wip

Author: dotansimha

Cargo.lock

@@ -11,11 +11,11 @@ documentation = "https://github.com/dotansimha/graphql-tools-rs"
 authors = ["Dotan Simha <[email protected]>"]
 
 [dependencies]
-graphql-parser = "^0.4.0"
+graphql-parser = { version = "0.5.0", package = "graphql-parser-hive-fork" }
 lazy_static = "1.4.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_with = "2.2.0"
 
 [dev-dependencies]
-graphql-parser = "0.4.0"
+graphql-parser = { version = "0.5.0", package = "graphql-parser-hive-fork" }

Cargo.toml

@@ -35,13 +35,14 @@ impl<'a> OperationVisitor<'a, ValidationErrorContext> for NoUnusedFragments<'a>
             .iter()
             .filter_map(|(fragment_name, _fragment)| {
                 if !self.fragments_in_use.contains(&fragment_name) {
-                    Some(fragment_name.clone())
+                    Some(fragment_name)
                 } else {
                     None
                 }
             })
             .for_each(|unused_fragment_name| {
-                user_context.report_error(ValidationError {error_code: self.error_code(),
+                user_context.report_error(ValidationError {
+                    error_code: self.error_code(),
                     locations: vec![],
                     message: format!("Fragment \"{}\" is never used.", unused_fragment_name),
                 });

src/validation/rules/no_unused_fragments.rs

@@ -779,7 +779,7 @@ impl<'a> OverlappingFieldsCanBeMerged<'a> {
                     let out_field_name = field.alias.as_ref().unwrap_or(field_name).as_str();
 
                     if !ast_and_defs.contains_key(out_field_name) {
-                        ast_and_defs.insert(out_field_name.clone(), Vec::new());
+                        ast_and_defs.insert(out_field_name, Vec::new());
                     }
 
                     ast_and_defs
@@ -852,7 +852,8 @@ impl<'a> OperationVisitor<'a, ValidationErrorContext> for OverlappingFieldsCanBe
         for Conflict(ConflictReason(reason_name, reason_msg), mut p1, p2) in found_conflicts {
             p1.extend(p2);
 
-            user_context.report_error(ValidationError {error_code: self.error_code(),
+            user_context.report_error(ValidationError {
+                error_code: self.error_code(),
                 message: error_message(&reason_name, &reason_msg),
                 locations: p1,
             });

src/validation/rules/overlapping_fields_can_be_merged.rs

@@ -36,7 +36,7 @@ impl<'a> UniqueFragmentNames<'a> {
 
     fn store_finding(&mut self, name: &'a str) {
         let value = *self.findings_counter.entry(name).or_insert(0);
-        self.findings_counter.insert(name.clone(), value + 1);
+        self.findings_counter.insert(name, value + 1);
     }
 }
 
@@ -58,7 +58,8 @@ impl<'u> ValidationRule for UniqueFragmentNames<'u> {
             .into_iter()
             .filter(|(_key, value)| *value > 1)
             .for_each(|(key, _value)| {
-                error_collector.report_error(ValidationError {error_code: self.error_code(),
+                error_collector.report_error(ValidationError {
+                    error_code: self.error_code(),
                     message: format!("There can be only one fragment named \"{}\".", key),
                     locations: vec![],
                 })

src/validation/rules/unique_fragment_names.rs

@@ -35,8 +35,8 @@ impl<'a> UniqueOperationNames<'a> {
     }
 
     fn store_finding(&mut self, name: &'a str) {
-        let value = *self.findings_counter.entry(name.clone()).or_insert(0);
-        self.findings_counter.insert(name.clone(), value + 1);
+        let value = *self.findings_counter.entry(name).or_insert(0);
+        self.findings_counter.insert(name, value + 1);
     }
 }
 
@@ -58,7 +58,8 @@ impl<'u> ValidationRule for UniqueOperationNames<'u> {
             .into_iter()
             .filter(|(_key, value)| *value > 1)
             .for_each(|(key, _value)| {
-                error_collector.report_error(ValidationError {error_code: self.error_code(),
+                error_collector.report_error(ValidationError {
+                    error_code: self.error_code(),
                     message: format!("There can be only one operation named \"{}\".", key),
                     locations: vec![],
                 })