safeshield 1.5.1__py3-none-any.whl → 1.5.3__py3-none-any.whl

validator/rules/utilities.py

@@ -4,247 +4,393 @@ from .basic import *
 from .boolean import AcceptedRule, DeclinedRule
 
 class RequiredIfRule(RequiredRule):
+    _count_parameter = 2
+    _accept_closure = True
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) == 1 and callable(params[0]):
+        if callable(params[0]):
             condition_met = params[0](self.validator.data)
-        elif len(params) == 1 and isinstance(params[0], bool):
+        elif isinstance(params[0], bool):
             condition_met = params[0]
         else:  
-            conditions = list(zip(params[::2], params[1::2]))
+            expected_value = self.get_field_value(params[0], False)
+            conditions = params[1:]
             
-            condition_met = any(
-                str(self.get_field_value(field, '')) == str(expected_value)
-                for field, expected_value in conditions
-                if field and expected_value is not None
-            )
+            condition_met = expected_value in conditions
                 
         if condition_met:
             return super().validate(field, value, params)
         
         return True
     
-class RequiredUnlessRule(RequiredRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2:
-            return False
-            
-        other_field, other_value = params[0], params[1]
-        actual_value = self.get_field_value(other_field, '') 
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':other': self._get_display_name(self._params[0]),
+            ':values': ', '.join(self._params[1:]),
+        }
         
-        if actual_value == other_value:
-            return True
-            
-        return super().validate(field, value, params)
+        return replacements
+    
+class RequiredUnlessRule(RequiredRule):
+    _count_parameter = 2
+    _accept_closure = True
     
-class RequiredAllIfRule(RequiredRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2:
-            return False
+        if callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif isinstance(params[0], bool):
+            condition_met = params[0]
+        else:  
+            expected_value = self.get_field_value(params[0], False)
+            conditions = params[1:]
             
-        conditions = [(f.strip(), v.strip()) for f, v in zip(params[::2], params[1::2])]
+            condition_met = expected_value in conditions
+                
+        if not condition_met:
+            return super().validate(field, value, params)
         
-        all_conditions_met = all(
-            self.get_field_value(f) == v 
-            for f, v in conditions
-        )
+        return True
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':other': self._get_display_name(self._params[0]),
+            ':values': ', '.join(self._params[1:]),
+        }
         
-        if not all_conditions_met:
-            return True
-            
-        return super().validate(field, value, params)
+        return replacements
     
 class RequiredWithRule(RequiredRule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
         if any(f in self.validator.data for f in params):
             return super().validate(field, value, params)
         return True
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':others': ', '.join(self._get_display_name(self._params)),
+        }
+        
+        return replacements
 
 class RequiredWithAllRule(RequiredRule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
         if all(f in self.validator.data for f in params):
-            return not self.is_empty(value)
+            return super().validate(field, value, params)
         return True
     
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':others': ', '.join(self._get_display_name(self._params)),
+        }
+        
+        return replacements
+    
 class RequiredWithoutRule(RequiredRule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
         if any(f not in self.validator.data for f in params):
             return super().validate(field, value, params)
         return True
     
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':others': ', '.join(self._get_display_name(self._params)),
+        }
+        
+        return replacements
+    
 class RequiredWithoutAllRule(RequiredRule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-            
         if all(f not in self.validator.data for f in params):
             return super().validate(field, value, params)
         return True
     
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':others': ', '.join(self._get_display_name(self._params)),
+        }
+        
+        return replacements
+    
 class RequiredIfAcceptedRule(RequiredRule, AcceptedRule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-        
         if AcceptedRule.validate(self, field, params[0], params):
             return super().validate(field, value, params)
         
         return True
     
 class RequiredIfDeclinedRule(RequiredRule, DeclinedRule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-        
         if DeclinedRule.validate(self, field, params[0], params):
             return super().validate(field, value, params)
         
         return True
     
 class RequiredArrayKeysRule(Rule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not isinstance(value, dict) or not params:
+        if not isinstance(value, dict):
             return False
         return all(key in value for key in params)
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute must contain all required keys: {', '.join(params)}"
+        return f"The :attribute must contain all required keys: :values"
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            'values': ', '.join(self._params),
+        }
+        
+        return replacements
     
 class ProhibitedIfRule(ProhibitedRule):
+    _count_parameter = 2
+    _accept_closure = True
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) == 1 and callable(params[0]):
+        if callable(params[0]):
             condition_met = params[0](self.validator.data)
-        elif len(params) == 1 and isinstance(params[0], bool):
+        elif isinstance(params[0], bool):
             condition_met = params[0]
         else:    
-            other_field, other_value = params[0], params[1]
-            actual_value = self.get_field_value(other_field, '')
-        
-            condition_met = actual_value == other_value
+            expected_value, conditions = self.get_field_value(params[0], None), params[1:]
+            condition_met = expected_value in conditions
         
         if condition_met:
             return super().validate(field, value, params)
-        return True            
+        return True
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':other': self._get_display_name(self._params[0]),
+            ':values': ', '.join(self._params[1:]),
+        }
+        
+        return replacements
     
 class ProhibitedUnlessRule(ProhibitedRule):
