feat: dev

Author: wislertt

.amazonq/plan/compare_template_files.py renamed to .amazonq/plans/compare_template_files.py

@@ -18,7 +18,8 @@ def generate(
     """Generate LeetCode problem from JSON using cookiecutter."""
     generator = TemplateGenerator()
     template_dir = Path(__file__).parent
-    generator.generate_problem(json_file, force, template_dir)
+    output_dir = template_dir.parent.parent / "leetcode"
+    generator.generate_problem(json_file, template_dir, output_dir, force)
 
 
 if __name__ == "__main__":

.amazonq/plan/cookiecutter-template-plan.md renamed to .amazonq/plans/cookiecutter-template-plan.md

@@ -48,7 +48,7 @@ leetcode/two_sum/
 └── __init__.py       # Package marker
 ```
 
-## 🎯 Supported Problem Categories
+## 🎯 Supported Problem Categories (ongoing)
 
 - **Arrays & Hashing** - Two Sum, Group Anagrams, Top K Elements
 - **Two Pointers** - Valid Palindrome, Container With Most Water
@@ -66,7 +66,7 @@ leetcode/two_sum/
 - **Intervals** - Merge Intervals, Meeting Rooms
 - **Math & Geometry** - Rotate Image, Spiral Matrix
 
-Includes problems from **Blind 75**, **Grind 75**, **NeetCode 150**, and **Top Interview Questions**. This is an ongoing project - contributions are welcome!
+Includes problems from **Blind 75**, **Grind 75**, **NeetCode 150**, and **Top Interview Questions**.
 
 ## 🎨 Visualizations
 
@@ -101,9 +101,12 @@ _Interactive multi-cell playground for each problem_
 
 ```bash
 # Work on a specific problem
-make p-test PROBLEM=two_sum
-# Edit leetcode/two_sum/solution.py
+make p-test PROBLEM=lru_cache
+# Edit leetcode/lru_cache/solution.py
 # Run tests to verify
+
+# Or use make p-test if default problem is set in Makefile
+make p-test
 ```
 
 **Add new problems**:
@@ -127,7 +130,7 @@ make gen-all-problems
 make lint
 ```
 
-## 🧰 Helper Classes
+## 🧰 Helper Classes (ongoing)
 
 - **TreeNode**: `from leetcode_py import TreeNode`
     - Beautiful tree visualization with anytree rendering
@@ -139,6 +142,4 @@ make lint
     - Perfect for debugging linked list problems
 - New helpers: Add to `leetcode_py/`
 
-This is an ongoing project - contributions are welcome!
-
 Perfect for interview preparation with professional-grade tooling and beautiful visualizations.

.templates/leetcode/gen.py

@@ -3,17 +3,60 @@
 import json
 import sys
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Dict, Protocol
 
 import typer
 from cookiecutter.main import cookiecutter
 
 
+class FileOperations(Protocol):
+    """Protocol for file operations to enable testing."""
+
+    def read_json(self, path: Path) -> Dict[str, Any]:
+        """Read JSON from file."""
+        ...
+
+    def write_json(self, path: Path, data: Dict[str, Any]) -> None:
+        """Write JSON to file."""
+        ...
+
+    def exists(self, path: Path) -> bool:
+        """Check if path exists."""
+        ...
+
+
+class DefaultFileOperations:
+    """Default file operations implementation."""
+
+    def read_json(self, path: Path) -> Dict[str, Any]:
+        """Read JSON from file."""
+        try:
+            with open(path) as f:
+                return json.load(f)
+        except (json.JSONDecodeError, OSError) as e:
+            typer.echo(f"Error reading {path}: {e}", err=True)
+            raise typer.Exit(1)
+
+    def write_json(self, path: Path, data: Dict[str, Any]) -> None:
+        """Write JSON to file."""
+        try:
+            with open(path, "w") as f:
+                json.dump(data, f)
+        except OSError as e:
+            typer.echo(f"Error writing {path}: {e}", err=True)
+            raise typer.Exit(1)
+
+    def exists(self, path: Path) -> bool:
+        """Check if path exists."""
+        return path.exists()
+
+
 class TemplateGenerator:
     """Generator for LeetCode problem templates using cookiecutter."""
 
-    def __init__(self):
+    def __init__(self, file_ops: FileOperations | None = None):
         self.common_tags = ["grind-75", "blind-75", "neetcode-150", "top-interview"]
+        self.file_ops = file_ops or DefaultFileOperations()
 
     def check_and_prompt_tags(self, data: Dict[str, Any]) -> Dict[str, Any]:
         """Check and prompt for tags if empty."""
@@ -85,18 +128,19 @@ def convert_arrays_to_nested(self, data: Dict[str, Any]) -> Dict[str, Any]:
                 del extra_context[field]
         return extra_context
 
-    def check_overwrite_permission(self, problem_name: str, force: bool, template_dir: Path) -> None:
+    def check_overwrite_permission(self, problem_name: str, force: bool, output_dir: Path) -> None:
         """Check if problem exists and get overwrite permission."""
         if force:
             return
 
-        output_dir = template_dir.parent.parent / "leetcode"
         problem_dir = output_dir / problem_name
 
-        if not problem_dir.exists():
+        if not self.file_ops.exists(problem_dir):
             return
 
-        typer.echo(f"⚠️  Warning: Problem '{problem_name}' already exists in leetcode/", err=True)
+        typer.echo(
+            f"⚠️  Warning: Problem '{problem_name}' already exists in {output_dir.name}/", err=True
+        )
         typer.echo("This will overwrite existing files. Use --force to skip this check.", err=True)
 
         if sys.stdin.isatty():  # Interactive terminal
@@ -109,47 +153,43 @@ def check_overwrite_permission(self, problem_name: str, force: bool, template_di
             raise typer.Exit(1)
 
     def generate_problem(
-        self, json_file: str, force: bool = False, template_dir: Path | None = None
+        self, json_file: str, template_dir: Path, output_dir: Path, force: bool = False
     ) -> None:
         """Generate problem from JSON using cookiecutter."""
         json_path = Path(json_file)
-        if not json_path.exists():
+        if not self.file_ops.exists(json_path):
             typer.echo(f"Error: {json_file} not found", err=True)
             raise typer.Exit(1)
 
         # Load JSON data
-        with open(json_path) as f:
-            data = json.load(f)
+        data = self.file_ops.read_json(json_path)
 
         # Process data
         data = self.check_and_prompt_tags(data)
         data = self.auto_set_dummy_return(data)
 
         # Save updated data back to JSON file
-        with open(json_path, "w") as f:
-            json.dump(data, f)
+        self.file_ops.write_json(json_path, data)
 
         # Convert arrays to cookiecutter-friendly nested format
         extra_context = self.convert_arrays_to_nested(data)
 
         # Check if problem already exists
         problem_name = extra_context.get("problem_name", "unknown")
 
-        # Use provided template_dir or default
-        if template_dir is None:
-            template_dir = Path(__file__).parent.parent.parent / ".templates" / "leetcode"
-
-        self.check_overwrite_permission(problem_name, force, template_dir)
+        self.check_overwrite_permission(problem_name, force, output_dir)
 
         # Generate project using cookiecutter
-        output_dir = template_dir.parent.parent / "leetcode"
-
-        cookiecutter(
-            str(template_dir),
-            extra_context=extra_context,
-            no_input=True,
-            overwrite_if_exists=True,
-            output_dir=str(output_dir),
-        )
+        try:
+            cookiecutter(
+                str(template_dir),
+                extra_context=extra_context,
+                no_input=True,
+                overwrite_if_exists=True,
+                output_dir=str(output_dir),
+            )
+        except Exception as e:
+            typer.echo(f"Error generating template: {e}", err=True)
+            raise typer.Exit(1)
 
         typer.echo(f"✅ Generated problem: {problem_name}")

README.md

@@ -106,15 +106,15 @@ def test_convert_arrays_to_nested_non_list_values(self):
 
     def test_check_overwrite_permission_force(self):
         """Test overwrite permission with force flag."""
-        template_dir = Path("/fake/template")
+        output_dir = Path("/fake/output")
         # Should not raise exception with force=True
-        self.generator.check_overwrite_permission("test_problem", True, template_dir)
+        self.generator.check_overwrite_permission("test_problem", True, output_dir)
 
     def test_check_overwrite_permission_nonexistent_problem(self):
         """Test overwrite permission when problem doesn't exist."""
-        template_dir = Path("/nonexistent/template")
+        output_dir = Path("/nonexistent/output")
         # Should not raise exception when problem doesn't exist
-        self.generator.check_overwrite_permission("nonexistent_problem", False, template_dir)
+        self.generator.check_overwrite_permission("nonexistent_problem", False, output_dir)
 
     def test_check_and_prompt_tags_with_existing_tags(self):
         """Test check_and_prompt_tags when tags already exist."""
@@ -157,3 +157,82 @@ def test_generate_problem_components(self):
         nested_data = self.generator.convert_arrays_to_nested(processed_data)
         assert "_tags" in nested_data
         assert nested_data["_tags"] == {"list": []}
+
+    def test_file_operations_injection(self):
+        """Test that file operations can be injected for testing."""
+        from unittest.mock import Mock
+
+        from leetcode_py.tools.generator import FileOperations
+
+        mock_file_ops = Mock(spec=FileOperations)
+        generator = TemplateGenerator(file_ops=mock_file_ops)
+        assert generator.file_ops is mock_file_ops
+
+    def test_check_and_prompt_tags_interactive_valid_choices(self):
+        """Test interactive tag selection with valid choices."""
+        from unittest.mock import patch
+
+        data: dict[str, Any] = {"tags": []}
+
+        with (
+            patch("sys.stdin.isatty", return_value=True),
+            patch("typer.prompt", return_value="1,2"),
+            patch("typer.echo"),
+        ):
+            result = self.generator.check_and_prompt_tags(data)
+            assert "grind-75" in result["tags"]
+            assert "blind-75" in result["tags"]
+
+    def test_check_and_prompt_tags_interactive_skip(self):
+        """Test interactive tag selection with skip option."""
+        from unittest.mock import patch
+
+        data: dict[str, Any] = {"tags": []}
+
+        with (
+            patch("sys.stdin.isatty", return_value=True),
+            patch("typer.prompt", return_value="0"),
+            patch("typer.echo"),
+        ):
+            result = self.generator.check_and_prompt_tags(data)
+            assert result["tags"] == []
+
+    def test_check_and_prompt_tags_interactive_invalid_input(self):
+        """Test interactive tag selection with invalid input."""
+        from unittest.mock import patch
+
+        data: dict[str, Any] = {"tags": []}
+
+        with (
+            patch("sys.stdin.isatty", return_value=True),
+            patch("typer.prompt", return_value="invalid"),
+            patch("typer.echo"),
+        ):
+            result = self.generator.check_and_prompt_tags(data)
+            assert result["tags"] == []
+
+    def test_generate_problem_success(self):
+        """Test successful problem generation."""
+        from unittest.mock import Mock, patch
+
+        from leetcode_py.tools.generator import FileOperations
+
+        mock_file_ops = Mock(spec=FileOperations)
+        mock_file_ops.exists.side_effect = lambda path: str(path).endswith("test.json")
+        mock_file_ops.read_json.return_value = {
+            "problem_name": "test_problem",
+            "return_type": "bool",
+            "tags": [],
+        }
+
+        generator = TemplateGenerator(file_ops=mock_file_ops)
+
+        template_dir = Path("/test/template")
+        output_dir = Path("/test/output")
+
+        with patch("leetcode_py.tools.generator.cookiecutter", return_value=None) as mock_cookiecutter:
+            generator.generate_problem("test.json", template_dir, output_dir, force=True)
+
+            mock_file_ops.read_json.assert_called_once()
+            mock_file_ops.write_json.assert_called_once()
+            mock_cookiecutter.assert_called_once()