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

validator/services/rule_error_handler.py

@@ -2,10 +2,7 @@ from typing import Dict, List, Any, Optional, Union
 import re
 
 class RuleErrorHandler:
-    """Enhanced validation error handler with complete Laravel-style placeholder support,
-    including field-value pair parameters (field1,value1,field2,value2)"""
-    
-    def __init__(self, messages: Dict[str, str], custom_attributes: Dict[str, str]):
+    def __init__(self, messages: Dict[str, str] = None, custom_attributes: Dict[str, str] = None):
         self.messages = messages or {}
         self.custom_attributes = custom_attributes or {}
         self.errors: Dict[str, List[str]] = {}
@@ -13,225 +10,44 @@ class RuleErrorHandler:
         self._current_params: Optional[List[str]] = None
         self._current_value: Optional[Any] = None
 
-    def add_error(self, field: str, rule_name: str, rule_params: List[str], default_message: str, value: Any) -> None:
-        """Add a formatted error message with complete placeholder support"""
-        self._current_rule = rule_name
+    def add_error(self, field: str, rule: Any, rule_params: List[str], default_message: str, value: Any) -> None:
+        """Add error message with support for all parameter formats"""
+        self._current_rule = rule
         self._current_params = rule_params
         self._current_value = value
         
-        message = self._format_message(field, rule_name, default_message, value)
+        message = self._format_message(field, rule, default_message, value)
         self.errors.setdefault(field, []).append(message)
 
-    def _format_message(self, field: str, rule_name: str, default_message: str, value: Any) -> str:
-        """Format error message with all supported placeholders"""
-        attribute = self._get_attribute_name(field)
-        value_str = self._stringify_value(value)
-        
-        # Get the most specific message available
-        message = self._get_message(field, rule_name, attribute, default_message)
-        
-        # Prepare all possible replacements
-        replacements = self._prepare_replacements(attribute, value_str)
-        
-        # Apply replacements safely
-        return self._apply_replacements(message, replacements)
-
-    def _get_attribute_name(self, field: str) -> str:
-        """Get the display name for a field with nested field support"""
-        # Check for exact match first
-        if field in self.custom_attributes:
-            return self.custom_attributes[field]
-        
-        # Handle nested fields (e.g., 'user.profile.name')
-        parts = field.split('.')
-        for i in range(len(parts), 0, -1):
-            wildcard_key = '.'.join(parts[:i]) + '.*'
-            if wildcard_key in self.custom_attributes:
-                return self.custom_attributes[wildcard_key]
-        
-        # Fallback to last part or field itself
-        return self.custom_attributes.get(parts[-1], field.replace('_', ' ').title())
+    def _format_message(self, field: str, rule: Any, default_message: str, value: Any) -> str:
+        message = self._select_message(field, rule.rule_name, field, default_message)
+        return self._replace_placeholders(message, rule.replacements(field, value))
 
-    def _stringify_value(self, value: Any) -> str:
-        """Convert any value to a string representation"""
+    def _stringify(self, value: Any) -> str:
+        """Convert value to display string"""
         if value is None:
-            return ''
+            return None
         if isinstance(value, (list, dict, set)):
-            return ', '.join(str(v) for v in value) if value else ''
+            return ', '.join(str(v) for v in value) if value else 'none'
         return str(value)
 
-    def _get_message(self, field: str, rule_name: str, attribute: str, default: str) -> str:
-        """Get the most specific error message available"""
+    def _select_message(self, field: str, rule_name: str, attribute: str, default: str) -> str:
+        """Select the most specific error message available"""
         return (
-            self.messages.get(f"{field}.{rule_name}") or  # Field-specific rule message
-            self.messages.get(field) or                    # Field-specific default
-            self.messages.get(rule_name) or                # Rule-specific default
-            default                                       # Fallback
+            self.messages.get(f"{field}.{rule_name}") or
+            self.messages.get(field) or
+            self.messages.get(rule_name) or
+            default
         )
-
-    def _prepare_replacements(self, attribute: str, value_str: str) -> Dict[str, str]:
-        """Prepare all placeholder replacements including field-value pairs"""
-        replacements = {
-            ':attribute': attribute,
-            ':input': value_str,
-            ':value': value_str,
-            ':values': self._get_values_param(),
-            ':min': self._get_min_param(),
-            ':max': self._get_max_param(),
-            ':size': self._get_size_param(),
-            ':other': self._get_other_param_display(),
-            ':date': self._get_date_param(),
-            ':format': self._get_format_param(),
-            ':param': self._get_first_param(),
-        }
         