+    _count_parameter = 2
+    _accept_closure = True
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2:
-            return False
-            
-        other_field, other_value = params[0], params[1]
-        actual_value = self.get_field_value(other_field, '') 
+        if callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif isinstance(params[0], bool):
+            condition_met = params[0]
+        else:  
+            expected_value, conditions = self.get_field_value(params[0], None), params[1:]
+            condition_met = expected_value in conditions
         
-        if actual_value == other_value:
-            return True
-            
-        return super().validate(field, value, params)
+        if not condition_met:
+            return super().validate(field, value, params)
+        return True
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':other': self._get_display_name(self._params[0]),
+            ':values': ', '.join(self._params[1:]),
+        }
+        
+        return replacements
     
 class ProhibitedIfAcceptedRule(ProhibitedRule, AcceptedRule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-        
         if AcceptedRule.validate(self, field, params[0], params):
             return super().validate(field, value, params)
         return True
 
 class ProhibitedIfDeclinedRule(ProhibitedRule, DeclinedRule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-        
         if DeclinedRule.validate(self, field, params[0], params):
             return super().validate(field, value, params)
         
         return True
     
 class PresentIfRule(PresentRule):
+    _count_parameter = 2
+    _accept_closure = True
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        condition_met = False
-        
-        if len(params) == 1 and callable(params[0]):
+        if callable(params[0]):
             condition_met = params[0](self.validator.data)
-        elif len(params) == 1 and isinstance(params[0], bool):
+        elif isinstance(params[0], bool):
             condition_met = params[0]
         else:
-            conditions = list(zip(params[::2], params[1::2]))
-            for other_field, expected_value in conditions:
-                if self.get_field_value(other_field, None) == expected_value:
-                    condition_met = True
-                    break
+            expected_value, conditions = self.get_field_value(params[0], None), params[1:]
+            
+            condition_met = expected_value in conditions
             
         if condition_met:
             return super().validate(field, value, params)
         
         return True
     
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':other': self._get_display_name(self._params[0]),
+            ':values': ', '.join(self._params[1:]),
+        }
+        
+        return replacements
+    
 class PresentUnlessRule(PresentRule):
+    _count_parameter = 2
+    _accept_closure = True
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2:
-            return False
-        other_field, other_value = params[0], params[1]
-        
-        if self.get_field_value(other_field, None) != other_value:
+        if callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif isinstance(params[0], bool):
+            condition_met = params[0]
+        else:
+            expected_value, conditions = self.get_field_value(params[0], None), params[1:]
+            
+            condition_met = expected_value in conditions
+            
+        if not condition_met:
             return super().validate(field, value, params)
         
         return True
     
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':other': self._get_display_name(self._params[0]),
+            ':values': ', '.join(self._params[1:]),
+        }
+        
+        return replacements
+    
 class PresentWithRule(PresentRule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
         if any(self.get_field_value(param, None) is not None for param in params):
             return super().validate(field, value, params)
         
         return True
     
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':others': ', '.join(self._get_display_name(self._params)),
+        }
+        
+        return replacements
+    
 class PresentWithAllRule(PresentRule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-        
         if all(self.get_field_value(param, None) is not None for param in params):
             return super().validate(field, value, params)
+        
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':others': ', '.join(self._get_display_name(self._params)),
+        }
+        
+        return replacements
 
 class MissingIfRule(MissingRule):
+    _count_parameter = 2
+    _accept_closure = True
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        condition_met = False
-        
-        if len(params) == 1 and callable(params[0]):
+        if callable(params[0]):
             condition_met = params[0](self.validator.data)
