wip failing commit

Author: adriangb

src/input/input_abstract.rs

@@ -182,32 +182,6 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         self.strict_tuple()
     }
 
-    fn validate_set(&'a self, strict: bool) -> ValResult<GenericCollection<'a>> {
-        if strict {
-            self.strict_set()
-        } else {
-            self.lax_set()
-        }
-    }
-    fn strict_set(&'a self) -> ValResult<GenericCollection<'a>>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
-    fn lax_set(&'a self) -> ValResult<GenericCollection<'a>> {
-        self.strict_set()
-    }
-
-    fn validate_frozenset(&'a self, strict: bool) -> ValResult<GenericCollection<'a>> {
-        if strict {
-            self.strict_frozenset()
-        } else {
-            self.lax_frozenset()
-        }
-    }
-    fn strict_frozenset(&'a self) -> ValResult<GenericCollection<'a>>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
-    fn lax_frozenset(&'a self) -> ValResult<GenericCollection<'a>> {
-        self.strict_frozenset()
-    }
-
     fn validate_iter(&self) -> ValResult<GenericIterator>;
 
     fn validate_date(&self, strict: bool) -> ValResult<EitherDate> {

src/input/input_json.rs

@@ -199,30 +199,6 @@ impl<'a> Input<'a> for JsonInput {
         self.validate_tuple(false)
     }
 
-    fn validate_set(&'a self, _strict: bool) -> ValResult<GenericCollection<'a>> {
-        // we allow a list here since otherwise it would be impossible to create a set from JSON
-        match self {
-            JsonInput::Array(a) => Ok(a.into()),
-            _ => Err(ValError::new(ErrorType::SetType, self)),
-        }
-    }
-    #[cfg_attr(has_no_coverage, no_coverage)]
-    fn strict_set(&'a self) -> ValResult<GenericCollection<'a>> {
-        self.validate_set(false)
-    }
-
-    fn validate_frozenset(&'a self, _strict: bool) -> ValResult<GenericCollection<'a>> {
-        // we allow a list here since otherwise it would be impossible to create a frozenset from JSON
-        match self {
-            JsonInput::Array(a) => Ok(a.into()),
-            _ => Err(ValError::new(ErrorType::FrozenSetType, self)),
-        }
-    }
-    #[cfg_attr(has_no_coverage, no_coverage)]
-    fn strict_frozenset(&'a self) -> ValResult<GenericCollection<'a>> {
-        self.validate_frozenset(false)
-    }
-
     fn extract_iterable(&'a self) -> ValResult<super::any_iterable::GenericIterable<'a>> {
         match self {
             JsonInput::Array(a) => Ok(super::any_iterable::GenericIterable::JsonArray(a)),
@@ -414,24 +390,6 @@ impl<'a> Input<'a> for String {
         self.validate_tuple(false)
     }
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
-    fn validate_set(&'a self, _strict: bool) -> ValResult<GenericCollection<'a>> {
-        Err(ValError::new(ErrorType::SetType, self))
-    }
-    #[cfg_attr(has_no_coverage, no_coverage)]
-    fn strict_set(&'a self) -> ValResult<GenericCollection<'a>> {
-        self.validate_set(false)
-    }
-
-    #[cfg_attr(has_no_coverage, no_coverage)]
-    fn validate_frozenset(&'a self, _strict: bool) -> ValResult<GenericCollection<'a>> {
-        Err(ValError::new(ErrorType::FrozenSetType, self))
-    }
-    #[cfg_attr(has_no_coverage, no_coverage)]
-    fn strict_frozenset(&'a self) -> ValResult<GenericCollection<'a>> {
-        self.validate_frozenset(false)
-    }
-
     fn validate_iter(&self) -> ValResult<GenericIterator> {
         Ok(string_to_vec(self).into())
     }

src/input/input_python.rs

@@ -459,58 +459,6 @@ impl<'a> Input<'a> for PyAny {
         }
     }
 
-    fn strict_set(&'a self) -> ValResult<GenericCollection<'a>> {
-        if let Ok(set) = self.downcast::<PySet>() {
-            Ok(set.into())
-        } else {
-            Err(ValError::new(ErrorType::SetType, self))
-        }
-    }
-
-    fn lax_set(&'a self) -> ValResult<GenericCollection<'a>> {
-        if let Ok(set) = self.downcast::<PySet>() {
-            Ok(set.into())
-        } else if let Ok(list) = self.downcast::<PyList>() {
-            Ok(list.into())
-        } else if let Ok(tuple) = self.downcast::<PyTuple>() {
-            Ok(tuple.into())
-        } else if let Ok(frozen_set) = self.downcast::<PyFrozenSet>() {
-            Ok(frozen_set.into())
-        } else if let Some(collection) = extract_dict_iter!(self) {
-            Ok(collection)
-        } else if let Some(collection) = extract_shared_iter!(PyTuple, self) {
-            Ok(collection)
-        } else {
-            Err(ValError::new(ErrorType::SetType, self))
-        }
-    }
-
-    fn strict_frozenset(&'a self) -> ValResult<GenericCollection<'a>> {
-        if let Ok(set) = self.downcast::<PyFrozenSet>() {
-            Ok(set.into())
-        } else {
-            Err(ValError::new(ErrorType::FrozenSetType, self))
-        }
-    }
-
-    fn lax_frozenset(&'a self) -> ValResult<GenericCollection<'a>> {
-        if let Ok(frozen_set) = self.downcast::<PyFrozenSet>() {
-            Ok(frozen_set.into())
-        } else if let Ok(set) = self.downcast::<PySet>() {
-            Ok(set.into())
-        } else if let Ok(list) = self.downcast::<PyList>() {
-            Ok(list.into())
-        } else if let Ok(tuple) = self.downcast::<PyTuple>() {
-            Ok(tuple.into())
-        } else if let Some(collection) = extract_dict_iter!(self) {
-            Ok(collection)
-        } else if let Some(collection) = extract_shared_iter!(PyTuple, self) {
-            Ok(collection)
-        } else {
-            Err(ValError::new(ErrorType::FrozenSetType, self))
-        }
-    }
-
     fn extract_iterable(&'a self) -> ValResult<super::any_iterable::GenericIterable<'a>> {
         // Handle concrete non-overlapping types first, then abstract types
         if let Ok(iterable) = self.downcast::<PyList>() {

src/validators/dict.rs

@@ -150,7 +150,7 @@ impl Validator for DictValidator {
 
         let generic_iterable = input
             .extract_iterable()
-            .map_err(|_| ValError::new(ErrorType::ListType, input))?;
+            .map_err(|_| ValError::new(ErrorType::DictType, input))?;
         let output = match (generic_iterable, strict) {
             // Always allow actual dicts or JSON objects
             (GenericIterable::Dict(iter), _) => iterator::validate_mapping(
@@ -197,9 +197,9 @@ impl Validator for DictValidator {
                         false,
                     )
                 }
-                Err(_) => return Err(ValError::new(ErrorType::ListType, input)),
+                Err(_) => return Err(ValError::new(ErrorType::DictType, input)),
             },
-            _ => return Err(ValError::new(ErrorType::ListType, input)),
+            _ => return Err(ValError::new(ErrorType::DictType, input)),
         }?;
 
         Ok(output.into_py(py))