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

validator/services/rule_error_handler.py

@@ -1,41 +1,238 @@
-from typing import Dict, List, Any
+from typing import Dict, List, Any, Optional, Union
+import re
 
 class RuleErrorHandler:
-    """Manages validation errors and message formatting"""
+    """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]):
         self.messages = messages or {}
         self.custom_attributes = custom_attributes or {}
         self.errors: Dict[str, List[str]] = {}
+        self._current_rule: Optional[str] = None
+        self._current_params: Optional[List[str]] = None
+        self._current_value: Optional[Any] = None
 
-    def add_error(self, field: str, rule_name: str, default_message: str, value: Any):
-        """Add formatted error message"""
-        message = self._format_message(field, rule_name, default_message, value)
+    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
+        self._current_params = rule_params
+        self._current_value = value
         
-        # Handle nested field display names
+        message = self._format_message(field, rule_name, 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 placeholders"""
-        # Get the base field name (last part of nested path)
-        base_field = field.split('.')[-1]
-        
-        attribute = self.custom_attributes.get(field) or self.custom_attributes.get(base_field, field)
-        value_str = str(value) if value is not None else ''
-        
-        message = (
-            self.messages.get(field) or
-            self.messages.get(attribute) or
-            self.messages.get(f"{attribute}.*") or
-            self.messages.get(f"{field}.{rule_name}") or
-            default_message
-        )
+        """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]
         
-        return (message
-            .replace(':name', attribute)
-            .replace(':value', value_str)
-            .replace(':param', rule_name.split(':')[1] if ':' in rule_name else '')
+        # Fallback to last part or field itself
+        return self.custom_attributes.get(parts[-1], field.replace('_', ' ').title())
+
+    def _stringify_value(self, value: Any) -> str:
+        """Convert any value to a string representation"""
+        if value is None:
+            return ''
+        if isinstance(value, (list, dict, set)):
+            return ', '.join(str(v) for v in value) if value else ''
+        return str(value)
+
+    def _get_message(self, field: str, rule_name: str, attribute: str, default: str) -> str:
+        """Get 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
         )
 
+    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
+                message = re.sub(
+                    re.escape(placeholder) + r'(?![a-zA-Z0-9_])', 
+                    str(replacement), 
+                    message
+                )
+        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',
+            'missing_if', 'missing_unless', 'present_if', 'present_unless'
+        }:
+            return self._current_params[::2]  # Take every even index
+            
+        # Rules with just field references
+        if rule in {
+            'prohibits', 'exclude_with', 'exclude_without',
+            'missing_with', 'missing_with_all', 
+            'present_with', 'present_with_all'
+        }:
+            return self._current_params
+            
+        # Single field rules
+        if rule in {
+            'required_if_accepted', 'required_if_declined',
+            'prohibited_if_accepted', 'prohibited_if_declined'
+        }:
+            return [self._current_params[0]] if self._current_params else []
+            
+        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"""

validator/services/rule_preparer.py

@@ -1,6 +1,6 @@
 from validator.factory import RuleFactory
 from validator.services.rule_conflict import RuleConflictChecker
-from validator.rules import ValidationRule
+from validator.rules import Rule
 from typing import Dict, List, Union, Tuple
 from validator.exceptions import RuleNotFoundException
 from collections.abc import Iterable, Sequence
@@ -14,7 +14,7 @@ class RulePreparer:
     def __init__(self, rule_factory: RuleFactory):
         self.rule_factory = rule_factory
 
-    def prepare(self, raw_rules: Dict[str, Union[str, List[Union[str, ValidationRule]]]]) -> Dict[str, List[ValidationRule]]:
+    def prepare(self, raw_rules: Dict[str, Union[str, List[Union[str, Rule]]]]) -> Dict[str, List[Rule]]:
         """Convert raw rules to prepared validation rules"""
         prepared_rules = {}
         for field, rule_input in raw_rules.items():
@@ -25,18 +25,18 @@ class RulePreparer:
             prepared_rules[field] = self._deduplicate_rules(rules)
         return prepared_rules
 
-    def _convert_to_rules(self, rule_input: Union[str, List[Union[str, ValidationRule]], ValidationRule, Tuple[Union[str, ValidationRule], str], Tuple[Union[str, ValidationRule], str]]) -> List[ValidationRule]:
-        """Convert mixed rule input to list of ValidationRule objects"""
+    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"""
         if rule_input is None:
             return []
-        if isinstance(rule_input, ValidationRule):
+        if isinstance(rule_input, Rule):
             return [rule_input]
-        if isinstance(rule_input, list):
+        if isinstance(rule_input, list | tuple):
             rules = []
             for r in rule_input:
                 if isinstance(r, str):
                     rules.extend(self._parse_rule_string(r))
-                elif isinstance(r, ValidationRule):
+                elif isinstance(r, Rule):
                     rules.append(r)
                 elif isinstance(r, (tuple, list)):
                     if len(r) == 0:
@@ -50,10 +50,10 @@ class RulePreparer:
                         if isinstance(rule_name, str):
                             rule = RuleFactory.create_rule(rule_name)
                             rule.params = params
-                        elif isinstance(rule_name, ValidationRule):
+                        elif isinstance(rule_name, Rule):
                             rule = rule_name
                             if params:
-                                warnings.warn(f"Parameters {params} are ignored for ValidationRule instance")
+                                warnings.warn(f"Parameters {params} are ignored for Rule instance")
                         else:
                             raise ValueError(f"Invalid rule name type in {r}")
                             