-        elif len(params) == 1 and isinstance(params[0], bool):
+        elif isinstance(params[0], bool):
             condition_met = params[0]
         else:
-            conditions = list(zip(params[::2], params[1::2]))
-            for other_field, expected_value in conditions:
-                if self.get_field_value(other_field, None) == expected_value:
-                    condition_met = True
-                    break
+            expected_value, conditions = self.get_field_value(params[0], None), params[1:]
+            condition_met = expected_value in conditions
             
         if condition_met:
             return super().validate(field, value, params)
         
         return True
     
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':other': self._get_display_name(self._params[0]),
+            ':values': ', '.join(self._params[1:]),
+        }
+        
+        return replacements
+    
 class MissingUnlessRule(MissingRule):
+    _count_parameter = 2
+    _accept_closure = True
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2:
-            return False
-        other_field, other_value = params[0], params[1]
-        if self.get_field_value(other_field, None) != other_value:
+        if callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif isinstance(params[0], bool):
+            condition_met = params[0]
+        else:
+            expected_value, conditions = self.get_field_value(params[0], None), params[1:]
+            condition_met = expected_value in conditions
+            
+        if not condition_met:
             return super().validate(field, value, params)
-
+        
         return True
+    
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':other': self._get_display_name(self._params[0]),
+            ':values': ', '.join(self._params[1:]),
+        }
+        
+        return replacements
             
 class MissingWithRule(MissingRule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
@@ -254,7 +400,18 @@ class MissingWithRule(MissingRule):
         
         return True
     
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':others': ', '.join(self._get_display_name(self._params)),
+        }
+        
+        return replacements
+    
 class MissingWithAllRule(MissingRule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
@@ -264,48 +421,52 @@ class MissingWithAllRule(MissingRule):
         
         return True
     
+    def replacements(self, field, value):
+        replacements = {
+            ':attribute': self._get_display_name(field),
+            ':input': value,
+            ':others': ', '.join(self._get_display_name(self._params)),
+        }
+        
+        return replacements
+    
 class ExcludeIfRule(ExcludeRule):
+    _count_parameter = 2
+    _accept_closure =  True
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) == 1 and callable(params[0]):
+        if callable(params[0]):
             condition_met = params[0](self.validator.data)
-        elif len(params) == 1 and isinstance(params[0], bool):
+        elif isinstance(params[0], bool):
             condition_met = params[0]
         else:
-            conditions = list(zip(params[::2], params[1::2]))
-            condition_met = all(
-                str(self.get_field_value(f)) == str(v) 
-                for f, v in conditions
-            )
+            expected_value, conditions = self.get_field_value(params[0], None), params[1:]
+            condition_met = expected_value in conditions
         
         if condition_met:
             return super().validate(field, value, params)
         return True
 
 class ExcludeUnlessRule(ExcludeRule):
+    _count_parameter = 2
+    _accept_closure =  True
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        all_conditions_met = False
-        
-        if len(params) == 1 and callable(params[0]):
-            all_conditions_met = params[0](self.validator.data)
-        elif len(params) == 1 and isinstance(params[0], bool):
-            all_conditions_met = params[0]
+        if callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif isinstance(params[0], bool):
+            condition_met = params[0]
         else:
-            conditions = [(f.strip(), v.strip()) for f, v in zip(params[::2], params[1::2])]
-            
-            all_conditions_met = all(
-                self.get_field_value(f) == v 
-                for f, v in conditions
-            )
+            expected_value, conditions = self.get_field_value(params[0], None), params[1:]
+            condition_met = expected_value in conditions
         
-        if not all_conditions_met:
+        if not condition_met:
             return super().validate(field, value, params)
-            
         return True
-            
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :attribute field is excluded unless {params[0]} is {params[1]}."
 
 class ExcludeWithRule(ExcludeRule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if any(not self.is_empty(self.get_field_value(param, None)) for param in params):
             return super().validate(field, value, params)
@@ -313,6 +474,8 @@ class ExcludeWithRule(ExcludeRule):
         return True
     
 class ExcludeWithoutRule(ExcludeRule):
+    _count_parameter = 1
+    
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if any(self.is_empty(self.get_field_value(param, None)) for param in params):
             return super().validate(field, value, params)