Refactor filename matching logic to separate classes

Signed-off-by: Olivier Mehani <shtrom@ssji.net>

Author: shtrom

rotate_backups/__init__.py

@@ -260,6 +260,58 @@ def rotate_backups(directory, rotation_scheme, **options):
     program.rotate_backups(directory)
 
 
+class Match:
+    def match_to_datetime(self) -> datetime.datetime:
+        pass
+
+
+class Matcher:
+    def search(self, entry: str) -> Match:
+        pass
+
+
+class FilenameMatch(Match):
+    match: re.Match = None
+
+    def __init__(self, match: re.Match):
+        self.match = match
+
+    def match_to_datetime(self) -> datetime.datetime:
+        """
+        Convert the regular expression match to a :class:`~datetime.datetime` value.
+
+        :returns: A :class:`~datetime.datetime` value.
+        :raises: :exc:`exceptions.ValueError` when a required date component is
+                 not captured by the pattern, the captured value is an empty
+                 string or the captured value cannot be interpreted as a
+                 base-10 integer.
+
+        .. seealso:: :data:`SUPPORTED_DATE_COMPONENTS`
+        """
+        kw = {}
+        captures = self.match.groupdict()
+        for component, required in SUPPORTED_DATE_COMPONENTS:
+            value = captures.get(component)
+            if value:
+                kw[component] = int(value, 10)
+            elif required:
+                raise ValueError("Missing required date component! (%s)" % component)
+            else:
+                kw[component] = 0
+        return datetime.datetime(**kw)
+
+
+class FilenameMatcher(Matcher):
+    timestamp_pattern: re.Pattern = None
+
+    def __init__(self, timestamp_pattern: re.Pattern):
+        self.timestamp_pattern = timestamp_pattern
+
+    def search(self, entry: str) -> FilenameMatch:
+        if match := self.timestamp_pattern.search(entry):
+            return FilenameMatch(match)
+
+
 class RotateBackups(PropertyManager):
 
     """Python API for the ``rotate-backups`` program."""
@@ -642,8 +694,10 @@ def collect_backups(self, location):
         location = coerce_location(location)
         logger.info("Scanning %s for backups ..", location)
         location.ensure_readable(self.force)
+
+        matcher = FilenameMatcher(self.timestamp_pattern)
         for entry in natsort(location.context.list_entries(location.directory)):
-            match = self.timestamp_pattern.search(entry)
+            match = matcher.search(entry)
             if match:
                 if self.exclude_list and any(fnmatch.fnmatch(entry, p) for p in self.exclude_list):
                     logger.verbose("Excluded %s (it matched the exclude list).", entry)
@@ -653,7 +707,7 @@ def collect_backups(self, location):
                     try:
                         backups.append(Backup(
                             pathname=os.path.join(location.directory, entry),
-                            timestamp=self.match_to_datetime(match),
+                            timestamp=match.match_to_datetime(),
                         ))
                     except ValueError as e:
                         logger.notice("Ignoring %s due to invalid date (%s).", entry, e)
@@ -663,31 +717,6 @@ def collect_backups(self, location):
             logger.info("Found %i timestamped backups in %s.", len(backups), location)
         return sorted(backups)
 
-    def match_to_datetime(self, match):
-        """
-        Convert a regular expression match to a :class:`~datetime.datetime` value.
-
-        :param match: A regular expression match object.
-        :returns: A :class:`~datetime.datetime` value.
-        :raises: :exc:`exceptions.ValueError` when a required date component is
-                 not captured by the pattern, the captured value is an empty
-                 string or the captured value cannot be interpreted as a
-                 base-10 integer.
-
-        .. seealso:: :data:`SUPPORTED_DATE_COMPONENTS`
-        """
-        kw = {}
-        captures = match.groupdict()
-        for component, required in SUPPORTED_DATE_COMPONENTS:
-            value = captures.get(component)
-            if value:
-                kw[component] = int(value, 10)
-            elif required:
-                raise ValueError("Missing required date component! (%s)" % component)
-            else:
-                kw[component] = 0
-        return datetime.datetime(**kw)
-
     def group_backups(self, backups):
         """
         Group backups collected by :func:`collect_backups()` by rotation frequencies.
@@ -781,25 +810,25 @@ class Location(PropertyManager):
 
     """:class:`Location` objects represent a root directory containing backups."""
 
-    @required_property
+    @ required_property
     def context(self):
         """An execution context created using :mod:`executor.contexts`."""
 
-    @required_property
+    @ required_property
     def directory(self):
         """The pathname of a directory containing backups (a string)."""
 
-    @lazy_property
+    @ lazy_property
     def have_ionice(self):
         """:data:`True` when ionice_ is available, :data:`False` otherwise."""
         return self.context.have_ionice
 
-    @lazy_property
+    @ lazy_property
     def have_wildcards(self):
         """:data:`True` if :attr:`directory` is a filename pattern, :data:`False` otherwise."""
         return '*' in self.directory
 
-    @lazy_property
+    @ lazy_property
     def mount_point(self):
         """
         The pathname of the mount point of :attr:`directory` (a string or :data:`None`).
@@ -814,17 +843,17 @@ def mount_point(self):
         except ExternalCommandFailed:
             return None
 
-    @lazy_property
+    @ lazy_property
     def is_remote(self):
         """:data:`True` if the location is remote, :data:`False` otherwise."""
         return isinstance(self.context, RemoteContext)
 
-    @lazy_property
+    @ lazy_property
     def ssh_alias(self):
         """The SSH alias of a remote location (a string or :data:`None`)."""
         return self.context.ssh_alias if self.is_remote else None
 
-    @property
+    @ property
     def key_properties(self):
         """
         A list of strings with the names of the :attr:`~custom_property.key` properties.
@@ -975,15 +1004,15 @@ class Backup(PropertyManager):
     :attr:`~property_manager.PropertyManager.key_properties`.
     """
 
-    @key_property
+    @ key_property
     def pathname(self):
         """The pathname of the backup (a string)."""
 
-    @key_property
+    @ key_property
     def timestamp(self):
         """The date and time when the backup was created (a :class:`~datetime.datetime` object)."""
 
-    @property
+    @ property
     def week(self):
         """The ISO week number of :attr:`timestamp` (a number)."""
         return self.timestamp.isocalendar()[1]