-        # Add numbered placeholders for field-value pairs (e.g., :other1, :value1, :other2, :value2)
-        if self._is_field_value_rule() and self._current_params:
-            field_value_pairs = self._get_field_value_pairs()
-            if field_value_pairs:
-                first_field, first_value = field_value_pairs[0]
-                replacements[':other'] = self._get_attribute_name(first_field)
-                replacements[':value'] = first_value
-                
-                for i, (field, val) in enumerate(field_value_pairs[1:], start=2):
-                    replacements[f':other{i}'] = self._get_attribute_name(field)
-                    replacements[f':value{i}'] = val
-        
-        return replacements
-
-    def _is_field_value_rule(self) -> bool:
-        """Check if the current rule uses field-value pairs"""
-        return self._current_rule and self._current_rule.lower() in {
-            'required_if', 'required_unless', 
-            'exclude_if', 'exclude_unless',
-            'missing_if', 'missing_unless',
-            'present_if', 'present_unless',
-        }
-
-    def _get_field_value_pairs(self) -> List[tuple]:
-        """Extract field-value pairs from parameters"""
-        if not self._current_params:
-            return []
-        
-        pairs = []
-        params = list(self._current_params).copy()
-        
-        # Process parameters in pairs (field, value)
-        while len(params) >= 2:
-            field = params.pop(0)
-            value = params.pop(0)
-            pairs.append((field, value))
-        
-        return pairs
-
-    def _apply_replacements(self, message: str, replacements: Dict[str, str]) -> str:
-        """Safely apply all replacements to the message"""
-        for placeholder, replacement in replacements.items():
-            if replacement is not None:
-                # Use regex to avoid partial replacements
-                safe_replacement = re.escape(str(replacement))
-                safe_replacement = safe_replacement.replace('\\', r'')
-                message = re.sub(
-                    re.escape(placeholder) + r'(?![a-zA-Z0-9_])', 
-                    safe_replacement, 
-                    message
-                )
+    def _replace_placeholders(self, message: str, replacements: Dict[str, str]) -> str:
+        """Safely replace all placeholders in message"""
+        for ph, val in replacements.items():
+            if val:
+                message = message.replace(ph, self._stringify(val))
         return message
 
-    def _get_other_param_display(self) -> Optional[str]:
-        """Get display names for other fields with proper formatting"""
-        other_fields = self._get_raw_other_fields()
-        if not other_fields:
-            return None
-            
-        display_names = [self._get_attribute_name(f) for f in other_fields]
-        
-        if len(display_names) == 1:
-            return display_names[0]
-        if len(display_names) == 2:
-            return f"{display_names[0]} and {display_names[1]}"
-        return f"{', '.join(display_names[:-1])}, and {display_names[-1]}"
-
-    def _get_raw_other_fields(self) -> List[str]:
-        """Extract field references from rule parameters"""
-        if not self._current_rule or not self._current_params:
-            return []
-            
-        rule = self._current_rule.lower()
-        
-        # Rules with field-value pairs (field1,value1,field2,value2,...)
-        if rule in {
-            'required_if', 'required_unless', 'exclude_if', 'exclude_unless',
-            'accepted_if', 'accepted_all_if', 'declined_if', 'declined_all_if',
-            'accepted_unless', 'declined_unless',
-            'missing_if', 'missing_unless', 'present_if', 'present_unless'
-        }:
-            return self._current_params[::2]  # Take every even index
-            
-        # Rules with multi field references
-        if rule in {
-            'required_with', 'required_with_all', 'required_without', 'required_without_all',
-            'prohibits', 'exclude_with', 'exclude_without',
-            'missing_with', 'missing_with_all', 
-            'present_with', 'present_with_all',  'same', 'different'
-        }:
-            return self._current_params
-            
-        return []
-
-    def _get_min_param(self) -> Optional[str]:
-        """Get min parameter from rule"""
-        if not self._current_params:
-            return None
-            
-        if self._current_rule and self._current_rule.startswith(('min', 'between', 'digits_between')):
-            return self._current_params[0]
-        return None
-
-    def _get_max_param(self) -> Optional[str]:
-        """Get max parameter from rule"""
-        if not self._current_params or len(self._current_params) < 2:
-            return None
-            
-        if self._current_rule and self._current_rule.startswith(('max', 'between', 'digits_between')):
-            return self._current_params[1] if self._current_rule.startswith('between') else self._current_params[0]
-        return None
-
-    def _get_size_param(self) -> Optional[str]:
-        """Get size parameter from rule"""
-        if self._current_rule and self._current_rule.startswith('size') and self._current_params:
-            return self._current_params[0]
-        return None
-
-    def _get_values_param(self) -> Optional[str]:
-        """Get values list for in/not_in rules"""
-        if (self._current_rule and 
-            self._current_rule.startswith(('in', 'not_in')) and 
-            self._current_params):
-            return ', '.join(self._current_params)
-        return None
-
-    def _get_date_param(self) -> Optional[str]:
-        """Get date parameter for date rules"""
-        if (self._current_rule and 
-            self._current_rule.startswith(('after', 'before', 'after_or_equal', 'before_or_equal')) and 
-            self._current_params):
-            return self._current_params[0]
-        return None
-
-    def _get_format_param(self) -> Optional[str]:
-        """Get format parameter"""
-        if (self._current_rule and 
-            self._current_rule.startswith('date_format') and 
-            self._current_params):
-            return self._current_params[0]
-        return None
-
-    def _get_first_param(self) -> Optional[str]:
-        """Get first parameter from rule"""
-        return self._current_params[0] if self._current_params else None
-
     @property
     def has_errors(self) -> bool:
