mvn-tree-visualizer 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

mvn_tree_visualizer/cli.py

@@ -1,11 +1,128 @@
 import argparse
+import time
 from pathlib import Path
 from typing import NoReturn
 
 from .diagram import create_diagram
+from .exceptions import DependencyFileNotFoundError, DependencyParsingError, MvnTreeVisualizerError, OutputGenerationError
+from .file_watcher import FileWatcher
 from .get_dependencies_in_one_file import merge_files
 from .outputs.html_output import create_html_diagram
 from .outputs.json_output import create_json_output
+from .validation import find_dependency_files, print_maven_help, validate_dependency_files, validate_output_directory
+
+
+def generate_diagram(
+    directory: str,
+    output_file: str,
+    filename: str,
+    keep_tree: bool,
+    output_format: str,
+    show_versions: bool,
+    theme: str = "minimal",
+) -> None:
+    """Generate the dependency diagram with comprehensive error handling."""
+    timestamp = time.strftime("%H:%M:%S")
+
+    try:
+        # Validate inputs
+        validate_dependency_files(directory, filename)
+        validate_output_directory(output_file)
+
+        # Show what files we found
+        dependency_files = find_dependency_files(directory, filename)
+        if len(dependency_files) > 1:
+            print(f"[{timestamp}] Found {len(dependency_files)} dependency files")
+
+        # Setup paths
+        dir_to_create_files = Path(output_file).parent
+        dir_to_create_intermediate_files = Path(dir_to_create_files)
+        intermediate_file_path: Path = dir_to_create_intermediate_files / "dependency_tree.txt"
+
+        # Merge dependency files
+        try:
+            merge_files(
+                output_file=intermediate_file_path,
+                root_dir=directory,
+                target_filename=filename,
+            )
+        except FileNotFoundError as e:
+            raise DependencyParsingError(f"Error reading dependency file: {e}\nThe file may have been moved or deleted during processing.")
+        except PermissionError as e:
+            raise DependencyParsingError(f"Permission denied while reading dependency files: {e}\nPlease check file permissions and try again.")
+        except UnicodeDecodeError as e:
+            raise DependencyParsingError(
+                f"Error decoding dependency file content: {e}\n"
+                f"The file may contain invalid characters or use an unsupported encoding.\n"
+                f"Please ensure the file is in UTF-8 format."
+            )
+
+        # Validate merged content
+        if not intermediate_file_path.exists() or intermediate_file_path.stat().st_size == 0:
+            raise DependencyParsingError(
+                "Generated dependency tree file is empty.\n"
+                "This usually means the Maven dependency files contain no valid dependency information.\n"
+                "Please check that your Maven dependency files were generated correctly."
+            )
+
+        # Create diagram from merged content
+        try:
+            dependency_tree = create_diagram(
+                keep_tree=keep_tree,
+                intermediate_filename=str(intermediate_file_path),
+            )
+        except FileNotFoundError:
+            raise DependencyParsingError("Intermediate dependency tree file was not found.\nThis is an internal error - please report this issue.")
+        except Exception as e:
+            raise DependencyParsingError(f"Error processing dependency tree: {e}\nThe dependency file format may be invalid or corrupted.")
+
+        # Validate that we have content to work with
+        if not dependency_tree.strip():
+            raise DependencyParsingError(
+                "Dependency tree is empty after processing.\n"
+                "Please check that your Maven dependency files contain valid dependency information.\n"
+                "You can verify this by opening the files and checking their content."
+            )
+
+        # Generate output
+        try:
+            if output_format == "html":
+                create_html_diagram(dependency_tree, output_file, show_versions, theme)
+            elif output_format == "json":
+                create_json_output(dependency_tree, output_file, show_versions)
+            else:
+                raise OutputGenerationError(f"Unsupported output format: {output_format}")
+        except PermissionError:
+            raise OutputGenerationError(
+                f"Permission denied writing to '{output_file}'.\nPlease check that you have write permissions to this location."
+            )
+        except OSError as e:
+            raise OutputGenerationError(
+                f"Error writing output file '{output_file}': {e}\nPlease check that you have enough disk space and write permissions."
+            )
+        except Exception as e:
+            raise OutputGenerationError(f"Error generating {output_format.upper()} output: {e}")
+
+        print(f"[{timestamp}] ✅ Diagram generated and saved to {output_file}")
+
+    except MvnTreeVisualizerError as e:
+        # Our custom errors already have helpful messages
+        print(f"[{timestamp}] ❌ Error: {e}")
+        if isinstance(e, DependencyFileNotFoundError):
+            print_maven_help()
+    except KeyboardInterrupt:
+        print(f"\n[{timestamp}] ⏹️  Operation cancelled by user")
+    except Exception as e:
+        # Unexpected errors
+        print(f"[{timestamp}] ❌ Unexpected error: {e}")
+        print("This is an internal error. Please report this issue with the following details:")
+        print(f"  - Directory: {directory}")
+        print(f"  - Filename: {filename}")
+        print(f"  - Output: {output_file}")
+        print(f"  - Format: {output_format}")
+        import traceback
+
+        traceback.print_exc()
 
 
 def cli() -> NoReturn:
@@ -57,6 +174,20 @@ def cli() -> NoReturn:
         help="Show dependency versions in the diagram. Applicable to both HTML and JSON output formats.",
     )
 
+    parser.add_argument(
+        "--watch",
+        action="store_true",
+        help="Watch for changes in Maven dependency files and automatically regenerate the diagram.",
+    )
+
+    parser.add_argument(
+        "--theme",
+        type=str,
+        default="minimal",
+        choices=["minimal", "dark"],
+        help="Theme for the diagram visualization. Default is 'minimal'.",
+    )
+
     args = parser.parse_args()
     directory: str = args.directory
     output_file: str = args.output
@@ -64,30 +195,30 @@ def cli() -> NoReturn:
     keep_tree: bool = args.keep_tree
     output_format: str = args.format
     show_versions: bool = args.show_versions
-
-    dir_to_create_files = Path(output_file).parent
-
-    dir_to_create_intermediate_files = Path(dir_to_create_files)
-
-    merge_files(
-        output_file=dir_to_create_intermediate_files / "dependency_tree.txt",
-        root_dir=directory,
-        target_filename=filename,
-    )
-
-    dependency_tree = create_diagram(
-        keep_tree=keep_tree,
-        intermediate_filename="dependency_tree.txt",
-    )
-
-    if output_format == "html":
-        create_html_diagram(dependency_tree, output_file, show_versions)
-    elif output_format == "json":
-        create_json_output(dependency_tree, output_file, show_versions)
-
-    print(f"Diagram generated and saved to {output_file}")
-    print("You can open it in your browser to view the dependency tree.")
-    print("Thank you for using mvn-tree-visualizer!")
+    watch_mode: bool = args.watch
+    theme: str = args.theme
+
+    # Generate initial diagram
+    print("Generating initial diagram...")
+    generate_diagram(directory, output_file, filename, keep_tree, output_format, show_versions, theme)
+
+    if not watch_mode:
+        print("You can open it in your browser to view the dependency tree.")
+        print("Thank you for using mvn-tree-visualizer!")
+        return
+
+    # Watch mode
+    def regenerate_callback():
+        """Callback function for file watcher."""
+        generate_diagram(directory, output_file, filename, keep_tree, output_format, show_versions, theme)
+
+    watcher = FileWatcher(directory, filename, regenerate_callback)
+    watcher.start()
+
+    try:
+        watcher.wait()
+    finally:
+        print("Thank you for using mvn-tree-visualizer!")
 
 
 if __name__ == "__main__":

mvn_tree_visualizer/diagram.py

@@ -5,10 +5,22 @@ def create_diagram(
     keep_tree: bool = False,
     intermediate_filename: str = "dependency_tree.txt",
 ) -> str:
-    with open(intermediate_filename, "r") as file:
-        dependency_tree: str = file.read()
+    """Create diagram from dependency tree file."""
+    try:
+        with open(intermediate_filename, "r", encoding="utf-8") as file:
+            dependency_tree: str = file.read()
+    except FileNotFoundError:
+        raise FileNotFoundError(f"Dependency tree file '{intermediate_filename}' not found")
+    except PermissionError:
+        raise PermissionError(f"Permission denied reading '{intermediate_filename}'")
+    except UnicodeDecodeError as e:
+        raise UnicodeDecodeError(e.encoding, e.object, e.start, e.end, f"Error decoding '{intermediate_filename}': {e.reason}")
 
     if not keep_tree:
-        os.remove(intermediate_filename)
+        try:
+            os.remove(intermediate_filename)
+        except OSError:
+            # If we can't remove the intermediate file, it's not critical
+            pass
 
     return dependency_tree

mvn_tree_visualizer/enhanced_template.py

@@ -0,0 +1,218 @@
+"""Enhanced HTML templates with the interactive features."""
+
+from typing import Any, Dict
+
+from .themes import STANDARD_COLORS, Theme
+
+
+def get_html_template(theme: Theme) -> str:
+    """Generate HTML template with theme-specific styling and interactive features."""
+
+    # Build Mermaid configuration
+    mermaid_config = {
+        "startOnLoad": True,
+        "sequence": {"useMaxWidth": False},
+        "theme": theme.mermaid_theme,
+        **theme.mermaid_config,
+    }
+
+    # Convert config to JavaScript object
+    mermaid_config_js = _dict_to_js_object(mermaid_config)
+
+    return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Maven Dependency Diagram - {theme.name.title()} Theme</title>
+    <style>
+        #mySvgId {{
+            height: 100%;
+            width: 100%;
+        }}
+        
+        /* Theme-specific styles */
+        {theme.custom_css}
+        
+        /* Dark theme text visibility fixes */
+        {
+        ""
+        if theme.name != "dark"
+        else '''
+        /* Force white text for all mermaid elements in dark theme */
+        .node text, .edgeLabel text, text, .label text {
+            fill: #ffffff !important;
+            color: #ffffff !important;
+        }
+        
+        /* Ensure node backgrounds are visible */
+        .node rect, .node circle, .node ellipse, .node polygon {
+            fill: #4a5568 !important;
+            stroke: #e2e8f0 !important;
+            stroke-width: 1px !important;
+        }
+        
+        /* Edge styling for dark theme */
+        .edge path, .flowchart-link {
+            stroke: #a0aec0 !important;
+            stroke-width: 2px !important;
+        }
+        
+        /* Arrow styling */
+        .arrowheadPath {
+            fill: #a0aec0 !important;
+            stroke: #a0aec0 !important;
+        }
+        '''
+    }
+        
+        /* Improved node styling */
+        .node {{
+            cursor: pointer;
+            transition: opacity 0.2s ease;
+        }}
+        
+        .node:hover {{
+            opacity: 0.8;
+        }}
+        
+        /* Highlighting styles */
+        .highlighted {{
+            opacity: 1 !important;
+            filter: drop-shadow(0 0 8px {STANDARD_COLORS["root_node"]});
+        }}
+        
+        .dimmed {{
+            opacity: 0.3;
+        }}
+    </style>
+</head>
+<body>
+    <div class="controls">
+        <div class="control-group">
+            <button id="downloadButton" class="toggle-btn">Download SVG</button>
+            <!-- Note: PNG download feature to be implemented in future version -->
+        </div>
+    </div>
+    
+    <div id="graphDiv"></div>
+    
+    <script src="https://cdn.jsdelivr.net/npm/svg-pan-zoom@3.5.0/dist/svg-pan-zoom.min.js"></script>
+    <script type="module">
+        import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@11.9.0/dist/mermaid.esm.min.mjs';
+        
+        // Initialize mermaid with theme configuration
+        mermaid.initialize({mermaid_config_js});
+
+        // Global variables
+        let panZoomInstance = null;
+        
+        const drawDiagram = async function () {{
+            const element = document.querySelector('#graphDiv');
+            const graphDefinition = `{{{{diagram_definition}}}}`;
+            
+            try {{
+                const {{ svg }} = await mermaid.render('mySvgId', graphDefinition);
+                element.innerHTML = svg.replace(/[ ]*max-width:[ 0-9\\.]*px;/i , '');
+                
+                // Initialize pan & zoom
+                panZoomInstance = svgPanZoom('#mySvgId', {{
+                    zoomEnabled: true,
+                    controlIconsEnabled: true,
+                    fit: true,
+                    center: true,
+                    minZoom: 0.1,
+                    maxZoom: 10
+                }});
+                
+                // Setup node interactions
+                setupNodeInteractions();
+                
+            }} catch (error) {{
+                console.error('Error rendering diagram:', error);
+                element.innerHTML = `<p style="color: red; padding: 20px;">Error rendering diagram: ${{error.message}}</p>`;
+            }}
+        }};
+        
+        const setupNodeInteractions = function() {{
+            const nodes = document.querySelectorAll('#mySvgId .node');
+            
+            nodes.forEach(node => {{
+                node.style.cursor = 'pointer';
+            }});
+        }};
+        
+        // Download functionality
+        document.getElementById('downloadButton').addEventListener('click', function() {{
+            downloadSVG();
+        }});
+        
+        const downloadSVG = function() {{
+            const svg = document.querySelector('#mySvgId');
+            let svgData = new XMLSerializer().serializeToString(svg);
+            
+            // Clean up pan & zoom controls
+            svgData = svgData.replace(/<g\\b[^>]*\\bclass="svg-pan-zoom-.*?".*?>.*?<\\/g>/g, '');
+            svgData = svgData.replace(/<\\/g><\\/svg>/, '</svg>');
+            
+            const svgBlob = new Blob([svgData], {{type: 'image/svg+xml;charset=utf-8'}});
+            const svgUrl = URL.createObjectURL(svgBlob);
+            const downloadLink = document.createElement('a');
+            downloadLink.href = svgUrl;
+            downloadLink.download = 'dependency-diagram.svg';
+            document.body.appendChild(downloadLink);
+            downloadLink.click();
+            document.body.removeChild(downloadLink);
+            URL.revokeObjectURL(svgUrl);
+        }};
+        
+        // Initialize the diagram
+        await drawDiagram();
+        
+        // Keyboard shortcuts
+        document.addEventListener('keydown', (e) => {{
+            if (e.ctrlKey || e.metaKey) {{
+                switch(e.key) {{
+                    case 's':
+                        e.preventDefault();
+                        downloadSVG();
+                        break;
+                    case 'r':
+                        e.preventDefault();
+                        if (panZoomInstance) {{
+                            panZoomInstance.reset();
+                        }}
+                        break;
+                }}
+            }}
+        }});
+        
+    </script>
+</body>
+</html>"""
+
+
+def _dict_to_js_object(d: Dict[str, Any], indent: int = 0) -> str:
+    """Convert Python dict to JavaScript object string."""
+    if not isinstance(d, dict):
+        if isinstance(d, str):
+            return f'"{d}"'
+        elif isinstance(d, bool):
+            return str(d).lower()
+        else:
+            return str(d)
+
+    items = []
+    for key, value in d.items():
+        if isinstance(value, dict):
+            value_str = _dict_to_js_object(value, indent + 1)
+        elif isinstance(value, str):
+            value_str = f'"{value}"'
+        elif isinstance(value, bool):
+            value_str = str(value).lower()
+        else:
+            value_str = str(value)
+
+        items.append(f'"{key}": {value_str}')
+
+    return "{" + ", ".join(items) + "}"

mvn_tree_visualizer/exceptions.py

@@ -0,0 +1,25 @@
+"""Custom exceptions for mvn-tree-visualizer."""
+
+
+class MvnTreeVisualizerError(Exception):
+    """Base exception for mvn-tree-visualizer errors."""
+
+    pass
+
+
+class DependencyFileNotFoundError(MvnTreeVisualizerError):
+    """Raised when no dependency files are found."""
+
+    pass
+
+
+class DependencyParsingError(MvnTreeVisualizerError):
+    """Raised when there's an error parsing dependency files."""
+
+    pass
+
+
+class OutputGenerationError(MvnTreeVisualizerError):
+    """Raised when there's an error generating output files."""
+
+    pass

