feat: Add custom exception messages (#13)

- Raise ValueError instead of generic Exception
- Create Custom Exceptions for each validation
- Update folder structure

Author: dinispeixoto

README.md

@@ -43,23 +43,23 @@ import checkarg.none_type as NoneType
 import checkarg.number as Number
 import checkarg.text as Text
 
-from checkarg.exceptions import ArgumentNoneException, ArgumentException, ArgumentOutOfRangeException
+from checkarg.exceptions import ArgumentNoneError, ArgumentError, ArgumentOutOfRangeError
 
 
 def lookup_name(mapping, key: str, default: int):
     try:
         Number.is_greater(default, 0)
-    except ArgumentOutOfRangeException:
+    except ArgumentOutOfRangeError:
         return None
 
     try:
         NoneType.is_not_none(mapping)
-    except ArgumentNoneException:
+    except ArgumentNoneError:
         return default
 
     try:
         Text.is_not_empty(key)
-    except (ArgumentException, ArgumentNoneException) as e:
+    except (ArgumentError, ArgumentNoneError) as e:
         return default
 
     return mapping[key]

checkarg/__init__.py

@@ -1,2 +1,2 @@
 __doc__ = "__init__"
-__version__ = "0.0.2"
+__version__ = "0.1.0"

checkarg/exceptions.py

@@ -0,0 +1,7 @@
+from .error_messages import (
+    DefaultErrorMessages,
+    NoneTypeErrorMessages,
+    NumberErrorMessages,
+    TextErrorMessages,
+)
+from .exceptions import ArgumentError, ArgumentNoneError, ArgumentOutOfRangeError

checkarg/exceptions/__init__.py

@@ -0,0 +1,83 @@
+class DefaultErrorMessages:
+    @staticmethod
+    def default_argument_message(argument_name):
+        return f"Argument name: {argument_name}"
+
+
+class NoneTypeErrorMessages:
+    @staticmethod
+    def not_none_message(argument_name):
+        return f"Argument {argument_name} shouldn't be None"
+
+
+class NumberErrorMessages:
+    @staticmethod
+    def is_greater_message(argument_name, value, condition_value):
+        return f"Argument {argument_name} with value {value} should be greater than {condition_value}"
+
+    @staticmethod
+    def is_lower_message(argument_name, value, condition_value):
+        return f"Argument {argument_name} with value {value} should be lower than {condition_value}"
+
+    @staticmethod
+    def is_greater_or_equals_message(argument_name, value, condition_value):
+        return f"Argument {argument_name} with value {value} should be greater than or equal to {condition_value}"
+
+    @staticmethod
+    def is_lower_or_equals_message(argument_name, value, condition_value):
+        return f"Argument {argument_name} with value {value} should be lower than or equal to {condition_value}"
+
+
+class TextErrorMessages:
+    @staticmethod
+    def is_not_whitespace_message(argument_name):
+        return f"Argument {argument_name} shouldn't be only whitespaces"
+
+    @staticmethod
+    def is_not_empty_message(argument_name):
+        return f"Argument {argument_name} shouldn't be empty"
+
+    @staticmethod
+    def is_alphanumeric_message(argument_name, value):
+        return f"Argument {argument_name} should be alphanumeric instead of {value}"
+
+    @staticmethod
+    def is_alphabetic_message(argument_name, value):
+        return f"Argument {argument_name} should be alphabetic instead of {value}"
+
+    @staticmethod
+    def is_number_message(argument_name, value):
+        return f"Argument {argument_name} should be a number instead of {value}"
+
+    @staticmethod
+    def is_integer_message(argument_name, value):
+        return f"Argument {argument_name} should be an integer instead of {value}"
+
+    @staticmethod
+    def is_lowercase_message(argument_name, value):
+        return f"Argument {argument_name} should be lowercase instead of {value}"
+
+    @staticmethod
+    def is_uppercase_message(argument_name, value):
+        return f"Argument {argument_name} should be uppercase instead of {value}"
+
+    @staticmethod
+    def has_length_message(argument_name, lenght_value, conditional_lenght):
+        return f"Argument {argument_name} should have lenght of {conditional_lenght} instead of {lenght_value}"
+
+    @staticmethod
+    def has_length_between_message(
+        argument_name, lenght_value, min_conditional_lenght, max_conditional_lenght
+    ):
+        return f"""
+            Argument {argument_name} should have lenght between
+            {min_conditional_lenght} and {max_conditional_lenght}
+            instead of {lenght_value}"""
+
+    @staticmethod
+    def is_equal_to_message(argument_name, value, conditional_value):
+        return f"Argument {argument_name} with value {value} should be equal to {conditional_value}"
+
+    @staticmethod
+    def is_not_equal_to_message(argument_name, value):
+        return f"Argument {argument_name} shouldn't be equal to {value}"

checkarg/exceptions/error_messages.py

@@ -0,0 +1,18 @@
+from .error_messages import DefaultErrorMessages
+
+
+class ArgumentError(ValueError):
+    def __init__(self, message, argument_name):
+        self.message = (
+            message
+            if message
+            else DefaultErrorMessages.default_argument_message(argument_name)
+        )
+
+
+class ArgumentNoneError(ArgumentError):
+    pass
+
+
+class ArgumentOutOfRangeError(ArgumentError):
+    pass

checkarg/exceptions/exceptions.py

@@ -1,6 +1,8 @@
-from checkarg.exceptions import ArgumentNoneException
+from checkarg.exceptions import ArgumentNoneError, NoneTypeErrorMessages
 
 
 def is_not_none(value, argument_name: str = None, exception: Exception = None):
     if value is None:
-        raise ArgumentNoneException(argument_name) if exception is None else exception
+        raise ArgumentNoneError(
+            NoneTypeErrorMessages.not_none_message(argument_name), argument_name
+        ) if exception is None else exception

checkarg/none_type.py

@@ -1,6 +1,6 @@
 from typing import Union
 
-from checkarg.exceptions import ArgumentOutOfRangeException
+from checkarg.exceptions import ArgumentOutOfRangeError, NumberErrorMessages
 
 
 def is_greater(
@@ -10,8 +10,11 @@ def is_greater(
     exception: Exception = None,
 ):
     if value < condition_value:
-        raise ArgumentOutOfRangeException(
-            argument_name
+        raise ArgumentOutOfRangeError(
+            NumberErrorMessages.is_greater_message(
+                argument_name, value, condition_value
+            ),
+            argument_name,
         ) if exception is None else exception
 
 
@@ -22,8 +25,9 @@ def is_lower(
     exception: Exception = None,
 ):
     if value > condition_value:
-        raise ArgumentOutOfRangeException(
-            argument_name
+        raise ArgumentOutOfRangeError(
+            NumberErrorMessages.is_lower_message(argument_name, value, condition_value),
+            argument_name,
         ) if exception is None else exception
 
 
@@ -34,8 +38,11 @@ def is_greater_or_equals(
     exception: Exception = None,
 ):
     if value < condition_value:
-        raise ArgumentOutOfRangeException(
-            argument_name
+        raise ArgumentOutOfRangeError(
+            NumberErrorMessages.is_greater_or_equals_message(
+                argument_name, value, condition_value
+            ),
+            argument_name,
         ) if exception is None else exception
 
 
@@ -46,6 +53,9 @@ def is_lower_or_equals(
     exception: Exception = None,
 ):
     if value > condition_value:
-        raise ArgumentOutOfRangeException(
-            argument_name
+        raise ArgumentOutOfRangeError(
+            NumberErrorMessages.is_lower_or_equals_message(
+                argument_name, value, condition_value
+            ),
+            argument_name,
         ) if exception is None else exception

checkarg/number.py

@@ -1,15 +1,17 @@
 from typing import List, Union
 
 import checkarg.none_type as NoneType
-from checkarg.exceptions import ArgumentException
+from checkarg.exceptions import ArgumentError, TextErrorMessages
 
 
 def is_not_whitespace(
     value: str, argument_name: str = None, exception: Exception = None
 ) -> None:
     NoneType.is_not_none(value, argument_name, exception)
     if len(value.strip()) <= 0:
-        raise ArgumentException(argument_name) if exception is None else exception
+        raise ArgumentError(
+            TextErrorMessages.is_not_whitespace_message(argument_name), argument_name
+        ) if exception is None else exception
 
 
 def is_not_empty(
@@ -19,23 +21,30 @@ def is_not_empty(
     if isinstance(value, str):
         value = value.strip()
     if len(value) <= 0:
-        raise ArgumentException(argument_name) if exception is None else exception
+        raise ArgumentError(
+            TextErrorMessages.is_not_empty_message(argument_name), argument_name
+        ) if exception is None else exception
 
 
 def is_alphanumeric(
     value: str, argument_name: str = None, exception: Exception = None
 ) -> None:
     NoneType.is_not_none(value, argument_name, exception)
     if not value.isalnum():
-        raise ArgumentException(argument_name) if exception is None else exception
+        raise ArgumentError(
+            TextErrorMessages.is_alphanumeric_message(argument_name, value),
+            argument_name,
+        ) if exception is None else exception
 
 
 def is_alphabetic(
     value: str, argument_name: str = None, exception: Exception = None
 ) -> None:
     NoneType.is_not_none(value, argument_name, exception)
     if not value.isalpha():
-        raise ArgumentException(argument_name) if exception is None else exception
+        raise ArgumentError(
+            TextErrorMessages.is_alphabetic_message(argument_name, value), argument_name
+        ) if exception is None else exception
 
 
 def is_number(
@@ -45,7 +54,9 @@ def is_number(
     try:
         float(value)
     except Exception:
-        raise ArgumentException(argument_name) if exception is None else exception
+        raise ArgumentError(
+            TextErrorMessages.is_number_message(argument_name, value), argument_name
+        ) if exception is None else exception
 
 
 def is_integer(
@@ -55,31 +66,40 @@ def is_integer(
     try:
         int(value)
     except Exception:
-        raise ArgumentException(argument_name) if exception is None else exception
+        raise ArgumentError(
+            TextErrorMessages.is_integer_message(argument_name, value), argument_name
+        ) if exception is None else exception
 
 
 def is_lowercase(
     value: str, argument_name: str = None, exception: Exception = None
 ) -> None:
     NoneType.is_not_none(value, argument_name, exception)
     if not value.islower():
-        raise ArgumentException(argument_name) if exception is None else exception
+        raise ArgumentError(
+            TextErrorMessages.is_lowercase_message(argument_name, value), argument_name
+        ) if exception is None else exception
 
 
 def is_uppercase(
     value: str, argument_name: str = None, exception: Exception = None
 ) -> None:
     NoneType.is_not_none(value, argument_name, exception)
     if not value.isupper():
-        raise ArgumentException(argument_name) if exception is None else exception
+        raise ArgumentError(
+            TextErrorMessages.is_uppercase_message(argument_name, value), argument_name
+        ) if exception is None else exception
 
 
 def has_length(
     value: str, length: int, argument_name: str = None, exception: Exception = None
 ) -> None:
     NoneType.is_not_none(value, argument_name, exception)
     if len(value) != length:
-        raise ArgumentException(argument_name) if exception is None else exception
+        raise ArgumentError(
+            TextErrorMessages.has_length_message(argument_name, len(value), length),
+            argument_name,
+        ) if exception is None else exception
 
 
 def has_length_between(
@@ -92,20 +112,31 @@ def has_length_between(
     NoneType.is_not_none(value, argument_name, exception)
     value_length = len(value)
     if value_length < min_lenght or value_length > max_lenght:
-        raise ArgumentException(argument_name) if exception is None else exception
+        raise ArgumentError(
+            TextErrorMessages.has_length_between_message(
+                argument_name, len(value), min_lenght, max_lenght
+            ),
+            argument_name,
+        ) if exception is None else exception
 
 
 def is_equal_to(
     value: str, expected: str, argument_name: str = None, exception: Exception = None
 ) -> None:
     NoneType.is_not_none(value, argument_name, exception)
     if value != expected:
-        raise ArgumentException(argument_name) if exception is None else exception
+        raise ArgumentError(
+            TextErrorMessages.is_equal_to_message(argument_name, value, expected),
+            argument_name,
+        ) if exception is None else exception
 
 
 def is_not_equal_to(
     value: str, expected: str, argument_name: str = None, exception: Exception = None
 ) -> None:
     NoneType.is_not_none(value, argument_name, exception)
     if value == expected:
-        raise ArgumentException(argument_name) if exception is None else exception
+        raise ArgumentError(
+            TextErrorMessages.is_not_equal_to_message(argument_name, value),
+            argument_name,
+        ) if exception is None else exception

checkarg/text.py

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.0.2
+current_version = 0.1.0
 
 [bumpversion:file:checkarg/__init__.py]