Change constructor arguments of FileNameSanitizer and FilePathSanitizer classes

Author: thombashi

pathvalidate/_base.py

@@ -30,17 +30,12 @@ def platform(self) -> Platform:
     def reserved_keywords(self) -> Tuple[str, ...]:
         return tuple()
 
-    @property
-    def min_len(self) -> int:
-        return self._min_len
-
     @property
     def max_len(self) -> int:
         return self._max_len
 
     def __init__(
         self,
-        min_len: int,
         max_len: int,
         fs_encoding: Optional[str],
         check_reserved: bool,
@@ -50,10 +45,6 @@ def __init__(
         self.__platform = normalize_platform(platform)
         self._check_reserved = check_reserved
 
-        if min_len <= 0:
-            min_len = DEFAULT_MIN_LEN
-        self._min_len = max(min_len, 1)
-
         if platform_max_len is None:
             platform_max_len = self._get_default_max_path_len()
 
@@ -69,8 +60,6 @@ def __init__(
         else:
             self._fs_encoding = sys.getfilesystemencoding()
 
-        self._validate_max_len()
-
     def _is_posix(self) -> bool:
         return self.platform == Platform.POSIX
 
@@ -95,13 +84,6 @@ def _is_macos(self, include_universal: bool = False) -> bool:
 
         return self.platform == Platform.MACOS
 
-    def _validate_max_len(self) -> None:
-        if self.max_len < 1:
-            raise ValueError("max_len must be greater or equal to one")
-
-        if self.min_len > self.max_len:
-            raise ValueError("min_len must be lower than max_len")
-
     def _get_default_max_path_len(self) -> int:
         if self._is_linux():
             return 4096
@@ -116,6 +98,10 @@ def _get_default_max_path_len(self) -> int:
 
 
 class AbstractValidator(BaseFile, metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def min_len(self) -> int:  # pragma: no cover
+        pass
+
     @abc.abstractmethod
     def validate(self, value: PathType) -> None:  # pragma: no cover
         pass
@@ -135,17 +121,16 @@ def _is_reserved_keyword(self, value: str) -> bool:
 class AbstractSanitizer(BaseFile, metaclass=abc.ABCMeta):
     def __init__(
         self,
-        min_len: int,
+        validator: AbstractValidator,
         max_len: int,
         fs_encoding: Optional[str],
         check_reserved: bool,
+        validate_after_sanitize: bool,
         null_value_handler: Optional[NullValueHandler] = None,
         platform_max_len: Optional[int] = None,
         platform: Optional[PlatformType] = None,
-        validate_after_sanitize: bool = False,
     ) -> None:
         super().__init__(
-            min_len=min_len,
             max_len=max_len,
             fs_encoding=fs_encoding,
             check_reserved=check_reserved,
@@ -159,12 +144,41 @@ def __init__(
 
         self._validate_after_sanitize = validate_after_sanitize
 
+        self._validator = validator
+
     @abc.abstractmethod
     def sanitize(self, value: PathType, replacement_text: str = "") -> PathType:  # pragma: no cover
         pass
 
 
 class BaseValidator(AbstractValidator):
+    @property
+    def min_len(self) -> int:
+        return self._min_len
+
+    def __init__(
+        self,
+        min_len: int,
+        max_len: int,
+        fs_encoding: Optional[str],
+        check_reserved: bool,
+        platform_max_len: Optional[int] = None,
+        platform: Optional[PlatformType] = None,
+    ) -> None:
+        if min_len <= 0:
+            min_len = DEFAULT_MIN_LEN
+        self._min_len = max(min_len, 1)
+
+        super().__init__(
+            max_len=max_len,
+            fs_encoding=fs_encoding,
+            check_reserved=check_reserved,
+            platform_max_len=platform_max_len,
+            platform=platform,
+        )
+
+        self._validate_max_len()
+
     def _validate_reserved_keywords(self, name: str) -> None:
         if not self._check_reserved:
             return
@@ -178,6 +192,13 @@ def _validate_reserved_keywords(self, name: str) -> None:
                 platform=self.platform,
             )
 
+    def _validate_max_len(self) -> None:
+        if self.max_len < 1:
+            raise ValueError("max_len must be greater or equal to one")
+
+        if self.min_len > self.max_len:
+            raise ValueError("min_len must be lower than max_len")
+
     @staticmethod
     def __extract_root_name(path: str) -> str:
         return os.path.splitext(os.path.basename(path))[0]

pathvalidate/_filename.py

@@ -9,7 +9,7 @@
 from pathlib import Path
 from typing import Optional, Pattern, Tuple
 
-from ._base import AbstractSanitizer, BaseFile, BaseValidator
+from ._base import AbstractSanitizer, AbstractValidator, BaseFile, BaseValidator
 from ._common import findall_to_str, to_str, validate_pathtype
 from ._const import DEFAULT_MIN_LEN, INVALID_CHAR_ERR_MSG_TMPL, Platform
 from ._types import PathType, PlatformType
@@ -27,32 +27,37 @@
 class FileNameSanitizer(AbstractSanitizer):
     def __init__(
         self,
-        min_len: int = DEFAULT_MIN_LEN,
         max_len: int = _DEFAULT_MAX_FILENAME_LEN,
         fs_encoding: Optional[str] = None,
         platform: Optional[PlatformType] = None,
         check_reserved: bool = True,
         null_value_handler: Optional[NullValueHandler] = None,
         validate_after_sanitize: bool = False,
+        validator: Optional[AbstractValidator] = None,
     ) -> None:
+        if validator:
+            fname_validator = validator
+        else:
+            fname_validator = FileNameValidator(
+                min_len=DEFAULT_MIN_LEN,
+                max_len=max_len,
+                fs_encoding=fs_encoding,
+                check_reserved=check_reserved,
+                platform=platform,
+            )
+
         super().__init__(
-            min_len=min_len,
             max_len=max_len,
             fs_encoding=fs_encoding,
             check_reserved=check_reserved,
             null_value_handler=null_value_handler,
             platform_max_len=_DEFAULT_MAX_FILENAME_LEN,
             platform=platform,
             validate_after_sanitize=validate_after_sanitize,
+            validator=fname_validator,
         )
 
         self._sanitize_regexp = self._get_sanitize_regexp()
-        self.__validator = FileNameValidator(
-            min_len=self.min_len,
-            max_len=self.max_len,
-            check_reserved=check_reserved,
-            platform=self.platform,
-        )
 
     def sanitize(self, value: PathType, replacement_text: str = "") -> PathType:
         try:
@@ -69,7 +74,7 @@ def sanitize(self, value: PathType, replacement_text: str = "") -> PathType:
         sanitized_filename = sanitized_filename[: self.max_len]
 
         try:
-            self.__validator.validate(sanitized_filename)
+            self._validator.validate(sanitized_filename)
         except ValidationError as e:
             if e.reason == ErrorReason.RESERVED_NAME and e.reusable_name is False:
                 sanitized_filename = re.sub(
@@ -90,7 +95,7 @@ def sanitize(self, value: PathType, replacement_text: str = "") -> PathType:
 
         if self._validate_after_sanitize:
             try:
-                self.__validator.validate(sanitized_filename)
+                self._validator.validate(sanitized_filename)
             except ValidationError as e:
                 raise ValidationError(
                     description=str(e),

pathvalidate/_filepath.py

@@ -9,7 +9,7 @@
 from pathlib import Path
 from typing import List, Optional, Pattern, Tuple
 
-from ._base import AbstractSanitizer, BaseFile, BaseValidator
+from ._base import AbstractSanitizer, AbstractValidator, BaseFile, BaseValidator
 from ._common import findall_to_str, to_str, validate_pathtype
 from ._const import _NTFS_RESERVED_FILE_NAMES, DEFAULT_MIN_LEN, INVALID_CHAR_ERR_MSG_TMPL, Platform
 from ._filename import FileNameSanitizer, FileNameValidator
@@ -25,36 +25,41 @@
 class FilePathSanitizer(AbstractSanitizer):
     def __init__(
         self,
-        min_len: int = DEFAULT_MIN_LEN,
         max_len: int = -1,
         fs_encoding: Optional[str] = None,
         platform: Optional[PlatformType] = None,
         check_reserved: bool = True,
         null_value_handler: Optional[NullValueHandler] = None,
         normalize: bool = True,
         validate_after_sanitize: bool = False,
+        validator: Optional[AbstractValidator] = None,
     ) -> None:
+        if validator:
+            fpath_validator = validator
+        else:
+            fpath_validator = FilePathValidator(
+                min_len=DEFAULT_MIN_LEN,
+                max_len=max_len,
+                fs_encoding=fs_encoding,
+                check_reserved=check_reserved,
+                platform=platform,
+            )
         super().__init__(
-            min_len=min_len,
             max_len=max_len,
             fs_encoding=fs_encoding,
             check_reserved=check_reserved,
+            validator=fpath_validator,
             null_value_handler=null_value_handler,
             platform=platform,
             validate_after_sanitize=validate_after_sanitize,
         )
 
         self._sanitize_regexp = self._get_sanitize_regexp()
-        self.__fpath_validator = FilePathValidator(
-            min_len=self.min_len,
-            max_len=self.max_len,
-            check_reserved=check_reserved,
-            platform=self.platform,
-        )
         self.__fname_sanitizer = FileNameSanitizer(
-            min_len=self.min_len,
             max_len=self.max_len,
+            fs_encoding=fs_encoding,
             check_reserved=check_reserved,
+            null_value_handler=null_value_handler,
             platform=self.platform,
             validate_after_sanitize=validate_after_sanitize,
         )
@@ -76,8 +81,6 @@ def sanitize(self, value: PathType, replacement_text: str = "") -> PathType:
                 return self._null_value_handler(e)
             raise
 
-        self.__fpath_validator.validate_abspath(value)
-
         unicode_filepath = to_str(value)
 
         drive, unicode_filepath = self.__split_drive(unicode_filepath)
@@ -106,13 +109,13 @@ def sanitize(self, value: PathType, replacement_text: str = "") -> PathType:
 
         sanitized_path = self.__get_path_separator().join(sanitized_entries)
         try:
-            self.__fpath_validator.validate(sanitized_path)
+            self._validator.validate(sanitized_path)
         except ValidationError as e:
             if e.reason == ErrorReason.NULL_NAME:
                 sanitized_path = self._null_value_handler(e)
 
         if self._validate_after_sanitize:
-            self.__fpath_validator.validate(sanitized_path)
+            self._validator.validate(sanitized_path)
 
         if isinstance(value, Path):
             return Path(sanitized_path)

test/test_filepath.py

@@ -794,12 +794,19 @@ def test_auto_platform_win(self, value, expected):
         ],
     )
     def test_auto_platform_linux(self, value, expected):
+        kwargs = {
+            "platform": "auto",
+            "validate_after_sanitize": True,
+        }
+
         if isinstance(expected, str):
-            sanitized = sanitize_filepath(value, platform="auto")
+            sanitized = sanitize_filepath(value, **kwargs)
             assert is_valid_filepath(sanitized, platform="auto")
-        else:
-            with pytest.raises(expected):
-                sanitize_filepath(value, platform="auto")
+            return
+
+        with pytest.raises(expected) as e:
+            sanitize_filepath(value, **kwargs)
+        assert e.value.reason == ErrorReason.MALFORMED_ABS_PATH
 
     @pytest.mark.parametrize(
         ["platform", "value"],