safeshield 1.2.2__py3-none-any.whl → 1.4.2__py3-none-any.whl

validator/rules/utilities.py

@@ -1,41 +1,46 @@
-from .base import ValidationRule
+from .base import Rule
 from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+from .basic import *
+from .boolean import AcceptedRule, DeclinedRule
 
-class AnyOfRule(ValidationRule):
+class RequiredIfRule(RequiredRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
-            return False
-        return any(self.get_field_value(param, param) == value for param in params)
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must be one of: {', '.join(params)}"
-
-class ExcludeRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        return False  # This rule is typically used to exclude fields from validation
+        if len(params) == 1 and callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif len(params) == 1 and isinstance(params[0], bool):
+            condition_met = params[0]
+        else:  
+            conditions = list(zip(params[::2], params[1::2]))
+            
+            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
+            )
+                
+        if condition_met:
+            return super().validate(field, value, params)
+        
+        return True
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is excluded."
-
-class ExcludeIfRule(ValidationRule):
+class RequiredUnlessRule(RequiredRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        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
-        )
+        if len(params) < 2:
+            return False
+            
+        other_field, other_value = params[0], params[1]
+        actual_value = self.get_field_value(other_field, '') 
         
-        if all_conditions_met:
-            self.validator._is_exclude = True
+        if actual_value == other_value:
+            return True
             
-        return True
+        return super().validate(field, value, params)
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is excluded when {params[0]} is {params[1]}."
-
-class ExcludeUnlessRule(ValidationRule):
+class RequiredAllIfRule(RequiredRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) < 2:
+            return False
+            
         conditions = [(f.strip(), v.strip()) for f, v in zip(params[::2], params[1::2])]
         
         all_conditions_met = all(
@@ -44,170 +49,265 @@ class ExcludeUnlessRule(ValidationRule):
         )
         
         if not all_conditions_met:
-            self.validator._is_exclude = True
-            
-        return True
+            return True
             
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is excluded unless {params[0]} is {params[1]}."
-
-class ExcludeWithRule(ValidationRule):
+        return super().validate(field, value, params)
+    
+class RequiredWithRule(RequiredRule):
     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):
-            self.validator._is_exclude = True
+        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 message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is excluded when any of {', '.join(params)} is present."
 
-class ExcludeWithoutRule(ValidationRule):
+class RequiredWithAllRule(RequiredRule):
     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):
-            self.validator._is_exclude = True
+        if not params:
+            return False
             
