consolidate

Author: sydney-runkle

src/input/input_abstract.rs

@@ -98,18 +98,7 @@ pub trait Input<'py>: fmt::Debug + ToPyObject {
 
     fn validate_float(&self, strict: bool) -> ValMatch<EitherFloat<'_>>;
 
-    fn validate_decimal(&self, strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
-        if strict {
-            self.strict_decimal(py)
-        } else {
-            self.lax_decimal(py)
-        }
-    }
-    fn strict_decimal(&self, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>>;
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_decimal(&self, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
-        self.strict_decimal(py)
-    }
+    fn validate_decimal(&self, strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>>;
 
     type Dict<'a>: ValidatedDict<'py>
     where

src/input/input_json.rs

@@ -165,7 +165,7 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
         }
     }
 
-    fn strict_decimal(&self, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
+    fn validate_decimal(&self, _strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
         match self {
             JsonValue::Float(f) => {
                 create_decimal(&PyString::new_bound(py, &f.to_string()), self).map(ValidationMatch::strict)
@@ -374,8 +374,8 @@ impl<'py> Input<'py> for str {
         str_as_float(self, self).map(ValidationMatch::lax)
     }
 
-    fn strict_decimal(&self, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
-        create_decimal(self.to_object(py).bind(py), self).map(ValidationMatch::strict)
+    fn validate_decimal(&self, _strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
+        create_decimal(self.to_object(py).bind(py), self).map(ValidationMatch::lax)
     }
 
     type Dict<'a> = Never;

src/input/input_python.rs

@@ -248,7 +248,7 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
                     str_as_int(self, s)
                 } else if self.is_exact_instance_of::<PyFloat>() {
                     float_as_int(self, self.extract::<f64>()?)
-                } else if let Ok(decimal) = self.strict_decimal(self.py()) {
+                } else if let Ok(decimal) = self.validate_decimal(strict, self.py()) {
                     decimal_as_int(self, &decimal.into_inner())
                 } else if let Ok(float) = self.extract::<f64>() {
                     float_as_int(self, float)
@@ -307,51 +307,38 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         Err(ValError::new(ErrorTypeDefaults::FloatType, self))
     }
 
-    fn strict_decimal(&self, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
+    fn validate_decimal(&self, strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
         let decimal_type = get_decimal_type(py);
-        // Fast path for existing decimal objects
-        if self.is_exact_instance(decimal_type) {
-            return Ok(ValidationMatch::exact(self.to_owned()));
-        }
-
-        // Try subclasses of decimals, they will be upcast to Decimal
-        if self.is_instance(decimal_type)? {
-            return create_decimal(self, self).map(ValidationMatch::strict);
-        }
-
-        Err(ValError::new(
-            ErrorType::IsInstanceOf {
-                class: decimal_type
-                    .qualname()
-                    .and_then(|name| name.extract())
-                    .unwrap_or_else(|_| "Decimal".to_owned()),
-                context: None,
-            },
-            self,
-        ))
-    }
 
-    fn lax_decimal(&self, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
-        let decimal_type = get_decimal_type(py);
         // Fast path for existing decimal objects
         if self.is_exact_instance(decimal_type) {
-            return Ok(ValidationMatch::exact(self.to_owned().clone()));
-        }
-
-        // TODO: I can see the case for int and float being strict - wdyt @davidhewitt?
-        return if self.is_instance_of::<PyString>()
-            || (self.is_instance_of::<PyInt>() && !self.is_instance_of::<PyBool>())
-        {
-            // checking isinstance for str / int / bool is fast compared to decimal / float
-            create_decimal(self, self).map(ValidationMatch::lax)
+            Ok(ValidationMatch::exact(self.to_owned().clone()))
         } else if self.is_instance(decimal_type)? {
-            // upcast subclasses to decimal
+            // Upcast subclasses to decimal
             create_decimal(self, self).map(ValidationMatch::strict)
-        } else if self.is_instance_of::<PyFloat>() {
-            create_decimal(self.str()?.as_any(), self).map(ValidationMatch::lax)
         } else {
-            Err(ValError::new(ErrorTypeDefaults::DecimalType, self))
-        };
+            if strict {
+                return Err(ValError::new(
+                    ErrorType::IsInstanceOf {
+                        class: decimal_type
+                            .qualname()
+                            .and_then(|name| name.extract())
+                            .unwrap_or_else(|_| "Decimal".to_owned()),
+                        context: None,
+                    },
+                    self,
+                ));
+            }
+            if self.is_instance_of::<PyString>() || (self.is_instance_of::<PyInt>() && !self.is_instance_of::<PyBool>())
+            {
+                // Checking isinstance for str / int / bool is fast compared to decimal / float
+                create_decimal(self, self).map(ValidationMatch::lax)
+            } else if self.is_instance_of::<PyFloat>() {
+                create_decimal(self.str()?.as_any(), self).map(ValidationMatch::lax)
+            } else {
+                Err(ValError::new(ErrorTypeDefaults::DecimalType, self))
+            }
+        }
     }
 
     type Dict<'a> = GenericPyMapping<'a, 'py> where Self: 'a;

src/input/input_string.rs

@@ -141,7 +141,7 @@ impl<'py> Input<'py> for StringMapping<'py> {
         }
     }
 
-    fn strict_decimal(&self, _py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
+    fn validate_decimal(&self, _strict: bool, _py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
         match self {
             Self::String(s) => create_decimal(s, self).map(ValidationMatch::strict),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::DecimalType, self)),