-        """Check if any errors exist"""
+        """Check if any validation errors exist"""
         return bool(self.errors)

validator/services/rule_preparer.py

@@ -13,6 +13,7 @@ class RulePreparer:
     """Handles rule preparation and parsing"""
     def __init__(self, rule_factory: RuleFactory):
         self.rule_factory = rule_factory
+        self.added_rules = {}
 
     def prepare(self, raw_rules: Dict[str, Union[str, List[Union[str, Rule]]]]) -> Dict[str, List[Rule]]:
         """Convert raw rules to prepared validation rules"""
@@ -20,10 +21,16 @@ class RulePreparer:
         for field, rule_input in raw_rules.items():
             if not rule_input:
                 continue
-            rules = self._convert_to_rules(rule_input)
-            RuleConflictChecker.check_conflicts(rules)
-            prepared_rules[field] = self._deduplicate_rules(rules)
+            
+            prepared_rules[field] = self._generate_rule(field, rule_input)
+                
         return prepared_rules
+    
+    def _generate_rule(self, field, rule_input):
+        rules = self._convert_to_rules(rule_input)
+        RuleConflictChecker.check_conflicts(rules)
+        
+        return self._deduplicate_rules(field, rules)
 
     def _convert_to_rules(self, rule_input: Union[str, List[Union[str, Rule]], Rule, Tuple[Union[str, Rule], str], Tuple[Union[str, Rule], str]]) -> List[Rule]:
         """Convert mixed rule input to list of Rule objects"""
@@ -95,13 +102,20 @@ class RulePreparer:
     def _parse_params(self, params: Union[Tuple, List, str, Enum]):
         return set(tuple(x) if isinstance(x, list) else x for x in params)
 
-    def _deduplicate_rules(self, rules: List[Rule]) -> List[Rule]:
+    def _deduplicate_rules(self, field: str, rules: List[Rule]) -> List[Rule]:
         """Remove duplicate rules based on name and parameters"""
-        seen = set()
         unique = []
         for rule in rules:
             identifier = (rule.rule_name, tuple(rule.params))
-            if identifier not in seen:
-                seen.add(identifier)
+            if rule.rule_name != 'when':
+                if identifier not in self.added_rules.get(field, []):
+                    if isinstance(self.added_rules.get(field), set):
+                        self.added_rules[field].add(identifier)
+                    else:
+                        self.added_rules[field] = set()
+                        self.added_rules[field].add(identifier)
+                        
+                    unique.append(rule)
+            else:
                 unique.append(rule)
         return unique

safeshield-1.5.1.dist-info/RECORD

