Feat: Add 'patterns' entry in specific_args (#52)

Author: adrien-berchet

.pylintrc

@@ -2,6 +2,7 @@
 disable=
 	arguments-differ,
 	invalid-name,
+	too-many-lines,
 
 [FORMAT]
 # Regexp for a line that is allowed to be longer than the limit.

README.md

@@ -163,6 +163,18 @@ specific_args = {
 }
 ```
 
+And last but not least, it's possible to use regular expressions to associate specific arguments to
+a set of files:
+
+```python
+specific_args = {
+    "all files with *.a of *.b extensions": {
+        "patterns": [r".*\.[a,b]$"],
+        "comparator": dir_content_diff.BaseComparator(),
+    }
+}
+```
+
 
 ### Export formatted data
 

dir_content_diff/__init__.py

@@ -5,6 +5,7 @@
 import copy
 import importlib.metadata
 import logging
+import re
 from pathlib import Path
 
 from dir_content_diff.base_comparators import DefaultComparator
@@ -240,9 +241,19 @@ def compare_trees(
                             kwarg_name_2: kwarg_value_2,
                         }
                     },
-                    <another_file_path>: {...}
+                    <another_file_path>: {...},
+                    <a name for this category>: {
+                        "patterns": ["regex1", "regex2", ...],
+                        ... (other arguments)
+                    }
                 }
 
+            If the "patterns" entry is present, then the name is not considered and is only used as
+            a helper for the user. When a "patterns" entry is detected, the other arguments are
+            applied to all files whose relative name matches one of the given regular expression
+            patterns. If a file could match multiple patterns of different groups, only the first
+            one is considered.
+
             Note that all entries in this ``dict`` are optional.
         return_raw_diffs (bool): If set to ``True``, only the raw differences are returned instead
             of a formatted report.
@@ -275,6 +286,11 @@ def compare_trees(
     else:
         specific_args = copy.deepcopy(specific_args)
 
+    pattern_specific_args = {}
+    for v in specific_args.values():
+        for pattern in v.pop("patterns", []):
+            pattern_specific_args[re.compile(pattern)] = v
+
     # Loop over all files and call the correct comparator
     different_files = {}
     for ref_file in ref_path.glob("**/*"):
@@ -285,7 +301,14 @@ def compare_trees(
         comp_file = comp_path / relative_path
 
         if comp_file.exists():
-            specific_file_args = specific_args.get(relative_path, {})
+            specific_file_args = specific_args.get(relative_path, None)
+            if specific_file_args is None:
+                for pattern, pattern_args in pattern_specific_args.items():
+                    if pattern.match(relative_path):
+                        specific_file_args = copy.deepcopy(pattern_args)
+                        break
+            if specific_file_args is None:
+                specific_file_args = {}
             comparator = specific_file_args.pop(
                 "comparator",
                 comparators.get(

tests/conftest.py

@@ -125,6 +125,12 @@ def dict_diff():
     return diff
 
 
+@pytest.fixture
+def base_diff():
+    """The diff that should be reported for the XML files."""
+    return r"The files '\S*/file\..{3,4}' and '\S*/file\..{3,4}' are different\."
+
+
 @pytest.fixture
 def xml_diff(dict_diff):
     """The diff that should be reported for the XML files."""

tests/test_base.py

@@ -716,6 +716,41 @@ def test_specific_comparator(self, ref_tree, res_tree_equal):
 
         assert res == {}
 
+    def test_specific_patterns(self, ref_tree, res_tree_equal, base_diff):
+        """Test specific args."""
+        specific_args = {
+            "all yaml files": {
+                "args": [None, None, None, False, 0, False],
+                "patterns": [r".*\.yaml"],
+            },
+            "all json files": {
+                "comparator": dir_content_diff.DefaultComparator(),
+                "patterns": [r".*\.json"],
+            },
+        }
+        res = compare_trees(ref_tree, res_tree_equal, specific_args=specific_args)
+
+        assert res == {}
+
+        # Test pattern override
+        specific_args["all json files"]["comparator"] = dir_content_diff.PdfComparator()
+        specific_args["file.json"] = {"comparator": dir_content_diff.DefaultComparator()}
+        res = compare_trees(ref_tree, res_tree_equal, specific_args=specific_args)
+
+        assert res == {}
+
+        # Test pattern multiple matches
+        specific_args = {
+            "all files": {
+                "comparator": dir_content_diff.DefaultComparator(),
+                "patterns": [r"file\..*"],
+            },
+        }
+        res = compare_trees(ref_tree, res_tree_equal, specific_args=specific_args)
+
+        assert list(res.keys()) == ["file.pdf"]
+        assert re.match(base_diff, res["file.pdf"]) is not None
+
 
 class TestDiffTrees:
     """Tests that should return differences."""
@@ -851,6 +886,48 @@ def test_specific_args(self, ref_tree, res_tree_diff, dict_diff, xml_diff, ini_d
         for match_i in [match_res_0, match_res_1, match_res_2, match_res_3]:
             assert match_i is not None
 
+    def test_specific_patterns(self, ref_tree, res_tree_diff, base_diff, dict_diff):
+        """Test specific args."""
+        specific_args = {
+            "all yaml files": {
+                "args": [None, None, None, False, 0, False],
+                "patterns": [r".*\.yaml"],
+            },
+            "all json files": {
+                "comparator": dir_content_diff.DefaultComparator(),
+                "patterns": [r".*\.json"],
+            },
+        }
+        res = compare_trees(ref_tree, res_tree_diff, specific_args=specific_args)
+
+        assert re.match(base_diff, res["file.json"]) is not None
+
+        # Test pattern override
+        specific_args["all json files"]["comparator"] = dir_content_diff.DefaultComparator()
+        specific_args["file.json"] = {"comparator": dir_content_diff.JsonComparator()}
+        res = compare_trees(ref_tree, res_tree_diff, specific_args=specific_args)
+
+        assert re.match(dict_diff, res["file.json"]) is not None
+
+        # Test pattern multiple matches
+        specific_args = {
+            "all files": {
+                "comparator": dir_content_diff.DefaultComparator(),
+                "patterns": [r"file\..*"],
+            },
+        }
+        res = compare_trees(ref_tree, res_tree_diff, specific_args=specific_args)
+
+        assert sorted(res.keys()) == [
+            "file.ini",
+            "file.json",
+            "file.pdf",
+            "file.xml",
+            "file.yaml",
+        ]
+        for v in res.values():
+            assert re.match(base_diff, v)
+
     def test_unknown_comparator(self, ref_tree, res_tree_diff, registry_reseter):
         """Test with an unknown extension."""
         dir_content_diff.unregister_comparator(".yaml")