Finished implementing skip_serializing_none feature

Author: Selyatin

graphql_client_codegen/src/codegen/inputs.rs

@@ -29,7 +29,7 @@ pub(super) fn generate_input_object_definitions(
                 let normalized_field_type_name = options
                     .normalization()
                     .field_type(field_type.id.name(query.schema));
-                let optional_skip_none = if *options.skip_none() && field_type.is_optional() {
+                let optional_skip_serializing_none = if *options.skip_serializing_none() && field_type.is_optional() {
                     Some(quote!(#[serde(skip_serializing_if = "Option::is_none")]))
                 } else {
                     None
@@ -48,7 +48,7 @@ pub(super) fn generate_input_object_definitions(
                 };
 
                 quote!(
-                    #optional_skip_none
+                    #optional_skip_serializing_none
                     #annotation pub #name_ident: #field_type
                 )
             });

graphql_client_codegen/src/codegen/selection.rs

@@ -405,7 +405,7 @@ impl<'a> ExpandedField<'a> {
             qualified_type
         };
 
-        let optional_skip_none = if *options.skip_none()
+        let optional_skip_serializing_none = if *options.skip_serializing_none()
             && self
                 .field_type_qualifiers
                 .get(0)
@@ -439,7 +439,7 @@ impl<'a> ExpandedField<'a> {
             };
 
         let tokens = quote! {
-            #optional_skip_none
+            #optional_skip_serializing_none
             #optional_flatten
             #optional_rename
             #optional_deprecation_annotation

graphql_client_codegen/src/codegen_options.rs

@@ -46,7 +46,7 @@ pub struct GraphQLClientCodegenOptions {
     /// Flag to trigger generation of Other variant for fragments Enum
     fragments_other_variant: bool,
     /// Skip Serialization of None values.
-    skip_none: bool,
+    skip_serializing_none: bool,
 }
 
 impl GraphQLClientCodegenOptions {
@@ -67,7 +67,7 @@ impl GraphQLClientCodegenOptions {
             custom_scalars_module: Default::default(),
             extern_enums: Default::default(),
             fragments_other_variant: Default::default(),
-            skip_none: Default::default(),
+            skip_serializing_none: Default::default(),
         }
     }
 
@@ -219,12 +219,12 @@ impl GraphQLClientCodegenOptions {
     }
 
     /// Set the graphql client codegen option's skip none value.
-    pub fn set_skip_none(&mut self, skip_none: bool) {
-        self.skip_none = skip_none
+    pub fn set_skip_serializing_none(&mut self, skip_serializing_none: bool) {
+        self.skip_serializing_none = skip_serializing_none
     }
 
     /// Get a reference to the graphql client codegen option's skip none value.
-    pub fn skip_none(&self) -> &bool {
-        &self.skip_none
+    pub fn skip_serializing_none(&self) -> &bool {
+        &self.skip_serializing_none
     }
 }

graphql_client_codegen/src/tests/mod.rs

@@ -119,7 +119,7 @@ fn fragments_other_variant_false_should_not_generate_unknown_other_variant() {
 }
 
 #[test]
-fn skip_none_should_generate_serde_skip_serializing() {
+fn skip_serializing_none_should_generate_serde_skip_serializing() {
     let query_string = include_str!("keywords_query.graphql");
     let query = graphql_parser::parse_query::<&str>(query_string).expect("Parse keywords query");
     let schema = graphql_parser::parse_schema(include_str!("keywords_schema.graphql"))
@@ -129,7 +129,7 @@ fn skip_none_should_generate_serde_skip_serializing() {
 
     let mut options = GraphQLClientCodegenOptions::new(CodegenMode::Cli);
 
-    options.set_skip_none(true);
+    options.set_skip_serializing_none(true);
 
     let query = crate::query::resolve(&schema, &query).unwrap();
 

graphql_query_derive/src/attributes.rs

@@ -103,8 +103,8 @@ pub fn extract_fragments_other_variant(ast: &syn::DeriveInput) -> bool {
         .unwrap_or(false)
 }
 
-pub fn extract_skip_none(ast: &syn::DeriveInput) -> bool {
-    extract_attr(ast, "skip_none")
+pub fn extract_skip_serializing_none(ast: &syn::DeriveInput) -> bool {
+    extract_attr(ast, "skip_serializing_none")
         .ok()
         .and_then(|s| FromStr::from_str(s.as_str()).ok())
         .unwrap_or(false)
@@ -228,52 +228,52 @@ mod test {
     }
 
     #[test]
-    fn test_skip_none_set_to_true() {
+    fn test_skip_serializing_none_set_to_true() {
         let input = r#"
             #[derive(GraphQLQuery)]
             #[graphql(
                 schema_path = "x",
                 query_path = "x",
-                skip_none = "true"
+                skip_serializing_none = "true"
             )]
             struct MyQuery;
         "#;
         let parsed = syn::parse_str(input).unwrap();
-        assert!(extract_skip_none(&parsed));
+        assert!(extract_skip_serializing_none(&parsed));
     }
 
     #[test]
-    fn test_skip_none_set_to_false() {
+    fn test_skip_serializing_none_set_to_false() {
         let input = r#"
             #[derive(GraphQLQuery)]
             #[graphql(
                 schema_path = "x",
                 query_path = "x",
-                skip_none = "false"
+                skip_serializing_none = "false"
             )]
             struct MyQuery;
         "#;
         let parsed = syn::parse_str(input).unwrap();
-        assert!(!extract_skip_none(&parsed));
+        assert!(!extract_skip_serializing_none(&parsed));
     }
 
     #[test]
-    fn test_skip_none_set_to_invalid() {
+    fn test_skip_serializing_none_set_to_invalid() {
         let input = r#"
             #[derive(GraphQLQuery)]
             #[graphql(
                 schema_path = "x",
                 query_path = "x",
-                skip_none = "invalid"
+                skip_serializing_none = "invalid"
             )]
             struct MyQuery;
         "#;
         let parsed = syn::parse_str(input).unwrap();
-        assert!(!extract_skip_none(&parsed));
+        assert!(!extract_skip_serializing_none(&parsed));
     }
 
     #[test]
-    fn test_skip_none_unset() {
+    fn test_skip_serializing_none_unset() {
         let input = r#"
             #[derive(GraphQLQuery)]
             #[graphql(
@@ -283,6 +283,6 @@ mod test {
             struct MyQuery;
         "#;
         let parsed = syn::parse_str(input).unwrap();
-        assert!(!extract_skip_none(&parsed));
+        assert!(!extract_skip_serializing_none(&parsed));
     }
 }

graphql_query_derive/src/lib.rs

@@ -64,12 +64,12 @@ fn build_graphql_client_derive_options(
     let custom_scalars_module = attributes::extract_attr(input, "custom_scalars_module").ok();
     let extern_enums = attributes::extract_attr_list(input, "extern_enums").ok();
     let fragments_other_variant: bool = attributes::extract_fragments_other_variant(input);
-    let skip_none: bool = attributes::extract_skip_none(input);
+    let skip_serializing_none: bool = attributes::extract_skip_serializing_none(input);
 
     let mut options = GraphQLClientCodegenOptions::new(CodegenMode::Derive);
     options.set_query_file(query_path);
     options.set_fragments_other_variant(fragments_other_variant);
-    options.set_skip_none(skip_none);
+    options.set_skip_serializing_none(skip_serializing_none);
 
     if let Some(variables_derives) = variables_derives {
         options.set_variables_derives(variables_derives);