fastled 1.2.33__py3-none-any.whl → 1.4.50__py3-none-any.whl

fastled/install/project_detection.py

@@ -0,0 +1,167 @@
+"""Project detection logic for FastLED installation."""
+
+import json
+import shutil
+from pathlib import Path
+
+
+def validate_vscode_project(no_interactive: bool = False) -> bool:
+    """
+    Validate if current directory has a VSCode project.
+    If not found, search parent directories, offer alternatives.
+    Returns True if a VSCode project is found or created.
+
+    Args:
+        no_interactive: If True, fail instead of prompting for input
+    """
+    current_dir = Path.cwd()
+
+    # Check current directory
+    if (current_dir / ".vscode").exists():
+        return True
+
+    # Search parent directories
+    parent_path = find_vscode_project_upward()
+    if parent_path:
+        if no_interactive:
+            print("❌ No .vscode directory found in current directory.")
+            print(f"   Found .vscode in parent: {parent_path}")
+            print("   In non-interactive mode, cannot change directory.")
+            print(f"   Please cd to {parent_path} and run the command again.")
+            return False
+        answer = (
+            input(f"Found a .vscode project in {parent_path}/\nInstall there? [y/n] ")
+            .strip()
+            .lower()
+        )
+        if answer in ["y", "yes"]:
+            import os
+
+            os.chdir(parent_path)
+            return True
+
+    # Check if IDE is available
+    if not (shutil.which("code") or shutil.which("cursor")):
+        print(
+            "No supported IDE found (VSCode or Cursor). Please install VSCode or Cursor first."
+        )
+        return False
+
+    # Offer to create new project
+    if no_interactive:
+        print(
+            "❌ No .vscode directory found in current directory or parent directories."
+        )
+        print("   In non-interactive mode, cannot create new project.")
+        print("   Please create a .vscode directory or run without --no-interactive.")
+        return False
+
+    print("No .vscode directory found in current directory or parent directories.")
+    answer = (
+        input(
+            "Would you like to generate a VSCode project with FastLED configuration? [y/n] "
+        )
+        .strip()
+        .lower()
+    )
+    if answer in ["y", "yes"]:
+        return generate_vscode_project()
+
+    return False
+
+
+def find_vscode_project_upward(max_levels: int = 5) -> Path | None:
+    """Search parent directories for .vscode folder."""
+    current = Path.cwd()
+
+    for _ in range(max_levels):
+        parent = current.parent
+        if parent == current:  # Reached root
+            break
+        current = parent
+        if (current / ".vscode").exists():
+            return current
+
+    return None
+
+
+def generate_vscode_project() -> bool:
+    """Create a new .vscode directory structure."""
+    vscode_dir = Path.cwd() / ".vscode"
+    vscode_dir.mkdir(exist_ok=True)
+    print(f"✅ Created .vscode directory at {vscode_dir}")
+    return True
+
+
+def detect_fastled_project() -> bool:
+    """Check if library.json contains FastLED."""
+    library_json = Path.cwd() / "library.json"
+    if not library_json.exists():
+        return False
+
+    try:
+        with open(library_json, "r") as f:
+            data = json.load(f)
+            return data.get("name") == "FastLED"
+    except (json.JSONDecodeError, KeyError):
+        return False
+
+
+def is_fastled_repository() -> bool:
+    """
+    🚨 CRITICAL: Detect actual FastLED repository.
+    Strict verification of multiple markers.
+    """
+    cwd = Path.cwd()
+
+    # Required files and directories for FastLED repository
+    required_markers = [
+        cwd / "src" / "FastLED.h",
+        cwd / "examples" / "Blink" / "Blink.ino",
+        cwd / "ci" / "ci-compile.py",
+        cwd / "src" / "platforms",
+        cwd / "library.json",
+    ]
+
+    # Check all markers exist
+    if not all(marker.exists() for marker in required_markers):
+        return False
+
+    # Verify library.json has correct content
+    try:
+        with open(cwd / "library.json", "r") as f:
+            data = json.load(f)
+            if data.get("name") != "FastLED":
+                return False
+            repo_url = data.get("repository", {}).get("url", "")
+            if "FastLED/FastLED" not in repo_url:
+                return False
+    except (json.JSONDecodeError, KeyError, FileNotFoundError):
+        return False
+
+    # Check for test files pattern
+    test_dir = cwd / "tests"
+    if test_dir.exists() and test_dir.is_dir():
+        test_files = list(test_dir.glob("test_*.cpp"))
+        if not test_files:
+            return False
+    else:
+        return False
+
+    return True
+
+
+def check_existing_arduino_content() -> bool:
+    """Check for .ino files OR examples/ folder."""
+    cwd = Path.cwd()
+
+    # Check for any .ino files
+    ino_files = list(cwd.rglob("*.ino"))
+    if ino_files:
+        return True
+
+    # Check for examples folder
+    if (cwd / "examples").exists():
+        return True
+
+    return False

