(avro-rs) branch main updated: Minor enhancement to `parse_str_with_list` (#105)

[mgrigorov]

This is an automated email from the ASF dual-hosted git repository.

mgrigorov pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/avro-rs.git


The following commit(s) were added to refs/heads/main by this push:
     new 4411f75  Minor enhancement to `parse_str_with_list` (#105)
4411f75 is described below

commit 4411f750ce8bf2563c8d93fc574cfcf9593220dd
Author: Robert Yokota <rayok...@gmail.com>
AuthorDate: Sat Jan 18 10:46:16 2025 -0800

    Minor enhancement to `parse_str_with_list` (#105)
---
 avro/src/schema.rs | 51 ++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 48 insertions(+), 3 deletions(-)

diff --git a/avro/src/schema.rs b/avro/src/schema.rs
index 1757e98..93dbe18 100644
--- a/avro/src/schema.rs
+++ b/avro/src/schema.rs
@@ -1108,7 +1108,10 @@ impl Schema {
     /// # Arguments
     /// * `schema` - the JSON string of the schema to parse
     /// * `schemata` - a slice of additional schemas that is used to resolve 
cross-references
-    pub fn parse_str_with_list(schema: &str, schemata: &[&str]) -> 
AvroResult<Schema> {
+    pub fn parse_str_with_list(
+        schema: &str,
+        schemata: &[&str],
+    ) -> AvroResult<(Schema, Vec<Schema>)> {
         let mut input_schemas: HashMap<Name, Value> = 
HashMap::with_capacity(schemata.len());
         let mut input_order: Vec<Name> = Vec::with_capacity(schemata.len());
         for json in schemata {
@@ -1132,7 +1135,9 @@ impl Schema {
         parser.parse_input_schemas()?;
 
         let value = 
serde_json::from_str(schema).map_err(Error::ParseSchemaJson)?;
-        parser.parse(&value, &None)
+        let schema = parser.parse(&value, &None)?;
+        let schemata = parser.parse_list()?;
+        Ok((schema, schemata))
     }
 
     /// Create a `Schema` from a reader which implements [`Read`].
@@ -2761,7 +2766,44 @@ mod tests {
 
         let schema_str_c = r#"["A", "B"]"#;
 
-        let schema_c = Schema::parse_str_with_list(schema_str_c, 
&[schema_str_a, schema_str_b])?;
+        let (schema_c, schemata) =
+            Schema::parse_str_with_list(schema_str_c, &[schema_str_a, 
schema_str_b])?;
+
+        let schema_a_expected = Schema::Record(RecordSchema {
+            name: Name::new("A")?,
+            aliases: None,
+            doc: None,
+            fields: vec![RecordField {
+                name: "field_one".to_string(),
+                doc: None,
+                default: None,
+                aliases: None,
+                schema: Schema::Float,
+                order: RecordFieldOrder::Ignore,
+                position: 0,
+                custom_attributes: Default::default(),
+            }],
+            lookup: BTreeMap::from_iter(vec![("field_one".to_string(), 0)]),
+            attributes: Default::default(),
+        });
+
+        let schema_b_expected = Schema::Record(RecordSchema {
+            name: Name::new("B")?,
+            aliases: None,
+            doc: None,
+            fields: vec![RecordField {
+                name: "field_one".to_string(),
+                doc: None,
+                default: None,
+                aliases: None,
+                schema: Schema::Float,
+                order: RecordFieldOrder::Ignore,
+                position: 0,
+                custom_attributes: Default::default(),
+            }],
+            lookup: BTreeMap::from_iter(vec![("field_one".to_string(), 0)]),
+            attributes: Default::default(),
+        });
 
         let schema_c_expected = Schema::Union(UnionSchema::new(vec![
             Schema::Ref {
@@ -2773,6 +2815,9 @@ mod tests {
         ])?);
 
         assert_eq!(schema_c, schema_c_expected);
+        assert_eq!(schemata[0], schema_a_expected);
+        assert_eq!(schemata[1], schema_b_expected);
+
         Ok(())
     }