Improved error handling

envargs/errors.py

@@ -4,6 +4,11 @@
 class BaseError(Exception):
     """Base Error for when envparse fails."""
 
+    def __init__(self, message, **extra):
+        """Make a new error."""
+        self.message = message
+        self.extra = extra
+
 
 class ParseError(BaseError):
     """Specific Error for when a raw value cannot be parsed."""

envargs/helpers.py

@@ -0,0 +1,9 @@
+"""Smaller helper functions for taking care of repeated things."""
+
+
+def callables(potential_callables):
+    """Ensure that the callables are in fact a sequence."""
+    if callable(potential_callables):
+        return [potential_callables]
+
+    return potential_callables

envargs/models.py

@@ -1,5 +1,6 @@
 """Everthing about vars."""
 from . import errors
+from . import helpers
 
 
 class Var:
@@ -11,7 +12,7 @@ class Var:
     def __init__(self, use, validate=None, load_from=None, default=None, err_msg=None):
         """Return a new instance."""
         self.use = use
-        self.validate_with = validate
+        self.validate_with = helpers.callables(validate)
         self.load_from = load_from
         self.default = default
         self.err_msg = err_msg
@@ -25,29 +26,26 @@ def __repr__(self):
             self.default,
         )
 
-    def parse(self, value):
+    def parse(self, value, location):
         """Return the parsed value."""
         try:
             return self.use(value)
         except Exception as err:
             raise errors.ParseError(
-                'Could not parse value.'
+                'Parsing failed.',
+                value=value,
+                location=location,
             ) from err
 
-    def validate(self, value):
+    def validate(self, value, location):
         """Validate the parsed value."""
         if self.validate_with is None:
             return
 
-        if callable(self.validate_with):
-            if self.validate_with(value) is False:
+        for validator in self.validate_with:
+            if validator(value) is False:
                 raise errors.ValidationError(
-                    self.err_msg or 'Validation failed.'
+                    self.err_msg or 'Validation failed.',
+                    value=value,
+                    location=location,
                 )
-
-        elif isinstance(self.validate_with, (list, set, tuple)):
-            for validator in self.validate_with:
-                if validator(value) is False:
-                    raise errors.ValidationError(
-                        self.err_msg or 'Validation failed.'
-                    )

envargs/parser.py

@@ -12,10 +12,11 @@ def _load_values(values, fields):
         if value is None:
             raise errors.ParseError(
                 'Required field missing.',
+                location=location,
             )
 
-        value = field.parse(value)
-        field.validate(value)
+        value = field.parse(value, location)
+        field.validate(value, location)
         yield dest, value
 
 

setup.py

@@ -8,7 +8,7 @@
 
 setup(
     name='envargs',
-    version='0.1.0',
+    version='0.1.1',
 
     description='Parsing and validation of environment variables',
     long_description=long_description,

tests/test_errors.py

@@ -19,9 +19,14 @@ def test_parse_fail():
         'A_VAR': 'abc',
     }
 
-    with raises(errors.ParseError):
+    with raises(errors.ParseError) as err:
         parse_dict(values, args)
 
+    assert err.value.extra == {
+        'location': 'A_VAR',
+        'value': 'abc',
+    }
+
 
 def test_validation_with_lambda_fail():
     """Simple case that fails to validate."""
@@ -37,9 +42,14 @@ def test_validation_with_lambda_fail():
         'A_VAR': '1',
     }
 
-    with raises(errors.ValidationError):
+    with raises(errors.ValidationError) as err:
         parse_dict(values, args)
 
+    assert err.value.extra == {
+        'value': 1,
+        'location': 'A_VAR',
+    }
+
 
 def test_missing_value():
     """Test case that fails because of a missing value."""
@@ -53,15 +63,22 @@ def test_missing_value():
 
     values = {}
 
-    with raises(errors.ParseError):
+    with raises(errors.ParseError) as err:
         parse_dict(values, args)
 
+    assert err.value.extra == {
+        'location': 'A_VAR',
+    }
+
 
 def test_fancy_validation_function():
     """Test that fails to validate with a real function."""
     def validation_function(value):
         if value == 1:
-            raise errors.ValidationError
+            raise errors.ValidationError(
+                'Value not 1',
+                value=value,
+            )
 
     args = {
         'a_var': Var(
@@ -75,5 +92,9 @@ def validation_function(value):
         'A_VAR': '1',
     }
 
-    with raises(errors.ValidationError):
+    with raises(errors.ValidationError) as err:
         parse_dict(values, args)
+
+    assert err.value.extra == {
+        'value': 1,
+    }