fastled/install/test_install.py

@@ -0,0 +1,373 @@
+"""Comprehensive test suite for FastLED install feature."""
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from fastled.install.main import auto_execute_fastled, fastled_install
+from fastled.install.project_detection import (
+    check_existing_arduino_content,
+)
+from fastled.install.vscode_config import (
+    generate_fastled_tasks,
+    update_launch_json_for_arduino,
+    update_vscode_settings_for_fastled,
+)
+
+
+class TestFastLEDInstall(unittest.TestCase):
+    """Test FastLED installation functionality."""
+
+    def setUp(self):
+        """Set up test environment."""
+        self.test_dir = tempfile.mkdtemp()
+        self.original_cwd = os.getcwd()
+        os.chdir(self.test_dir)
+
+    def tearDown(self):
+        """Clean up test environment."""
+        os.chdir(self.original_cwd)
+        shutil.rmtree(self.test_dir)
+
+    @patch("fastled.install.project_detection.shutil.which")
+    @patch("builtins.input")
+    def test_dry_run_basic_project(self, mock_input, mock_which):
+        """Test 1: Dry-run in basic project."""
+        # Setup
+        mock_which.return_value = "/usr/bin/code"
+        mock_input.return_value = "y"
+        os.makedirs(".vscode")
+
+        # Run
+        result = fastled_install(dry_run=True, no_interactive=True)
+
+        # Verify
+        self.assertTrue(result)
+        self.assertTrue(Path(".vscode/launch.json").exists())
+        self.assertTrue(Path(".vscode/tasks.json").exists())
+
+    @patch("fastled.install.project_detection.is_fastled_repository")
+    @patch("fastled.install.project_detection.detect_fastled_project")
+    @patch("fastled.install.project_detection.shutil.which")
+    @patch("builtins.input")
+    def test_dry_run_fastled_external(
+        self, mock_input, mock_which, mock_detect, mock_repo
+    ):
+        """Test 2: Dry-run in external FastLED project."""
+        # Setup
+        mock_which.return_value = "/usr/bin/code"
+        mock_input.return_value = "y"
+        mock_detect.return_value = True
+        mock_repo.return_value = False
+        os.makedirs(".vscode")
+
+        # Create library.json
+        with open("library.json", "w") as f:
+            json.dump({"name": "FastLED"}, f)
+
+        # Run
+        result = fastled_install(dry_run=True, no_interactive=True)
+
+        # Verify
+        self.assertTrue(result)
+        self.assertFalse(Path(".vscode/settings.json").exists())  # No clangd settings
+
+    @patch("fastled.install.project_detection.is_fastled_repository")
+    @patch("fastled.install.project_detection.detect_fastled_project")
+    @patch("fastled.install.project_detection.shutil.which")
+    @patch("builtins.input")
+    def test_dry_run_fastled_repository(
+        self, mock_input, mock_which, mock_detect, mock_repo
+    ):
+        """Test 3: Dry-run in actual FastLED repository."""
+        # Setup
+        mock_which.return_value = "/usr/bin/code"
+        mock_input.return_value = "y"
+        mock_detect.return_value = True
+        mock_repo.return_value = True
+        os.makedirs(".vscode")
+
+        # Run
+        result = fastled_install(dry_run=True, no_interactive=True)
+
+        # Verify
+        self.assertTrue(result)
+        self.assertTrue(Path(".vscode/settings.json").exists())  # Has clangd settings
+
+    @patch("fastled.install.project_detection.shutil.which")
+    @patch("builtins.input")
+    def test_existing_vscode_project(self, mock_input, mock_which):
+        """Test 4: Merge with existing .vscode configs."""
+        # Setup
+        mock_which.return_value = "/usr/bin/code"
+        mock_input.return_value = "y"
+        os.makedirs(".vscode")
+
+        # Create existing launch.json
+        existing_config = {
+            "version": "0.2.0",
+            "configurations": [{"name": "Existing", "type": "node"}],
+        }
+        with open(".vscode/launch.json", "w") as f:
+            json.dump(existing_config, f)
+
+        # Run
+        result = fastled_install(dry_run=True, no_interactive=True)
+
+        # Verify
+        self.assertTrue(result)
+        with open(".vscode/launch.json") as f:
+            data = json.load(f)
+            self.assertEqual(len(data["configurations"]), 2)
+            self.assertEqual(
+                data["configurations"][0]["name"],
+                "🎯 Auto Debug (Smart File Detection)",
+            )
+
+    @patch("fastled.install.project_detection.shutil.which")
+    @patch("builtins.input")
+    def test_parent_directory_detection(self, mock_input, mock_which):
+        """Test 5: Find .vscode in parent directories."""
+        # Setup
+        mock_which.return_value = "/usr/bin/code"
+        parent_dir = Path(self.test_dir)
+        child_dir = parent_dir / "child" / "grandchild"
+        child_dir.mkdir(parents=True)
+        (parent_dir / ".vscode").mkdir()
+        os.chdir(child_dir)
+
+        # Test non-interactive mode - should fail
+        result = fastled_install(dry_run=True, no_interactive=True)
+        self.assertFalse(result)  # Should fail in non-interactive
+
+        # Test interactive mode
+        mock_input.side_effect = ["y", "y"]  # Yes to parent, yes to extension
+        result = fastled_install(dry_run=True, no_interactive=False)
+
+        # Verify - we should be in parent directory now
+        self.assertTrue(result)
+        self.assertEqual(Path.cwd(), parent_dir)
+
+    @patch("fastled.install.project_detection.shutil.which")
+    @patch("builtins.input")
+    def test_project_generation(self, mock_input, mock_which):
+        """Test 6: Generate new VSCode project."""
+        # Setup
+        mock_which.return_value = "/usr/bin/code"
+
+        # Test non-interactive mode - should fail
+        result = fastled_install(dry_run=True, no_interactive=True)
+        self.assertFalse(result)  # Should fail without .vscode
+
+        # Test interactive mode
+        mock_input.side_effect = ["y", "y"]  # Yes to generate, yes to extension
+        result = fastled_install(dry_run=True, no_interactive=False)
+
+        # Verify
+        self.assertTrue(result)
+        self.assertTrue(Path(".vscode").exists())
+        self.assertTrue(Path(".vscode/launch.json").exists())
+        self.assertTrue(Path(".vscode/tasks.json").exists())
+
+    def test_arduino_content_detection(self):
+        """Test 7: Detect existing .ino files."""
+        # Create .ino file
+        with open("test.ino", "w") as f:
+            f.write("void setup() {}")
+
+        # Test detection
+        self.assertTrue(check_existing_arduino_content())
+
+        # Remove and test examples folder
+        os.unlink("test.ino")
+        os.makedirs("examples")
+        self.assertTrue(check_existing_arduino_content())
+
+    @patch("fastled.install.project_detection.shutil.which")
+    @patch("builtins.input")
+    def test_tasks_json_merging(self, mock_input, mock_which):
+        """Test 8: Merge FastLED tasks with existing."""
+        # Setup
+        mock_which.return_value = "/usr/bin/code"
+        mock_input.return_value = "y"
+        os.makedirs(".vscode")
+
+        # Create existing tasks.json
+        existing_tasks = {
+            "version": "2.0.0",
+            "tasks": [{"label": "Existing Task", "command": "echo"}],
+        }
+        with open(".vscode/tasks.json", "w") as f:
+            json.dump(existing_tasks, f)
+
+        # Run
+        generate_fastled_tasks()
+
+        # Verify
+        with open(".vscode/tasks.json") as f:
+            data = json.load(f)
+            self.assertEqual(len(data["tasks"]), 3)  # 1 existing + 2 FastLED
+            labels = [task["label"] for task in data["tasks"]]
+            self.assertIn("Run FastLED (Debug)", labels)
+            self.assertIn("Run FastLED (Quick)", labels)
+
+    def test_launch_json_updates(self):
+        """Test 9: Update launch.json configurations."""
+        # Setup
+        os.makedirs(".vscode")
+
+        # Run
+        update_launch_json_for_arduino()
+
+        # Verify
+        with open(".vscode/launch.json") as f:
+            data = json.load(f)
+            self.assertEqual(len(data["configurations"]), 1)
+            config = data["configurations"][0]
+            self.assertEqual(config["name"], "🎯 Auto Debug (Smart File Detection)")
+            self.assertEqual(config["type"], "auto-debug")
+            self.assertIn("*.ino", config["map"])
+
+    @patch("fastled.install.project_detection.is_fastled_repository")
+    def test_safety_clangd_protection(self, mock_repo):
+        """Test 10: 🚨 CRITICAL - clangd safety protection."""
+        # Setup
+        os.makedirs(".vscode")
+
+        # Test non-repository
+        mock_repo.return_value = False
+        update_vscode_settings_for_fastled()
+        self.assertFalse(Path(".vscode/settings.json").exists())
+
+        # Test repository
+        mock_repo.return_value = True
+        update_vscode_settings_for_fastled()
+        self.assertTrue(Path(".vscode/settings.json").exists())
+
+        with open(".vscode/settings.json") as f:
+            data = json.load(f)
+            self.assertIn("clangd.arguments", data)
+
+    @patch("fastled.install.main.check_existing_arduino_content")
+    def test_auto_execution_trigger(self, mock_check):
+        """Test 11: Post-installation auto-execution."""
+        # Setup
+        mock_check.return_value = True
+        original_argv = sys.argv.copy()
+        sys.argv = ["fastled", "--install"]
+
+        try:
+            # We'll test that auto_execute_fastled modifies sys.argv correctly
+            # without actually calling main()
+            with patch("fastled.app.main") as mock_main:
+                mock_main.return_value = 0
+                auto_execute_fastled()
+
+                # Verify
+                mock_main.assert_called_once()
+                # Check that argv was filtered before calling main
+                # The function should have set sys.argv to ['fastled', '.']
+        finally:
+            sys.argv = original_argv
+
+    @patch("fastled.install.project_detection.shutil.which")
+    def test_no_ide_error_handling(self, mock_which):
+        """Test 12: Error when no IDE available."""
+        # Setup
+        mock_which.return_value = None
+
+        # Run
+        from fastled.install.project_detection import validate_vscode_project
+
+        result = validate_vscode_project(no_interactive=True)
+
+        # Verify
+        self.assertFalse(result)
+
+    @patch("subprocess.run")
+    @patch("builtins.input")
+    def test_examples_installation(self, mock_input, mock_run):
+        """Test 13: --project-init examples installation."""
+        # Setup
+        mock_input.return_value = "y"
+        mock_run.return_value = MagicMock(returncode=0)
+
+        # Run
+        from fastled.install.examples_manager import (
+            install_fastled_examples_via_project_init,
+        )
+
+        # Test non-interactive mode - should skip
+        result = install_fastled_examples_via_project_init(no_interactive=True)
+        self.assertFalse(result)
+
+        # Test interactive mode
+        result = install_fastled_examples_via_project_init(no_interactive=False)
+        self.assertTrue(result)
+        mock_run.assert_called_once()
+        call_args = mock_run.call_args[0][0]
+        self.assertEqual(call_args, ["fastled", "--project-init"])
+
+    @patch("fastled.install.extension_manager.download_auto_debug_extension")
+    @patch("fastled.install.extension_manager.install_vscode_extensions")
+    def test_extension_installation_flow(self, mock_install, mock_download):
+        """Test 14: Auto Debug extension prompt/install."""
+        # Setup
+        mock_download.return_value = Path("test.vsix")
+        mock_install.return_value = True
+
+        # Test dry run
+        from fastled.install.extension_manager import install_auto_debug_extension
+
+        result = install_auto_debug_extension(dry_run=True)
+        self.assertTrue(result)
+        mock_download.assert_not_called()
+
+        # Test real install
+        result = install_auto_debug_extension(dry_run=False)
+        self.assertTrue(result)
+        mock_download.assert_called_once()
+        mock_install.assert_called_once()
+
+    @patch("fastled.install.project_detection.is_fastled_repository")
+    @patch("fastled.install.project_detection.shutil.which")
+    @patch("builtins.input")
+    def test_comprehensive_integration(self, mock_input, mock_which, mock_repo):
+        """Test 15: End-to-end integration test."""
+        # Setup
+        mock_which.return_value = "/usr/bin/code"
+        mock_input.side_effect = ["y", "y", "y"]  # Yes to project, extension, examples
+        mock_repo.return_value = False
+
+        # Create .vscode first for non-interactive test
+        os.makedirs(".vscode")
+
+        # Run full installation in non-interactive mode
+        result = fastled_install(dry_run=True, no_interactive=True)
+
+        # Verify all components
+        self.assertTrue(result)
+        self.assertTrue(Path(".vscode").exists())
+        self.assertTrue(Path(".vscode/launch.json").exists())
+        self.assertTrue(Path(".vscode/tasks.json").exists())
+
+        # Verify tasks have correct content
+        with open(".vscode/tasks.json") as f:
+            data = json.load(f)
+            debug_task = next(
+                t for t in data["tasks"] if t["label"] == "Run FastLED (Debug)"
+            )
+            self.assertIn("--debug", debug_task["args"])
+            self.assertIn("--app", debug_task["args"])
+
+
+if __name__ == "__main__":
+    unittest.main()