woolly 0.3.0__tar.gz → 0.4.0__tar.gz

{woolly-0.3.0 → woolly-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: woolly
-Version: 0.3.0
+Version: 0.4.0
 Summary: Check if package dependencies are available in Fedora. Supports Rust, Python, and more.
 Author-email: Rodolfo Olivieri <rodolfo.olivieri3@gmail.com>
 License-File: LICENSE
@@ -26,6 +26,8 @@ Requires-Dist: cyclopts>=4.3.0
 Requires-Dist: httpx>=0.28.0
 Requires-Dist: pydantic>=2.10.0
 Requires-Dist: rich>=14.2.0
+Provides-Extra: template
+Requires-Dist: jinja2>=3.1.0; extra == 'template'
 Description-Content-Type: text/markdown
 
 # 🐑 Woolly

woolly-0.4.0/examples/template/example_template.md

@@ -0,0 +1,16 @@
+ Report for {{ root_package }}
+
+Generated: {{ timestamp }}
+Language: {{ language }}
+
+## Summary
+- Total: {{ total_dependencies }}
+- Packaged: {{ packaged_count }}
+- Missing: {{ missing_count }}
+
+{% if missing_packages %}
+## Missing Packages
+{% for pkg in missing_packages %}
+- {{ pkg }}
+{% endfor %}
+{% endif %}

{woolly-0.3.0 → woolly-0.4.0}/pyproject.toml

@@ -37,6 +37,11 @@ classifiers = [
     "Topic :: Utilities",
 ]
 
+[project.optional-dependencies]
+template = [
+    "jinja2>=3.1.0",
+]
+
 [project.url]
 "Source code" = "https://github.com/r0x0d/woolly"
 "Bug Tracker" = "https://github.com/r0x0d/woolly/issues"

{woolly-0.3.0 → woolly-0.4.0}/tests/functional/test_cli.py

@@ -34,6 +34,7 @@ class TestCliHelp:
         assert result.returncode == 0
         assert "package" in result.stdout.lower()
         assert "--lang" in result.stdout
+        assert "--missing-only" in result.stdout
 
 
 class TestListLanguages:
@@ -263,6 +264,32 @@ class TestCheckCommandPython:
 class TestCheckCommandOptions:
     """Tests for check command options."""
 
+    @pytest.mark.functional
+    @pytest.mark.slow
+    def test_missing_only_option(self, cli_runner, tmp_path, monkeypatch):
+        """Good path: missing-only option is accepted."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+
+        result = cli_runner(
+            "check", "cfg-if", "--lang", "rust", "--missing-only", "--no-progress"
+        )
+
+        assert result.returncode == 0
+        # Should not show the dependency tree when --missing-only is used
+        assert "Dependency Tree:" not in result.stdout
+
+    @pytest.mark.functional
+    @pytest.mark.slow
+    def test_missing_only_short_option(self, cli_runner, tmp_path, monkeypatch):
+        """Good path: missing-only short option (-m) is accepted."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+
+        result = cli_runner("check", "cfg-if", "--lang", "rust", "-m", "--no-progress")
+
+        assert result.returncode == 0
+        # Should not show the dependency tree when -m is used
+        assert "Dependency Tree:" not in result.stdout
+
     @pytest.mark.functional
     @pytest.mark.slow
     def test_max_depth_option(self, cli_runner, tmp_path, monkeypatch):
@@ -275,6 +302,62 @@ class TestCheckCommandOptions:
 
         assert result.returncode == 0
 
+    @pytest.mark.functional
+    @pytest.mark.slow
+    def test_exclude_option(self, cli_runner, tmp_path, monkeypatch):
+        """Good path: exclude option is accepted and displayed."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+
+        result = cli_runner(
+            "check",
+            "cfg-if",
+            "--lang",
+            "rust",
+            "--exclude",
+            "windows*",
+            "--no-progress",
+        )
+
+        assert result.returncode == 0
+        assert "Excluding dependencies matching" in result.stdout
+        assert "windows*" in result.stdout
+
+    @pytest.mark.functional
+    @pytest.mark.slow
+    def test_exclude_multiple_patterns(self, cli_runner, tmp_path, monkeypatch):
+        """Good path: multiple exclude patterns are accepted."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+
+        result = cli_runner(
+            "check",
+            "cfg-if",
+            "--lang",
+            "rust",
+            "--exclude",
+            "windows*",
+            "--exclude",
+            "*-sys",
+            "--no-progress",
+        )
+
+        assert result.returncode == 0
+        assert "Excluding dependencies matching" in result.stdout
+        assert "windows*" in result.stdout
+        assert "*-sys" in result.stdout
+
+    @pytest.mark.functional
+    @pytest.mark.slow
+    def test_exclude_short_option(self, cli_runner, tmp_path, monkeypatch):
+        """Good path: -e short option works."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+
+        result = cli_runner(
+            "check", "cfg-if", "--lang", "rust", "-e", "win*", "--no-progress"
+        )
+
+        assert result.returncode == 0
+        assert "Excluding dependencies matching" in result.stdout
+
     @pytest.mark.functional
     @pytest.mark.slow
     def test_debug_option(self, cli_runner, tmp_path, monkeypatch):

{woolly-0.3.0 → woolly-0.4.0}/tests/unit/test_commands/test_check.py

@@ -170,6 +170,126 @@ class TestBuildTree:
 
         tracker.update.assert_called()
 
+    @pytest.mark.unit
+    def test_excludes_dependencies_matching_pattern(self, provider):
+        """Good path: excludes dependencies matching glob patterns."""
+        # Set up package with dependencies
+        provider.packages["parent"] = PackageInfo(name="parent", latest_version="1.0.0")
+        provider.packages["child"] = PackageInfo(name="child", latest_version="2.0.0")
+        provider.packages["windows-sys"] = PackageInfo(
+            name="windows-sys", latest_version="0.52.0"
+        )
+        provider.dependencies["parent:1.0.0"] = [
+            Dependency(name="child", version_requirement="^2.0", kind="normal"),
+            Dependency(name="windows-sys", version_requirement="^0.52", kind="normal"),
+        ]
+        provider.fedora_status["parent"] = FedoraPackageStatus(
+            is_packaged=True, versions=["1.0.0"]
+        )
+        provider.fedora_status["child"] = FedoraPackageStatus(
+            is_packaged=True, versions=["2.0.0"]
+        )
+        provider.fedora_status["windows-sys"] = FedoraPackageStatus(is_packaged=False)
+
+        tree = build_tree(provider, "parent", exclude_patterns=["windows*"])
+
+        # Should only have child, not windows-sys
+        assert isinstance(tree, Tree)
+        assert len(tree.children) == 1
+        child_label = str(tree.children[0].label)
+        assert "child" in child_label
+        # windows-sys should be excluded
+        for child in tree.children:
+            label = str(child.label) if hasattr(child, "label") else str(child)
+            assert "windows" not in label
+
+    @pytest.mark.unit
+    def test_excludes_multiple_patterns(self, provider):
+        """Good path: excludes dependencies matching multiple glob patterns."""
+        provider.packages["parent"] = PackageInfo(name="parent", latest_version="1.0.0")
+        provider.packages["good-dep"] = PackageInfo(
+            name="good-dep", latest_version="1.0.0"
+        )
+        provider.packages["win-dep"] = PackageInfo(
+            name="win-dep", latest_version="1.0.0"
+        )
+        provider.packages["macos-dep"] = PackageInfo(
+            name="macos-dep", latest_version="1.0.0"
+        )
+        provider.dependencies["parent:1.0.0"] = [
+            Dependency(name="good-dep", version_requirement="^1.0", kind="normal"),
+            Dependency(name="win-dep", version_requirement="^1.0", kind="normal"),
+            Dependency(name="macos-dep", version_requirement="^1.0", kind="normal"),
+        ]
+        provider.fedora_status["parent"] = FedoraPackageStatus(
+            is_packaged=True, versions=["1.0.0"]
+        )
+        provider.fedora_status["good-dep"] = FedoraPackageStatus(
+            is_packaged=True, versions=["1.0.0"]
+        )
+        provider.fedora_status["win-dep"] = FedoraPackageStatus(is_packaged=False)
+        provider.fedora_status["macos-dep"] = FedoraPackageStatus(is_packaged=False)
+
+        tree = build_tree(provider, "parent", exclude_patterns=["win*", "macos*"])
+
+        # Should only have good-dep
+        assert isinstance(tree, Tree)
+        assert len(tree.children) == 1
+        child_label = str(tree.children[0].label)
+        assert "good-dep" in child_label
+
+    @pytest.mark.unit
+    def test_exclude_patterns_applied_recursively(self, provider):
+        """Good path: exclude patterns are applied at all depth levels."""
+        provider.packages["root"] = PackageInfo(name="root", latest_version="1.0.0")
+        provider.packages["child"] = PackageInfo(name="child", latest_version="1.0.0")
+        provider.packages["windows-inner"] = PackageInfo(
+            name="windows-inner", latest_version="1.0.0"
+        )
+        provider.dependencies["root:1.0.0"] = [
+            Dependency(name="child", version_requirement="^1.0", kind="normal"),
+        ]
+        provider.dependencies["child:1.0.0"] = [
+            Dependency(name="windows-inner", version_requirement="^1.0", kind="normal"),
+        ]
+        provider.fedora_status["root"] = FedoraPackageStatus(
+            is_packaged=True, versions=["1.0.0"]
+        )
+        provider.fedora_status["child"] = FedoraPackageStatus(
+            is_packaged=True, versions=["1.0.0"]
+        )
+        provider.fedora_status["windows-inner"] = FedoraPackageStatus(is_packaged=False)
+
+        tree = build_tree(provider, "root", exclude_patterns=["windows*"])
+
+        # root -> child (no windows-inner)
+        assert isinstance(tree, Tree)
+        assert len(tree.children) == 1
+        child_tree = tree.children[0]
+        assert isinstance(child_tree, Tree)
+        # child should have no children (windows-inner was filtered)
+        assert len(child_tree.children) == 0
+
+    @pytest.mark.unit
+    def test_no_exclusion_when_patterns_none(self, provider):
+        """Good path: no exclusion when patterns is None."""
+        provider.packages["parent"] = PackageInfo(name="parent", latest_version="1.0.0")
+        provider.packages["child"] = PackageInfo(name="child", latest_version="1.0.0")
+        provider.dependencies["parent:1.0.0"] = [
+            Dependency(name="child", version_requirement="^1.0", kind="normal"),
+        ]
+        provider.fedora_status["parent"] = FedoraPackageStatus(
+            is_packaged=True, versions=["1.0.0"]
+        )
+        provider.fedora_status["child"] = FedoraPackageStatus(
+            is_packaged=True, versions=["1.0.0"]
+        )
+
+        tree = build_tree(provider, "parent", exclude_patterns=None)
+
+        assert isinstance(tree, Tree)
+        assert len(tree.children) == 1
+
 
 class TestCollectStats:
     """Tests for collect_stats function."""

{woolly-0.3.0 → woolly-0.4.0}/tests/unit/test_optional_dependencies.py

@@ -229,6 +229,7 @@ class TestBuildTreeOptional:
         """Good path: optional dependencies are marked in the tree."""
         tree = build_tree(provider, "parent", include_optional=True)
 
+        assert isinstance(tree, Tree)
         # Find optional children
         optional_count = 0
         for child in tree.children:
@@ -246,6 +247,7 @@ class TestBuildTreeOptional:
         """Good path: required dependencies don't have optional marker."""
         tree = build_tree(provider, "parent", include_optional=True)
 
+        assert isinstance(tree, Tree)
         # The root should not have optional marker
         label = str(tree.label)
         assert "(optional)" not in label
@@ -255,6 +257,7 @@ class TestBuildTreeOptional:
         """Critical path: is_optional_dep parameter adds marker."""
         tree = build_tree(provider, "required-child", is_optional_dep=True)
 
+        assert isinstance(tree, Tree)
         label = str(tree.label)
         assert "(optional)" in label
 

{woolly-0.3.0 → woolly-0.4.0}/tests/unit/test_reporters/test_json.py

@@ -179,3 +179,54 @@ class TestJsonReporterParseLabel:
 
         assert "[" not in result.raw
         assert "]" not in result.raw
+
+
+class TestJsonReporterMissingOnly:
+    """Tests for JsonReporter with missing_only flag."""
+
+    @pytest.mark.unit
+    def test_missing_only_metadata_included(self, sample_report_data):
+        """Good path: missing_only is included in metadata."""
+        sample_report_data.missing_only = True
+        reporter = JsonReporter()
+
+        result = reporter.generate(sample_report_data)
+        parsed = json.loads(result)
+
+        assert "missing_only" in parsed["metadata"]
+        assert parsed["metadata"]["missing_only"] is True
+
+    @pytest.mark.unit
+    def test_missing_only_excludes_packaged_packages(self, sample_report_data):
+        """Good path: excludes packaged packages when missing_only is True."""
+        sample_report_data.missing_only = True
+        reporter = JsonReporter()
+
+        result = reporter.generate(sample_report_data)
+        parsed = json.loads(result)
+
+        assert parsed["packaged_packages"] == []
+
+    @pytest.mark.unit
+    def test_missing_only_false_includes_packaged_packages(self, sample_report_data):
+        """Good path: includes packaged packages when missing_only is False."""
+        sample_report_data.missing_only = False
+        reporter = JsonReporter()
+
+        result = reporter.generate(sample_report_data)
+        parsed = json.loads(result)
+
+        assert len(parsed["packaged_packages"]) > 0
+        assert "packaged-a" in parsed["packaged_packages"]
+
+    @pytest.mark.unit
+    def test_missing_only_still_includes_missing_packages(self, sample_report_data):
+        """Good path: missing packages are still included when missing_only is True."""
+        sample_report_data.missing_only = True
+        reporter = JsonReporter()
+
+        result = reporter.generate(sample_report_data)
+        parsed = json.loads(result)
+
+        assert len(parsed["missing_packages"]) > 0
+        assert "missing-a" in parsed["missing_packages"]

{woolly-0.3.0 → woolly-0.4.0}/tests/unit/test_reporters/test_markdown.py

@@ -133,3 +133,68 @@ class TestMarkdownReporterTreeToText:
 
         # Should contain tree structure characters
         assert "├──" in result or "└──" in result
+
+
+class TestMarkdownReporterMissingOnly:
+    """Tests for MarkdownReporter with missing_only flag."""
+
+    @pytest.mark.unit
+    def test_missing_only_metadata_included(self, sample_report_data):
+        """Good path: shows missing_only indicator in metadata."""
+        sample_report_data.missing_only = True
+        reporter = MarkdownReporter()
+
+        result = reporter.generate(sample_report_data)
+
+        assert "**Missing only:** Yes" in result
+
+    @pytest.mark.unit
+    def test_missing_only_excludes_packaged_section(self, sample_report_data):
+        """Good path: excludes packaged packages section when missing_only is True."""
+        sample_report_data.missing_only = True
+        reporter = MarkdownReporter()
+
+        result = reporter.generate(sample_report_data)
+
+        assert "## Packaged Packages" not in result
+
+    @pytest.mark.unit
+    def test_missing_only_excludes_dependency_tree(self, sample_report_data):
+        """Good path: excludes dependency tree when missing_only is True."""
+        sample_report_data.missing_only = True
+        reporter = MarkdownReporter()
+
+        result = reporter.generate(sample_report_data)
+
+        assert "## Dependency Tree" not in result
+
+    @pytest.mark.unit
+    def test_missing_only_false_includes_packaged_section(self, sample_report_data):
+        """Good path: includes packaged section when missing_only is False."""
+        sample_report_data.missing_only = False
+        reporter = MarkdownReporter()
+
+        result = reporter.generate(sample_report_data)
+
+        assert "## Packaged Packages" in result
+
+    @pytest.mark.unit
+    def test_missing_only_false_includes_dependency_tree(self, sample_report_data):
+        """Good path: includes dependency tree when missing_only is False."""
+        sample_report_data.missing_only = False
+        reporter = MarkdownReporter()
+
+        result = reporter.generate(sample_report_data)
+
+        assert "## Dependency Tree" in result
+
+    @pytest.mark.unit
+    def test_missing_only_still_includes_missing_packages(self, sample_report_data):
+        """Good path: missing packages are still shown when missing_only is True."""
+        sample_report_data.missing_only = True
+        reporter = MarkdownReporter()
+
+        result = reporter.generate(sample_report_data)
+
+        assert "## Missing Packages" in result
+        assert "- `missing-a`" in result

{woolly-0.3.0 → woolly-0.4.0}/tests/unit/test_reporters/test_stdout.py

@@ -102,3 +102,32 @@ class TestStdoutReporterGenerate:
             for arg in args:
                 if isinstance(arg, str):
                     assert "Missing packages that need packaging" not in arg
+
+    @pytest.mark.unit
+    def test_missing_only_skips_dependency_tree(self, sample_report_data, mock_console):
+        """Good path: skips dependency tree when missing_only is True."""
+        sample_report_data.missing_only = True
+        reporter = StdoutReporter(console=mock_console)
+
+        reporter.generate(sample_report_data)
+
+        # Should not print "Dependency Tree:"
+        for call_obj in mock_console.print.call_args_list:
+            args = call_obj[0] if call_obj[0] else []
+            for arg in args:
+                if isinstance(arg, str):
+                    assert "Dependency Tree:" not in arg
+
+    @pytest.mark.unit
+    def test_missing_only_false_shows_dependency_tree(
+        self, sample_report_data, mock_console
+    ):
+        """Good path: shows dependency tree when missing_only is False."""
+        sample_report_data.missing_only = False
+        reporter = StdoutReporter(console=mock_console)
+
+        reporter.generate(sample_report_data)
+
+        # Should print "Dependency Tree:"
+        calls_str = str(mock_console.print.call_args_list)
+        assert "Dependency Tree" in calls_str