Make context required

build.rs

@@ -83,7 +83,7 @@ fn avro_{name}() {{
     }};
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }}
 "##,
             name = case.name,
@@ -111,7 +111,7 @@ fn bigquery_{name}() {{
     }};
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }}
 "##,
             name = case.name,

src/ast.rs

@@ -507,10 +507,7 @@ impl Tag {
 impl TranslateFrom<jsonschema::Tag> for Tag {
     type Error = &'static str;
 
-    fn translate_from(
-        tag: jsonschema::Tag,
-        _context: Option<Context>,
-    ) -> Result<Self, Self::Error> {
+    fn translate_from(tag: jsonschema::Tag, _context: Context) -> Result<Self, Self::Error> {
         let mut tag = tag.type_into_ast();
         tag.infer_name();
         tag.infer_nullability();

src/avro.rs

@@ -108,7 +108,7 @@ impl Default for Type {
 impl TranslateFrom<ast::Tag> for Type {
     type Error = &'static str;
 
-    fn translate_from(tag: ast::Tag, context: Option<Context>) -> Result<Self, Self::Error> {
+    fn translate_from(tag: ast::Tag, context: Context) -> Result<Self, Self::Error> {
         let mut tag = tag;
         if tag.is_root {
             // Name inference is run only from the root for the proper
@@ -127,9 +127,7 @@ impl TranslateFrom<ast::Tag> for Type {
                 ast::Atom::Number => Primitive::Double,
                 ast::Atom::String => Primitive::String,
                 ast::Atom::Datetime => Primitive::String,
-                ast::Atom::JSON => {
-                    let context = context.unwrap();
-                    match context.resolve_method {
+                ast::Atom::JSON => match context.resolve_method {
                     ResolveMethod::Cast => {
                         warn!(
                             "{} - Treating subschema as JSON string",
@@ -139,8 +137,7 @@ impl TranslateFrom<ast::Tag> for Type {
                     }
                     ResolveMethod::Drop => return Err("json atom"),
                     ResolveMethod::Panic => panic!("json atom"),
-                    }
-                }
+                },
             }),
             ast::Type::Object(object) => {
                 let mut fields: Vec<Field> = if object.fields.is_empty() {
@@ -168,7 +165,6 @@ impl TranslateFrom<ast::Tag> for Type {
                 };
 
                 if fields.is_empty() {
-                    let context = context.unwrap();
                     match context.resolve_method {
                         ResolveMethod::Cast => {
                             warn!(
@@ -209,17 +205,14 @@ impl TranslateFrom<ast::Tag> for Type {
                 })),
                 Err(_) => return Err("untyped map value"),
             },
-            _ => {
-                let context = context.unwrap();
-                match context.resolve_method {
+            _ => match context.resolve_method {
                 ResolveMethod::Cast => {
                     warn!("{} - Unsupported conversion", tag.fully_qualified_name());
                     Type::Primitive(Primitive::String)
                 }
                 ResolveMethod::Panic => panic!(),
                 ResolveMethod::Drop => return Err("unsupported type"),
-                }
-            }
+            },
         };
         if tag.nullable && !tag.is_null() {
             Ok(Type::Union(vec![
@@ -251,7 +244,7 @@ mod tests {
             resolve_method: ResolveMethod::Cast,
         };
         let tag: ast::Tag = serde_json::from_value(ast).unwrap();
-        let from_tag = Type::translate_from(tag, Some(context)).unwrap();
+        let from_tag = Type::translate_from(tag, context).unwrap();
         assert_eq!(avro, json!(from_tag))
     }
 

src/bigquery.rs

@@ -58,7 +58,7 @@ pub struct Tag {
 impl TranslateFrom<ast::Tag> for Tag {
     type Error = &'static str;
 
-    fn translate_from(tag: ast::Tag, context: Option<Context>) -> Result<Self, Self::Error> {
+    fn translate_from(tag: ast::Tag, context: Context) -> Result<Self, Self::Error> {
         let mut tag = tag;
         tag.collapse();
         tag.infer_name();
@@ -70,9 +70,7 @@ impl TranslateFrom<ast::Tag> for Tag {
                 ast::Atom::Number => Atom::Float64,
                 ast::Atom::String => Atom::String,
                 ast::Atom::Datetime => Atom::Timestamp,
-                ast::Atom::JSON => {
-                    let context = context.unwrap();
-                    match context.resolve_method {
+                ast::Atom::JSON => match context.resolve_method {
                     ResolveMethod::Cast => {
                         warn!(
                             "{} - Treating subschema as JSON string",
@@ -84,8 +82,7 @@ impl TranslateFrom<ast::Tag> for Tag {
                     ResolveMethod::Drop => {
                         return Err("json atom");
                     }
-                    }
-                }
+                },
             }),
             ast::Type::Object(object) => {
                 let fields: HashMap<String, Box<Tag>> = if object.fields.is_empty() {
@@ -101,7 +98,6 @@ impl TranslateFrom<ast::Tag> for Tag {
                 };
 
                 if fields.is_empty() {
-                    let context = context.unwrap();
                     match context.resolve_method {
                         ResolveMethod::Cast => {
                             warn!(
@@ -133,17 +129,14 @@ impl TranslateFrom<ast::Tag> for Tag {
                     .collect();
                 Type::Record(Record { fields })
             }
-            _ => {
-                let context = context.unwrap();
-                match context.resolve_method {
+            _ => match context.resolve_method {
                 ResolveMethod::Cast => {
                     warn!("{} - Unsupported conversion", tag.fully_qualified_name());
                     Type::Atom(Atom::String)
                 }
                 ResolveMethod::Panic => panic!(),
                 ResolveMethod::Drop => return Err("unsupported type"),
-                }
-            }
+            },
         };
 
         let mode = if tag.is_array() || tag.is_map() {
@@ -176,7 +169,7 @@ pub enum Schema {
 impl TranslateFrom<ast::Tag> for Schema {
     type Error = &'static str;
 
-    fn translate_from(tag: ast::Tag, context: Option<Context>) -> Result<Self, Self::Error> {
+    fn translate_from(tag: ast::Tag, context: Context) -> Result<Self, Self::Error> {
         let mut bq_tag = Tag::translate_from(tag.clone(), context).unwrap();
         match *bq_tag.data_type {
             // Maps and arrays are both treated as a Record type with different
@@ -251,7 +244,7 @@ mod tests {
             resolve_method: ResolveMethod::Cast,
         };
         let ast_tag: ast::Tag = serde_json::from_value(data).unwrap();
-        let bq_tag: Tag = ast_tag.translate_into(Some(context)).unwrap();
+        let bq_tag: Tag = ast_tag.translate_into(context).unwrap();
         json!(bq_tag)
     }
 
@@ -260,7 +253,7 @@ mod tests {
             resolve_method: ResolveMethod::Cast,
         };
         let ast_tag: ast::Tag = serde_json::from_value(data).unwrap();
-        let bq_tag: Schema = ast_tag.translate_into(Some(context)).unwrap();
+        let bq_tag: Schema = ast_tag.translate_into(context).unwrap();
         json!(bq_tag)
     }
 

src/jsonschema.rs

@@ -235,7 +235,7 @@ mod tests {
             resolve_method: ResolveMethod::Cast,
         };
         let schema: Tag = serde_json::from_value(data).unwrap();
-        let ast: ast::Tag = schema.translate_into(Some(context)).unwrap();
+        let ast: ast::Tag = schema.translate_into(context).unwrap();
         json!(ast)
     }
 

src/lib.rs

@@ -27,7 +27,7 @@ pub struct Context {
     pub resolve_method: ResolveMethod,
 }
 
-fn into_ast(input: &Value, context: Option<Context>) -> ast::Tag {
+fn into_ast(input: &Value, context: Context) -> ast::Tag {
     let jsonschema: jsonschema::Tag = match serde_json::from_value(json!(input)) {
         Ok(tag) => tag,
         Err(e) => panic!(format!("{:#?}", e)),
@@ -36,13 +36,13 @@ fn into_ast(input: &Value, context: Option<Context>) -> ast::Tag {
 }
 
 /// Convert JSON Schema into an Avro compatible schema
-pub fn convert_avro(input: &Value, context: Option<Context>) -> Value {
+pub fn convert_avro(input: &Value, context: Context) -> Value {
     let avro = avro::Type::translate_from(into_ast(input, context), context).unwrap();
     json!(avro)
 }
 
 /// Convert JSON Schema into a BigQuery compatible schema
-pub fn convert_bigquery(input: &Value, context: Option<Context>) -> Value {
+pub fn convert_bigquery(input: &Value, context: Context) -> Value {
     let bq = bigquery::Schema::translate_from(into_ast(input, context), context).unwrap();
     json!(bq)
 }

src/main.rs

@@ -48,19 +48,13 @@ fn main() {
         None => Box::new(io::stdin()),
     };
     let data: Value = serde_json::from_reader(reader).unwrap();
-    let context: Option<Context> = match matches.value_of("resolve") {
-        Some(resolve) => {
-            let method = match resolve {
+    let context = Context {
+        resolve_method: match matches.value_of("resolve").unwrap() {
             "cast" => ResolveMethod::Cast,
             "panic" => ResolveMethod::Panic,
             "drop" => ResolveMethod::Drop,
             _ => panic!("Unknown resolution method!"),
-            };
-            Some(Context {
-                resolve_method: method,
-            })
-        }
-        None => None,
+        },
     };
 
     let output = match matches.value_of("type").unwrap() {

src/traits.rs

@@ -4,13 +4,13 @@ use super::Context;
 pub trait TranslateFrom<T>: Sized {
     type Error;
 
-    fn translate_from(value: T, context: Option<Context>) -> Result<Self, Self::Error>;
+    fn translate_from(value: T, context: Context) -> Result<Self, Self::Error>;
 }
 
 pub trait TranslateInto<T>: Sized {
     type Error;
 
-    fn translate_into(self, context: Option<Context>) -> Result<T, Self::Error>;
+    fn translate_into(self, context: Context) -> Result<T, Self::Error>;
 }
 
 // TranslateFrom implies TranslateInto
@@ -19,7 +19,7 @@ where
     U: TranslateFrom<T>,
 {
     type Error = U::Error;
-    fn translate_into(self, context: Option<Context>) -> Result<U, U::Error> {
+    fn translate_into(self, context: Context) -> Result<U, U::Error> {
         U::translate_from(self, context)
     }
 }

tests/resolve_method.rs

@@ -5,7 +5,7 @@ use serde_json::Value;
 #[test]
 fn test_bigquery_object_error_resolution() {
     let mut expected: Value;
-    let mut context: Option<Context>;
+    let mut context: Context;
 
     let input: Value = serde_json::from_str(
         r#"
@@ -38,9 +38,9 @@ fn test_bigquery_object_error_resolution() {
     )
     .unwrap();
 
-    context = Some(Context {
+    context = Context {
         resolve_method: ResolveMethod::Cast,
-    });
+    };
     assert_eq!(expected, convert_bigquery(&input, context));
 
     expected = serde_json::from_str(
@@ -55,21 +55,21 @@ fn test_bigquery_object_error_resolution() {
         "#,
     )
     .unwrap();
-    context = Some(Context {
+    context = Context {
         resolve_method: ResolveMethod::Drop,
-    });
+    };
     assert_eq!(expected, convert_bigquery(&input, context));
 
-    context = Some(Context {
+    context = Context {
         resolve_method: ResolveMethod::Panic,
-    });
+    };
     assert!(std::panic::catch_unwind(|| convert_bigquery(&input, context)).is_err());
 }
 
 #[test]
 fn test_avro_object_error_resolution() {
     let mut expected: Value;
-    let mut context: Option<Context>;
+    let mut context: Context;
 
     let input: Value = serde_json::from_str(
         r#"
@@ -112,9 +112,9 @@ fn test_avro_object_error_resolution() {
     )
     .unwrap();
 
-    context = Some(Context {
+    context = Context {
         resolve_method: ResolveMethod::Cast,
-    });
+    };
     assert_eq!(expected, convert_avro(&input, context));
 
     expected = serde_json::from_str(
@@ -136,13 +136,13 @@ fn test_avro_object_error_resolution() {
         "#,
     )
     .unwrap();
-    context = Some(Context {
+    context = Context {
         resolve_method: ResolveMethod::Drop,
-    });
+    };
     assert_eq!(expected, convert_avro(&input, context));
 
-    context = Some(Context {
+    context = Context {
         resolve_method: ResolveMethod::Panic,
-    });
+    };
     assert!(std::panic::catch_unwind(|| convert_avro(&input, context)).is_err());
 }

tests/transpile_avro.rs

@@ -26,7 +26,7 @@ fn avro_test_array_with_atomics() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -88,7 +88,7 @@ fn avro_test_array_with_complex() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -108,7 +108,7 @@ fn avro_test_atomic() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -136,7 +136,7 @@ fn avro_test_atomic_with_null() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -159,7 +159,7 @@ fn avro_test_incompatible_atomic_multitype() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -188,7 +188,7 @@ fn avro_test_incompatible_atomic_multitype_with_null() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -209,7 +209,7 @@ fn avro_test_datetime() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -235,7 +235,7 @@ fn avro_test_map_with_atomics() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -297,7 +297,7 @@ fn avro_test_map_with_complex() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -326,7 +326,7 @@ fn avro_test_map_with_pattern_properties() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -357,7 +357,7 @@ fn avro_test_map_with_pattern_and_additional_properties() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -389,7 +389,7 @@ fn avro_test_incompatible_map_with_pattern_properties() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -420,7 +420,7 @@ fn avro_test_incompatible_map_with_pattern_and_additional_properties() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -505,7 +505,7 @@ fn avro_test_object_with_atomics_is_sorted() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -567,7 +567,7 @@ fn avro_test_object_with_atomics_required() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -638,7 +638,7 @@ fn avro_test_object_with_atomics_required_with_null() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -714,7 +714,7 @@ fn avro_test_object_with_complex() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -735,7 +735,7 @@ fn avro_test_object_empty_record() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -762,7 +762,7 @@ fn avro_test_oneof_atomic() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -794,7 +794,7 @@ fn avro_test_oneof_atomic_with_null() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -821,7 +821,7 @@ fn avro_test_incompatible_oneof_atomic() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -856,7 +856,7 @@ fn avro_test_incompatible_oneof_atomic_with_null() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -926,7 +926,7 @@ fn avro_test_oneof_object_with_atomics() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -1008,7 +1008,7 @@ fn avro_test_oneof_object_merge() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -1151,7 +1151,7 @@ fn avro_test_oneof_object_merge_with_complex() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -1183,7 +1183,7 @@ fn avro_test_incompatible_oneof_atomic_and_object() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -1220,7 +1220,7 @@ fn avro_test_incompatible_oneof_object() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -1273,7 +1273,7 @@ fn avro_test_incompatible_oneof_object_with_complex() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }
 
 #[test]
@@ -1355,5 +1355,5 @@ fn avro_test_oneof_object_merge_nullability() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_avro(&input, Some(context)));
+    assert_eq!(expected, convert_avro(&input, context));
 }

tests/transpile_bigquery.rs

@@ -27,7 +27,7 @@ fn bigquery_test_array_with_atomics() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -74,7 +74,7 @@ fn bigquery_test_array_with_complex() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -98,7 +98,7 @@ fn bigquery_test_atomic() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -125,7 +125,7 @@ fn bigquery_test_atomic_with_null() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -152,7 +152,7 @@ fn bigquery_test_incompatible_atomic_multitype() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -180,7 +180,7 @@ fn bigquery_test_incompatible_atomic_multitype_with_null() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -205,7 +205,7 @@ fn bigquery_test_datetime() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -244,7 +244,7 @@ fn bigquery_test_map_with_atomics() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -303,7 +303,7 @@ fn bigquery_test_map_with_complex() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -345,7 +345,7 @@ fn bigquery_test_map_with_pattern_properties() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -389,7 +389,7 @@ fn bigquery_test_map_with_pattern_and_additional_properties() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -434,7 +434,7 @@ fn bigquery_test_incompatible_map_with_pattern_properties() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -478,7 +478,7 @@ fn bigquery_test_incompatible_map_with_pattern_and_additional_properties() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -531,7 +531,7 @@ fn bigquery_test_object_with_atomics_is_sorted() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -580,7 +580,7 @@ fn bigquery_test_object_with_atomics_required() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -632,7 +632,7 @@ fn bigquery_test_object_with_atomics_required_with_null() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -681,7 +681,7 @@ fn bigquery_test_object_with_complex() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -706,7 +706,7 @@ fn bigquery_test_object_empty_record() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -737,7 +737,7 @@ fn bigquery_test_oneof_atomic() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -768,7 +768,7 @@ fn bigquery_test_oneof_atomic_with_null() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -799,7 +799,7 @@ fn bigquery_test_incompatible_oneof_atomic() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -833,7 +833,7 @@ fn bigquery_test_incompatible_oneof_atomic_with_null() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -885,7 +885,7 @@ fn bigquery_test_oneof_object_with_atomics() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -942,7 +942,7 @@ fn bigquery_test_oneof_object_merge() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -1037,7 +1037,7 @@ fn bigquery_test_oneof_object_merge_with_complex() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -1073,7 +1073,7 @@ fn bigquery_test_incompatible_oneof_atomic_and_object() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -1114,7 +1114,7 @@ fn bigquery_test_incompatible_oneof_object() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -1171,7 +1171,7 @@ fn bigquery_test_incompatible_oneof_object_with_complex() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }
 
 #[test]
@@ -1234,5 +1234,5 @@ fn bigquery_test_oneof_object_merge_nullability() {
     };
     let input: Value = serde_json::from_str(input_data).unwrap();
     let expected: Value = serde_json::from_str(expected_data).unwrap();
-    assert_eq!(expected, convert_bigquery(&input, Some(context)));
+    assert_eq!(expected, convert_bigquery(&input, context));
 }