mvn_tree_visualizer/file_watcher.py

@@ -0,0 +1,71 @@
+"""File watcher functionality for monitoring Maven dependency files."""
+
+import time
+from typing import Callable
+
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
+
+
+class DependencyFileHandler(FileSystemEventHandler):
+    """Handler for file system events to trigger diagram regeneration."""
+
+    def __init__(
+        self,
+        filename: str,
+        callback: Callable[[], None],
+    ):
+        """Initialize the file handler.
+
+        Args:
+            filename: Name of the file to monitor for changes
+            callback: Function to call when file changes are detected
+        """
+        self.filename = filename
+        self.callback = callback
+
+    def on_modified(self, event):
+        """Handle file modification events."""
+        if not event.is_directory and event.src_path.endswith(self.filename):
+            print(f"Detected change in {event.src_path}")
+            self.callback()
+
+
+class FileWatcher:
+    """File system watcher for monitoring Maven dependency files."""
+
+    def __init__(self, directory: str, filename: str, callback: Callable[[], None]):
+        """Initialize the file watcher.
+
+        Args:
+            directory: Directory to watch for file changes
+            filename: Name of the file to monitor
+            callback: Function to call when file changes are detected
+        """
+        self.directory = directory
+        self.filename = filename
+        self.callback = callback
+        self.observer = Observer()
+        self.event_handler = DependencyFileHandler(filename, callback)
+
+    def start(self) -> None:
+        """Start watching for file changes."""
+        print(f"Watching for changes in '{self.filename}' files in '{self.directory}'...")
+        print("Press Ctrl+C to stop watching.")
+
+        self.observer.schedule(self.event_handler, self.directory, recursive=True)
+        self.observer.start()
+
+    def stop(self) -> None:
+        """Stop watching for file changes."""
+        print("\nStopping file watcher...")
+        self.observer.stop()
+        self.observer.join()
+
+    def wait(self) -> None:
+        """Wait for file changes (blocking)."""
+        try:
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            self.stop()