@@ -65,8 +65,8 @@ class RulePreparer:
             return self._parse_rule_string(rule_input)
         raise ValueError(f"Invalid rule input type: {type(rule_input)}")
 
-    def _parse_rule_string(self, rule_str: str) -> List[ValidationRule]:
-        """Parse rule string into ValidationRule objects"""
+    def _parse_rule_string(self, rule_str: str) -> List[Rule]:
+        """Parse rule string into Rule objects"""
         rules = []
         for rule_part in rule_str.split('|'):
             rule_part = rule_part.strip()
@@ -93,22 +93,9 @@ class RulePreparer:
         return rule_name, [p.strip() for p in param_str.split(',') if p.strip()]
     
     def _parse_params(self, params: Union[Tuple, List, str, Enum]):
-        all_params = []
-        # seen = set()
-        # for param in params:
-        #     if isinstance(param, Iterable) and not isinstance(param, str | bytes) and not inspect.isclass(param):
-        #         for item in param:
-        #             if item not in seen and item not in (None, '', [], {}) and (isinstance(item, (Number, Sequence)) or inspect.isclass(item)):
-        #                 seen.add(item)
-        #                 all_params.append(item)
-        #     else:
-        #         if param not in seen and param not in (None, '', [], {}) and (isinstance(param, (Number, Sequence)) or inspect.isclass(param)):
-        #             seen.add(param)
-        #             all_params.append(param)
-                    
         return set(tuple(x) if isinstance(x, list) else x for x in params)
 
-    def _deduplicate_rules(self, rules: List[ValidationRule]) -> List[ValidationRule]:
+    def _deduplicate_rules(self, rules: List[Rule]) -> List[Rule]:
         """Remove duplicate rules based on name and parameters"""
         seen = set()
         unique = []

safeshield-1.2.2.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=bImQNLhEJg5VTxtHiMYVb2EbHWvimTDqHq-UcA8uolw,812
-validator/core/__init__.py,sha256=ZcqlXJSk03i_CVzmIN-nVe1UOyvwwO5jhbEj7f62Y_o,59
-validator/core/validator.py,sha256=00qVnbH-EJC5KALlaoUBLAfsszAFLcoSxfRbmy0amyk,12751
-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=nDE3qoI82qJTCbILLUWkXuwsMOmsDtB1m-3IGIvRfpY,919
-validator/rules/array.py,sha256=tx8FCDqn-27Vs7tgtjeoCE9ceDMVrdBEb2-pq-lNLuo,2809
-validator/rules/base.py,sha256=hrGESfkdvqZrQ1yIK_ftVVOMUuyvNFoz-_qaqUucSy8,3474
-validator/rules/basic.py,sha256=fMk0s5_IEQu27X1wndP_ocNyOZ1upXJCn7fR9YYbI74,1527
-validator/rules/comparison.py,sha256=9xb2mO5GiThR1iO8867ex2o7olQC2Bnew6MBdD2UtEo,9402
-validator/rules/conditional.py,sha256=8_O1etzCyCGeD8lmfhegJ1uzhkBSjTEVdufbZmkqgP4,12993
-validator/rules/date.py,sha256=18JIKTO5nzFtCnJEMXm4OUbneqTMB7HGPN6jUkxGU4Y,5278
-validator/rules/files.py,sha256=vu_TZFffDPzDojyTsFXSQ6MmQm3WU6ppFfz7-wuDy98,6550
-validator/rules/format.py,sha256=UeeIAkFn0CdzC5bS9tI78_lbPYRgcpaUujxdmyCSdzE,3744
-validator/rules/string.py,sha256=vYzu4ICKY9FCuGahmsQCoJLmnlBF7uNvVazFj9DQ438,3178
-validator/rules/type.py,sha256=Tu-EOBkTtxkcCe0ANXavurZC449n63iE_VXVzc3BIiM,1596
-validator/rules/utilities.py,sha256=AIm9JRGYf6cTCSkivg3gTj3U5DnXlCAJ5ej1yUSa1dU,9724
-validator/services/__init__.py,sha256=zzKTmqL7v4niFGWHJBfWLqgJ0iTaW_69OzYZN8uInzQ,210
-validator/services/rule_conflict.py,sha256=s1RJNUY5d0WtSMHkrKulBCgJ2BZL2GE0Eu5pdAoiIbM,4943
-validator/services/rule_error_handler.py,sha256=MGvvkP6hbZLpVXxC3xpzg15OmVdPlk7l0M2Srmy5VfM,1729
-validator/services/rule_preparer.py,sha256=jRcMNjqq2xyZjO64Pim8jWmja5DmTzf0V_uuHG0lJTg,5621
-validator/utils/__init__.py,sha256=Yzo-xv285Be-a233M4duDdYtscuHiuBbPSX_C8yViJI,20
-validator/utils/string.py,sha256=0YACzeEaWNEOR9_7O9A8D1ItIbtWfOJ8IfrzcB8VMYA,515
-safeshield-1.2.2.dist-info/LICENSE,sha256=qugtRyKckyaks6hd2xyxOFSOYM6au1N80pMXuMTPvC4,1090
-safeshield-1.2.2.dist-info/METADATA,sha256=Da-A5dUfizYqEpszV6KlIwRLJLgKj7KThQ_990k2wNg,1912
-safeshield-1.2.2.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-safeshield-1.2.2.dist-info/top_level.txt,sha256=iUtV3dlHOIiMfLuY4pruY00lFni8JzOkQ3Nh1II19OE,10
-safeshield-1.2.2.dist-info/RECORD,,