woolly 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

woolly/reporters/markdown.py

@@ -4,9 +4,7 @@ Markdown report generator.
 Generates a markdown file with the full dependency analysis.
 """
 
-import re
-
-from woolly.reporters.base import Reporter, ReportData
+from woolly.reporters.base import ReportData, Reporter, strip_markup
 
 
 class MarkdownReporter(Reporter):
@@ -29,6 +27,10 @@ class MarkdownReporter(Reporter):
         lines.append(f"**Registry:** {data.registry}")
         if data.version:
             lines.append(f"**Version:** {data.version}")
+        if data.include_optional:
+            lines.append("**Include optional:** Yes")
+        if data.missing_only:
+            lines.append("**Missing only:** Yes")
         lines.append("")
 
         # Summary
@@ -39,85 +41,68 @@ class MarkdownReporter(Reporter):
         lines.append(f"| Total dependencies checked | {data.total_dependencies} |")
         lines.append(f"| Packaged in Fedora | {data.packaged_count} |")
         lines.append(f"| Missing from Fedora | {data.missing_count} |")
+
+        # Optional dependency stats
+        if data.optional_total > 0:
+            lines.append(f"| Optional dependencies | {data.optional_total} |")
+            lines.append(f"| Optional - Packaged | {data.optional_packaged} |")
+            lines.append(f"| Optional - Missing | {data.optional_missing} |")
         lines.append("")
 
-        # Missing packages
-        if data.missing_packages:
+        # Missing packages - use computed properties from ReportData
+        required_missing = data.required_missing_packages
+        optional_missing = data.optional_missing_set
+
+        if required_missing:
             lines.append("## Missing Packages")
             lines.append("")
             lines.append("The following packages need to be packaged for Fedora:")
             lines.append("")
-            for name in sorted(set(data.missing_packages)):
+            for name in sorted(required_missing):
                 lines.append(f"- `{name}`")
             lines.append("")
 
-        # Packaged packages
-        if data.packaged_packages:
+        if optional_missing:
+            lines.append("## Missing Optional Packages")
+            lines.append("")
+            lines.append("The following optional packages are not available in Fedora:")
+            lines.append("")
+            for name in sorted(optional_missing):
+                lines.append(f"- `{name}` *(optional)*")
+            lines.append("")
+
+        # Packaged packages - use computed property (skip if missing_only mode)
+        if data.unique_packaged_packages and not data.missing_only:
             lines.append("## Packaged Packages")
             lines.append("")
             lines.append("The following packages are already available in Fedora:")
             lines.append("")
-            for name in sorted(set(data.packaged_packages)):
+            for name in sorted(data.unique_packaged_packages):
                 lines.append(f"- `{name}`")
             lines.append("")
 
-        # Dependency tree
-        lines.append("## Dependency Tree")
-        lines.append("")
-        lines.append("```")
-        lines.append(self._tree_to_text(data.tree))
-        lines.append("```")
-        lines.append("")
+        # Dependency tree (skip if missing_only mode)
+        if not data.missing_only:
+            lines.append("## Dependency Tree")
+            lines.append("")
+            lines.append("```")
+            lines.append(self._tree_to_text(data.tree))
+            lines.append("```")
+            lines.append("")
 
         return "\n".join(lines)
 
-    def _get_label(self, node) -> str:
-        """Extract the label text from a tree node, handling nested Trees."""
-        # If it's a string, return it directly
-        if isinstance(node, str):
-            return node
-
-        # Try to get label attribute (Rich Tree has this)
-        if hasattr(node, "label"):
-            label = node.label
-            # If label is None, return empty string
-            if label is None:
-                return ""
-            # If label is another Tree-like object (has its own label), recurse
-            if hasattr(label, "label"):
-                return self._get_label(label)
-            # Otherwise convert to string
-            return str(label)
-
-        # Fallback - shouldn't happen
-        return str(node)
-
-    def _get_children(self, node) -> list:
-        """Get all children from a tree node, flattening nested Trees."""
-        children = []
-
-        if hasattr(node, "children"):
-            for child in node.children:
-                # If the child's label is itself a Tree, use that Tree's children
-                if hasattr(child, "label") and hasattr(child.label, "children"):
-                    # The child is a wrapper around another tree
-                    children.append(child.label)
-                else:
-                    children.append(child)
-
-        return children
-
     def _tree_to_text(self, tree, prefix: str = "") -> str:
         """Convert Rich Tree to plain text representation."""
         lines = []
 
-        # Get label text (strip Rich markup)
+        # Get label text (strip Rich markup) using inherited method and shared utility
         label = self._get_label(tree)
-        label = self._strip_markup(label)
+        label = strip_markup(label)
 
         lines.append(label)
 
-        # Get children
+        # Get children using inherited method
         children = self._get_children(tree)
 
         for i, child in enumerate(children):
@@ -133,8 +118,3 @@ class MarkdownReporter(Reporter):
                     lines.append(line)
 
         return "\n".join(lines)
-
-    def _strip_markup(self, text: str) -> str:
-        """Strip Rich markup from text."""
-        # Remove Rich markup tags like [bold], [/bold], [green], etc.
-        return re.sub(r"\[/?[^\]]+\]", "", text)

woolly/reporters/stdout.py

@@ -8,7 +8,7 @@ from rich import box
 from rich.console import Console
 from rich.table import Table
 
-from woolly.reporters.base import Reporter, ReportData
+from woolly.reporters.base import ReportData, Reporter
 
 
 class StdoutReporter(Reporter):
@@ -36,19 +36,41 @@ class StdoutReporter(Reporter):
         table.add_row("[green]Packaged in Fedora[/green]", str(data.packaged_count))
         table.add_row("[red]Missing from Fedora[/red]", str(data.missing_count))
 
+        # Show optional dependency stats if any were found
+        if data.optional_total > 0:
+            table.add_row("", "")  # Empty row as separator
+            table.add_row(
+                "[yellow]Optional dependencies[/yellow]", str(data.optional_total)
+            )
+            table.add_row("[yellow]  ├─ Packaged[/yellow]", str(data.optional_packaged))
+            table.add_row("[yellow]  └─ Missing[/yellow]", str(data.optional_missing))
+
         self.console.print(table)
         self.console.print()
 
-        # Print missing packages list
+        # Print missing packages list using computed properties
         if data.missing_packages:
-            self.console.print("[bold]Missing packages that need packaging:[/bold]")
-            for name in sorted(set(data.missing_packages)):
-                self.console.print(f"  • {name}")
-            self.console.print()
+            required_missing = data.required_missing_packages
+            optional_missing = data.optional_missing_set
 
-        # Print dependency tree
-        self.console.print("[bold]Dependency Tree:[/bold]")
-        self.console.print(data.tree)
-        self.console.print()
+            if required_missing:
+                self.console.print("[bold]Missing packages that need packaging:[/bold]")
+                for name in sorted(required_missing):
+                    self.console.print(f"  • {name}")
+                self.console.print()
+
+            if optional_missing:
+                self.console.print(
+                    "[bold yellow]Missing optional packages:[/bold yellow]"
+                )
+                for name in sorted(optional_missing):
+                    self.console.print(f"  • {name} [dim](optional)[/dim]")
+                self.console.print()
+
+        # Print dependency tree (skip if missing_only mode is enabled)
+        if not data.missing_only:
+            self.console.print("[bold]Dependency Tree:[/bold]")
+            self.console.print(data.tree)
+            self.console.print()
 
         return ""  # Output is printed directly

woolly/reporters/template.py

@@ -0,0 +1,215 @@
+"""
+Template-based report generator using Jinja2.
+
+Allows users to provide a custom markdown template file for report generation.
+Only a limited set of variables are exposed for security and simplicity.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+from woolly.reporters.base import ReportData, Reporter, strip_markup
+
+
+class TemplateReporter(Reporter):
+    """Reporter that generates reports from user-provided Jinja2 templates.
+
+    This reporter allows users to customize the output format by providing
+    a markdown template file. Only a limited, safe set of variables are
+    exposed to the template.
+
+    Available template variables:
+        Metadata:
+            - root_package: Name of the analyzed package
+            - language: Language/ecosystem name (e.g., "Rust", "Python")
+            - registry: Registry name (e.g., "crates.io", "PyPI")
+            - version: Package version (if specified)
+            - timestamp: Formatted timestamp string (YYYY-MM-DD HH:MM:SS)
+            - max_depth: Maximum recursion depth used
+
+        Statistics:
+            - total_dependencies: Total number of dependencies analyzed
+            - packaged_count: Number of packages available in Fedora
+            - missing_count: Number of packages missing from Fedora
+
+        Optional dependency statistics:
+            - include_optional: Whether optional deps were included
+            - optional_total: Total optional dependencies
+            - optional_packaged: Optional deps available in Fedora
+            - optional_missing: Optional deps missing from Fedora
+
+        Package lists (sorted):
+            - missing_packages: List of missing required package names
+            - packaged_packages: List of packaged package names
+            - optional_missing_packages: List of missing optional package names
+
+        Flags:
+            - missing_only: Whether missing-only mode was enabled
+
+    Example template:
+        # 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 %}
+    """
+
+    name = "template"
+    description = "Custom template-based report (requires --template)"
+    file_extension = "md"
+    writes_to_file = True
+
+    def __init__(self, template_path: Optional[Path] = None):
+        """Initialize the template reporter.
+
+        Args:
+            template_path: Path to the Jinja2 template file.
+        """
+        self._template_path = template_path
+        self._jinja2_available: Optional[bool] = None
+
+    @property
+    def template_path(self) -> Optional[Path]:
+        """Get the template path."""
+        return self._template_path
+
+    @template_path.setter
+    def template_path(self, value: Optional[Path]) -> None:
+        """Set the template path."""
+        self._template_path = value
+
+    def _check_jinja2(self) -> bool:
+        """Check if Jinja2 is available.
+
+        Returns:
+            True if Jinja2 is available, False otherwise.
+        """
+        if self._jinja2_available is None:
+            try:
+                import jinja2  # type: ignore[import-not-found]  # noqa: F401
+
+                self._jinja2_available = True
+            except ImportError:
+                self._jinja2_available = False
+        return self._jinja2_available
+
+    def _get_template_context(self, data: ReportData) -> dict:
+        """Build the template context with allowed variables only.
+
+        This method creates a safe, limited context for template rendering.
+        Only specific variables from ReportData are exposed.
+
+        Args:
+            data: Report data containing all information.
+
+        Returns:
+            Dictionary of template variables.
+        """
+        return {
+            # Metadata
+            "root_package": data.root_package,
+            "language": data.language,
+            "registry": data.registry,
+            "version": data.version,
+            "timestamp": data.timestamp.strftime("%Y-%m-%d %H:%M:%S"),
+            "max_depth": data.max_depth,
+            # Statistics
+            "total_dependencies": data.total_dependencies,
+            "packaged_count": data.packaged_count,
+            "missing_count": data.missing_count,
+            # Optional dependency statistics
+            "include_optional": data.include_optional,
+            "optional_total": data.optional_total,
+            "optional_packaged": data.optional_packaged,
+            "optional_missing": data.optional_missing,
+            # Package lists (sorted for consistent output)
+            "missing_packages": sorted(data.required_missing_packages),
+            "packaged_packages": sorted(data.unique_packaged_packages),
+            "optional_missing_packages": sorted(data.optional_missing_set),
+            # Flags
+            "missing_only": data.missing_only,
+        }
+
+    def generate(self, data: ReportData) -> str:
+        """Generate report content from the template.
+
+        Args:
+            data: Report data containing all information.
+
+        Returns:
+            Rendered template content as a string.
+
+        Raises:
+            RuntimeError: If Jinja2 is not installed or template is not set.
+            FileNotFoundError: If the template file doesn't exist.
+            jinja2.TemplateError: If there's a template syntax error.
+        """
+        if not self._check_jinja2():
+            raise RuntimeError(
+                "Jinja2 is required for template reports. "
+                "Install it with: pip install jinja2"
+            )
+
+        if self._template_path is None:
+            raise RuntimeError(
+                "No template path specified. Use --template to provide a template file."
+            )
+
+        if not self._template_path.exists():
+            raise FileNotFoundError(f"Template file not found: {self._template_path}")
+
+        # Import Jinja2 here (we've already checked it's available)
+        from jinja2 import (  # type: ignore[import-not-found]
+            Environment,
+            FileSystemLoader,
+            StrictUndefined,
+            select_autoescape,
+        )
+
+        # Create Jinja2 environment with security settings
+        env = Environment(
+            loader=FileSystemLoader(self._template_path.parent),
+            autoescape=select_autoescape(default=False),
+            undefined=StrictUndefined,  # Raise error on undefined variables
+            # Disable dangerous features
+            extensions=[],
+        )
+
+        # Add custom filter to strip Rich markup
+        env.filters["strip_markup"] = strip_markup
+
+        # Load and render template
+        template = env.get_template(self._template_path.name)
+        context = self._get_template_context(data)
+
+        return template.render(**context)
+
+    def get_output_filename(self, data: ReportData) -> str:
+        """Get the output filename for the template report.
+
+        Uses the template filename as a base if available, otherwise
+        falls back to the default naming convention.
+
+        Args:
+            data: Report data.
+
+        Returns:
+            Filename string.
+        """
+        timestamp = data.timestamp.strftime("%Y%m%d_%H%M%S")
+        if self._template_path:
+            # Use template name as base (without extension)
+            base_name = self._template_path.stem
+            return f"woolly_{data.root_package}_{base_name}_{timestamp}.md"
+        return f"woolly_{data.root_package}_template_{timestamp}.md"