@@ -1,31 +0,0 @@
-validator/__init__.py,sha256=udxDzUicPfxBOAQvzsnl3pHur9VUppKbWMgg35hpiww,244
-validator/exceptions.py,sha256=y2v7CaXmeGFHWcnigtLl4U-sFta_jMiXkGKXWIIVglY,366
-validator/factory.py,sha256=SJ2iJmTnFS-4ccH-gzZl_7CAW7Z6YJkZbMImu-po80w,1163
-validator/core/__init__.py,sha256=ZcqlXJSk03i_CVzmIN-nVe1UOyvwwO5jhbEj7f62Y_o,59
-validator/core/validator.py,sha256=la-kzp82iCii2bq4hV76F-7datWPb27vmyHvpg2itR0,12726
-validator/database/__init__.py,sha256=O-cB6-MhNapJ3iwe5jvifbMfr1dPjXLtEdfNTKIu0hc,171
-validator/database/detector.py,sha256=Vac7oVL26GjU6expGo01-6mgUtXqldr-jirzpYokZBM,9597
-validator/database/manager.py,sha256=XJM_I0WaWfZWV710duAc32p1gtiP2or-MAj75WPw1oM,6478
-validator/rules/__init__.py,sha256=z3Vk3R5CRgjeqyDWZxdofD2tBMTgdyYVuFmo1mKOTj4,830
-validator/rules/array.py,sha256=AqVoBR_chSqxPec14Av5KmR9NAByovXDNNu2oeId4-U,2528
-validator/rules/base.py,sha256=PadT5Ko3Zs_yr5EPxOfTw-IdS7uJKhGpaekF1k4tvYk,4359
-validator/rules/basic.py,sha256=LWYs4fPCA6_lTtOmtTgvjGqjVxxSdklj9fsCgSAMy2Y,4918
-validator/rules/boolean.py,sha256=vy6huFJ5JidpsoJ0WSvcydiU7a8aYFj225UswggSGAE,5748
-validator/rules/comparison.py,sha256=W22Gsafnu8zC0Ue-28PDB36fB8VDO3bMS5MDSg5VUHE,13368
-validator/rules/date.py,sha256=yolYaTIvQTN1LBje5SM8i7EmNzOxV_eUwnOokmqZrMs,5812
-validator/rules/files.py,sha256=c7deO8fEiFNCx4jq1B2sJXhxTqGzTVq4kK2EscSNhKI,10946
-validator/rules/format.py,sha256=Medw57PJwfElxA-DgxiZ5GHqvqPhUCQPFMGCGTDne8w,7070
-validator/rules/numeric.py,sha256=nkYVc8VtrWJ3Kt7JDLPsbg7ZaN3F0zJMnbf8Y5gxNsk,6824
-validator/rules/string.py,sha256=p8ZQfd0XaWIjksg_8ta3f6PEnXlxjRzlSJx1GohZ7yk,5237
-validator/rules/utilities.py,sha256=dLbmSvaTdC2kK7_6V1MrPmtXr5u6YvJKnHMJSByslKk,12236
-validator/services/__init__.py,sha256=zzKTmqL7v4niFGWHJBfWLqgJ0iTaW_69OzYZN8uInzQ,210
-validator/services/rule_conflict.py,sha256=T3IhWLmZsRUccJ4oFO-OKRjrc5Xt7r71kktxjjj2IA8,9505
-validator/services/rule_error_handler.py,sha256=1Tka8PZA5skgf0VGUVj0evdL9Xqq2Zb9Vns_XcUMgZ8,10385
-validator/services/rule_preparer.py,sha256=4khRjdely_0Z5mxFwf1bKIid076_xDuNh2XBO_fGerE,4706
-validator/utils/__init__.py,sha256=Yzo-xv285Be-a233M4duDdYtscuHiuBbPSX_C8yViJI,20
-validator/utils/string.py,sha256=0YACzeEaWNEOR9_7O9A8D1ItIbtWfOJ8IfrzcB8VMYA,515
-safeshield-1.5.1.dist-info/LICENSE,sha256=qugtRyKckyaks6hd2xyxOFSOYM6au1N80pMXuMTPvC4,1090
-safeshield-1.5.1.dist-info/METADATA,sha256=wg2r8qCTKIwdHcKUpQf6Xf_nDrubGkzo2spCdDBze_g,2313
-safeshield-1.5.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-safeshield-1.5.1.dist-info/top_level.txt,sha256=iUtV3dlHOIiMfLuY4pruY00lFni8JzOkQ3Nh1II19OE,10
-safeshield-1.5.1.dist-info/RECORD,,