Fix typo. #297

derive/src/input_object.rs

@@ -75,7 +75,7 @@ pub fn generate(object_args: &args::InputObject) -> GeneratorResult<TokenStream>
             get_fields.push(quote! {
                 let #ident: #ty = #crate_name::InputValueType::parse(
                     Some(#crate_name::Value::Object(obj.clone()))
-                ).map_err(#crate_name::InputValueError::propogate)?;
+                ).map_err(#crate_name::InputValueError::propagate)?;
             });
 
             fields.push(ident);
@@ -111,7 +111,7 @@ pub fn generate(object_args: &args::InputObject) -> GeneratorResult<TokenStream>
                 let #ident: #ty = {
                     match obj.get(#name) {
                         Some(value) => #crate_name::InputValueType::parse(Some(value.clone()))
-                            .map_err(#crate_name::InputValueError::propogate)?,
+                            .map_err(#crate_name::InputValueError::propagate)?,
                         None => #default,
                     }
                 };
@@ -119,7 +119,7 @@ pub fn generate(object_args: &args::InputObject) -> GeneratorResult<TokenStream>
         } else {
             get_fields.push(quote! {
                 let #ident: #ty = #crate_name::InputValueType::parse(obj.get(#name).cloned())
-                    .map_err(#crate_name::InputValueError::propogate)?;
+                    .map_err(#crate_name::InputValueError::propagate)?;
             });
         }
 

src/error.rs

@@ -122,8 +122,8 @@ impl<T: InputValueType> InputValueError<T> {
         Self::new(format!(r#"Failed to parse "{}": {}"#, T::type_name(), msg))
     }
 
-    /// Propogate the error message to a different type.
-    pub fn propogate<U: InputValueType>(self) -> InputValueError<U> {
+    /// Propagate the error message to a different type.
+    pub fn propagate<U: InputValueType>(self) -> InputValueError<U> {
         InputValueError::new(format!(
             r#"{} (occurred while parsing "{}")"#,
             self.message,

src/types/external/bson.rs

@@ -24,7 +24,7 @@ impl ScalarType for ObjectId {
 impl ScalarType for UtcDateTime {
     fn parse(value: Value) -> InputValueResult<Self> {
         <DateTime<Utc>>::parse(value)
-            .map_err(InputValueError::propogate)
+            .map_err(InputValueError::propagate)
             .map(UtcDateTime::from)
     }
 

src/types/external/json_object/btreemap.rs

@@ -16,7 +16,7 @@ where
                 .into_iter()
                 .map(|(name, value)| Ok((name.into_string(), T::parse(Some(value))?)))
                 .collect::<Result<_, _>>()
-                .map_err(InputValueError::propogate),
+                .map_err(InputValueError::propagate),
             _ => Err(InputValueError::expected_type(value)),
         }
     }

src/types/external/json_object/hashmap.rs

@@ -16,7 +16,7 @@ where
                 .into_iter()
                 .map(|(name, value)| Ok((name.into_string(), T::parse(Some(value))?)))
                 .collect::<Result<_, _>>()
-                .map_err(InputValueError::propogate),
+                .map_err(InputValueError::propagate),
             _ => Err(InputValueError::expected_type(value)),
         }
     }

src/types/external/list/btree_set.rs

@@ -29,11 +29,11 @@ impl<T: InputValueType + Ord> InputValueType for BTreeSet<T> {
                 .into_iter()
                 .map(|value| InputValueType::parse(Some(value)))
                 .collect::<Result<_, _>>()
-                .map_err(InputValueError::propogate),
+                .map_err(InputValueError::propagate),
             value => Ok({
                 let mut result = Self::default();
                 result.insert(
-                    InputValueType::parse(Some(value)).map_err(InputValueError::propogate)?,
+                    InputValueType::parse(Some(value)).map_err(InputValueError::propagate)?,
                 );
                 result
             }),

src/types/external/list/hash_set.rs

@@ -31,11 +31,11 @@ impl<T: InputValueType + Hash + Eq> InputValueType for HashSet<T> {
                 .into_iter()
                 .map(|value| InputValueType::parse(Some(value)))
                 .collect::<Result<_, _>>()
-                .map_err(InputValueError::propogate),
+                .map_err(InputValueError::propagate),
             value => Ok({
                 let mut result = Self::default();
                 result.insert(
-                    InputValueType::parse(Some(value)).map_err(InputValueError::propogate)?,
+                    InputValueType::parse(Some(value)).map_err(InputValueError::propagate)?,
                 );
                 result
             }),

src/types/external/list/linked_list.rs

@@ -29,11 +29,11 @@ impl<T: InputValueType> InputValueType for LinkedList<T> {
                 .into_iter()
                 .map(|value| InputValueType::parse(Some(value)))
                 .collect::<Result<_, _>>()
-                .map_err(InputValueError::propogate),
+                .map_err(InputValueError::propagate),
             value => Ok({
                 let mut result = Self::default();
                 result.push_front(
-                    InputValueType::parse(Some(value)).map_err(InputValueError::propogate)?,
+                    InputValueType::parse(Some(value)).map_err(InputValueError::propagate)?,
                 );
                 result
             }),

src/types/external/list/vec.rs

@@ -28,9 +28,9 @@ impl<T: InputValueType> InputValueType for Vec<T> {
                 .into_iter()
                 .map(|value| InputValueType::parse(Some(value)))
                 .collect::<Result<_, _>>()
-                .map_err(InputValueError::propogate),
+                .map_err(InputValueError::propagate),
             value => Ok(vec![
-                InputValueType::parse(Some(value)).map_err(InputValueError::propogate)?
+                InputValueType::parse(Some(value)).map_err(InputValueError::propagate)?
             ]),
         }
     }

src/types/external/list/vec_deque.rs

@@ -29,11 +29,11 @@ impl<T: InputValueType> InputValueType for VecDeque<T> {
                 .into_iter()
                 .map(|value| InputValueType::parse(Some(value)))
                 .collect::<Result<_, _>>()
-                .map_err(InputValueError::propogate),
+                .map_err(InputValueError::propagate),
             value => Ok({
                 let mut result = Self::default();
                 result.push_back(
-                    InputValueType::parse(Some(value)).map_err(InputValueError::propogate)?,
+                    InputValueType::parse(Some(value)).map_err(InputValueError::propagate)?,
                 );
                 result
             }),

src/types/external/optional.rs

@@ -25,7 +25,7 @@ impl<T: InputValueType> InputValueType for Option<T> {
         match value.unwrap_or_default() {
             Value::Null => Ok(None),
             value => Ok(Some(
-                T::parse(Some(value)).map_err(InputValueError::propogate)?,
+                T::parse(Some(value)).map_err(InputValueError::propagate)?,
             )),
         }
     }

src/types/maybe_undefined.rs

@@ -130,7 +130,7 @@ impl<T: InputValueType> InputValueType for MaybeUndefined<T> {
             None => Ok(MaybeUndefined::Undefined),
             Some(Value::Null) => Ok(MaybeUndefined::Null),
             Some(value) => Ok(MaybeUndefined::Value(
-                T::parse(Some(value)).map_err(InputValueError::propogate)?,
+                T::parse(Some(value)).map_err(InputValueError::propagate)?,
             )),
         }
     }