+        if all(f in self.validator.data for f in params):
+            return not self.is_empty(value)
         return True
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is excluded when any of {', '.join(params)} is missing."
-
-class MissingRule(ValidationRule):
-    def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        return value is None
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field must be missing."
-
-class MissingIfRule(ValidationRule):
+class RequiredWithoutRule(RequiredRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2:
+        if not params:
             return False
-        other_field, other_value = params[0], params[1]
-        return value is None if self.get_field_value(other_field, None) == other_value else True
+            
+        if any(f not in self.validator.data for f in params):
+            return super().validate(field, value, params)
+        return True
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field must be missing when {params[0]} is {params[1]}."
-
-class MissingUnlessRule(ValidationRule):
+class RequiredWithoutAllRule(RequiredRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2:
+        if not params:
             return False
-        other_field, other_value = params[0], params[1]
-        return value is None if self.get_field_value(other_field, None) != other_value else True
+            
+        if all(f not in self.validator.data for f in params):
+            return super().validate(field, value, params)
+        return True
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field must be missing unless {params[0]} is {params[1]}."
-
-class MissingWithRule(ValidationRule):
+class RequiredIfAcceptedRule(RequiredRule, AcceptedRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
-        return value is None if any(self.get_field_value(param, None) is not None for param in params) else True
+        
+        if AcceptedRule.validate(self, field, params[0], params):
+            return super().validate(field, value, params)
+        
+        return True
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field must be missing when any of {', '.join(params)} is present."
-
-class MissingWithAllRule(ValidationRule):
+class RequiredIfDeclinedRule(RequiredRule, DeclinedRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
-        return value is None if all(self.get_field_value(param, None) is not None for param in params) else True
+        
+        if DeclinedRule.validate(self, field, params[0], params):
+            return super().validate(field, value, params)
+        
+        return True
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field must be missing when all of {', '.join(params)} are present."
-
-class PresentIfRule(ValidationRule):
+class RequiredArrayKeysRule(Rule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if len(params) < 2:
+        if not isinstance(value, dict) or not params:
             return False
-        other_field, other_value = params[0], params[1]
-        return value is not None if self.get_field_value(other_field, None) == other_value else True
+        return all(key in value for key in params)
     
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field must be present when {params[0]} is {params[1]}."
-
-class PresentUnlessRule(ValidationRule):
+        return f"The :attribute must contain all required keys: {', '.join(params)}"
+    
+class ProhibitedIfRule(ProhibitedRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) == 1 and callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif len(params) == 1 and 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
+        
+        if condition_met:
+            return super().validate(field, value, params)
+        return True            
+    
+class ProhibitedUnlessRule(ProhibitedRule):
     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]
-        return value is not None if self.get_field_value(other_field, None) != other_value else True
+        actual_value = self.get_field_value(other_field, '') 
+        
+        if actual_value == other_value:
+            return True
+            
+        return super().validate(field, value, params)
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field must be present unless {params[0]} is {params[1]}."
-
-class PresentWithRule(ValidationRule):
+class ProhibitedIfAcceptedRule(ProhibitedRule, AcceptedRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
-        return value is not None if any(self.get_field_value(param, None) is not None for param in params) else True
-    
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field must be present when any of {', '.join(params)} is present."
+        
+        if AcceptedRule.validate(self, field, params[0], params):
+            return super().validate(field, value, params)
+        return True
 
-class PresentWithAllRule(ValidationRule):
+class ProhibitedIfDeclinedRule(ProhibitedRule, DeclinedRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
-        return value is not None if all(self.get_field_value(param, None) is not None for param in params) else True
+        
+        if DeclinedRule.validate(self, field, params[0], params):
+            return super().validate(field, value, params)
+        
+        return True
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field must be present when all of {', '.join(params)} are present."
-
-class ProhibitedIfAcceptedRule(ValidationRule):
+class PresentIfRule(PresentRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params:
+        condition_met = False
+        
+        if len(params) == 1 and callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif len(params) == 1 and 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
+            
+        if condition_met:
+            return super().validate(field, value, params)
+        
+        return True
+    
+class PresentUnlessRule(PresentRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) < 2:
             return False
-        other_field = params[0]
-        return value is None if self.get_field_value(other_field, None) in ['yes', 'on', '1', 1, True, 'true', 'True'] else True
+        other_field, other_value = params[0], params[1]
+        
+        if self.get_field_value(other_field, None) != other_value:
+            return super().validate(field, value, params)
+        
+        return True
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is prohibited when {params[0]} is accepted."
-
-class ProhibitedIfDeclinedRule(ValidationRule):
+class PresentWithRule(PresentRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
-        other_field = params[0]
-        return value is None if self.get_field_value(other_field, None) in ['no', 'off', '0', 0, False, 'false', 'False'] else True
+        if any(self.get_field_value(param, None) is not None for param in params):
+            return super().validate(field, value, params)
+        
+        return True
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is prohibited when {params[0]} is declined."
+class PresentWithAllRule(PresentRule):
+    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)
 
-class ProhibitsRule(ValidationRule):
+class MissingIfRule(MissingRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not params or value is None:
-            return True
-        return all(self.get_field_value(param, param) in (None, 'None') for param in params)
+        condition_met = False
+        
+        if len(params) == 1 and callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif len(params) == 1 and 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
+            
+        if condition_met:
+            return super().validate(field, value, params)
+        
+        return True
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"When :name is present, {', '.join(params)} must be absent."
+class MissingUnlessRule(MissingRule):
+    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:
+            return super().validate(field, value, params)
 
-class RequiredIfAcceptedRule(ValidationRule):
+        return True
+            
+class MissingWithRule(MissingRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
-        other_field = params[0]
-        return value is not None if self.get_field_value(other_field, None) in ['yes', 'on', '1', 1, True, 'true', 'True'] else True
+        
+        if any(self.get_field_value(param, None) is not None for param in params):
+            return super().validate(field, value, params)
+        
+        return True
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is required when {params[0]} is accepted."
-
-class RequiredIfDeclinedRule(ValidationRule):
+class MissingWithAllRule(MissingRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
         if not params:
             return False
-        other_field = params[0]
-        return value is not None if self.get_field_value(other_field, other_field) in ['no', 'off', '0', 0, False, 'false', 'False'] else True
+        
+        if all(self.get_field_value(param, None) is not None for param in params):
+            return super().validate(field, value, params)
+        
+        return True
     
+class ExcludeIfRule(ExcludeRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) == 1 and callable(params[0]):
+            condition_met = params[0](self.validator.data)
+        elif len(params) == 1 and 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
+            )
+        
+        if condition_met:
+            return super().validate(field, value, params)
+        return True
+
+class ExcludeUnlessRule(ExcludeRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        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
+        )
+        
+        if not all_conditions_met:
+            return super().validate(field, value, params)
+            
+        return True
+            
     def message(self, field: str, params: List[str]) -> str:
-        return f"The :name field is required when {params[0]} is declined."
+        return f"The :attribute field is excluded unless {params[0]} is {params[1]}."
 
-class RequiredArrayKeysRule(ValidationRule):
+class ExcludeWithRule(ExcludeRule):
     def validate(self, field: str, value: Any, params: List[str]) -> bool:
-        if not isinstance(value, dict) or not params:
-            return False
-        return all(key in value for key in params)
+        if any(not self.is_empty(self.get_field_value(param, None)) for param in params):
+            return super().validate(field, value, params)
+            
+        return True
     
-    def message(self, field: str, params: List[str]) -> str:
-        return f"The :name must contain all required keys: {', '.join(params)}"
+class ExcludeWithoutRule(ExcludeRule):
+    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)
+            
+        return True

validator/services/rule_conflict.py

@@ -58,11 +58,11 @@ class RuleConflictChecker:
     }
 
     @classmethod
-    def check_conflicts(cls, rules: List['ValidationRule']) -> None:
+    def check_conflicts(cls, rules: List['Rule']) -> None:
         """Main method untuk mengecek semua jenis konflik.
         
         Args:
-            rules: List of ValidationRule objects to check
+            rules: List of Rule objects to check
             
         Raises:
             ValueError: Untuk konflik kritis