mvn_tree_visualizer/get_dependencies_in_one_file.py

@@ -4,10 +4,37 @@ from typing import Union
 
 
 def merge_files(output_file: Union[str, Path], root_dir: str = ".", target_filename: str = "maven_dependency_file") -> None:
-    with open(output_file, "w", encoding="utf-8") as outfile:
-        for dirpath, _, filenames in os.walk(root_dir):
-            for fname in filenames:
-                if fname == target_filename:
-                    file_path: str = os.path.join(dirpath, fname)
-                    with open(file_path, "r", encoding="utf-8") as infile:
-                        outfile.write(infile.read())
+    """Merge all dependency files from the directory tree into a single file."""
+    files_found = 0
+
+    try:
+        with open(output_file, "w", encoding="utf-8") as outfile:
+            for dirpath, _, filenames in os.walk(root_dir):
+                for fname in filenames:
+                    if fname == target_filename:
+                        file_path: str = os.path.join(dirpath, fname)
+                        try:
+                            with open(file_path, "r", encoding="utf-8") as infile:
+                                content = infile.read()
+                                if content.strip():  # Only write non-empty content
+                                    outfile.write(content)
+                                    if not content.endswith("\n"):
+                                        outfile.write("\n")
+                                    files_found += 1
+                        except UnicodeDecodeError as e:
+                            raise UnicodeDecodeError(
+                                e.encoding,
+                                e.object,
+                                e.start,
+                                e.end,
+                                f"Error reading '{file_path}': {e.reason}. Please ensure the file is in UTF-8 format.",
+                            )
+                        except PermissionError:
+                            raise PermissionError(f"Permission denied reading '{file_path}'")
+    except PermissionError:
+        raise PermissionError(f"Permission denied writing to '{output_file}'")
+    except OSError as e:
+        raise OSError(f"Error writing to '{output_file}': {e}")
+
+    if files_found == 0:
+        raise FileNotFoundError(f"No '{target_filename}' files found in '{root_dir}' or its subdirectories")