sprout-cli 0.5.0__tar.gz → 0.7.0__tar.gz

{sprout_cli-0.5.0 → sprout_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sprout-cli
-Version: 0.5.0
+Version: 0.7.0
 Summary: CLI tool to automate git worktree and Docker Compose development workflows
 Author: SecDevLab Inc.
 License: MIT
@@ -68,6 +68,10 @@ API_PORT={{ auto_port() }}
 DB_HOST=localhost
 DB_PORT={{ auto_port() }}
 
+# Branch-specific Configuration
+SERVICE_NAME=myapp-{{ branch() }}
+DEPLOYMENT_ENV={{ branch() }}
+
 # Example: Docker Compose variables (preserved as-is)
 # sprout will NOT process ${...} syntax - it's passed through unchanged
 # DB_NAME=${DB_NAME}
@@ -180,7 +184,7 @@ Show the version of sprout.
 
 ## Template Syntax
 
-sprout supports two types of placeholders in `.env.example`:
+sprout supports three types of placeholders in `.env.example`:
 
 1. **Variable Placeholders**: `{{ VARIABLE_NAME }}`
    - **First**: Checks if the variable exists in your environment (e.g., `export API_KEY=xxx`)
@@ -193,7 +197,12 @@ sprout supports two types of placeholders in `.env.example`:
    - Checks system port availability
    - Ensures global uniqueness even in monorepo setups
 
-3. **Docker Compose Syntax (Preserved)**: `${VARIABLE}`
+3. **Branch Name**: `{{ branch() }}`
+   - Replaced with the current branch/subtree name
+   - Useful for branch-specific configurations
+   - Example: `SERVICE_NAME=myapp-{{ branch() }}` becomes `SERVICE_NAME=myapp-feature-auth`
+
+4. **Docker Compose Syntax (Preserved)**: `${VARIABLE}`
    - NOT processed by sprout - passed through as-is
    - Useful for Docker Compose variable substitution
    - Example: `${DB_NAME:-default}` remains unchanged in generated `.env`

{sprout_cli-0.5.0 → sprout_cli-0.7.0}/README.md

@@ -40,6 +40,10 @@ API_PORT={{ auto_port() }}
 DB_HOST=localhost
 DB_PORT={{ auto_port() }}
 
+# Branch-specific Configuration
+SERVICE_NAME=myapp-{{ branch() }}
+DEPLOYMENT_ENV={{ branch() }}
+
 # Example: Docker Compose variables (preserved as-is)
 # sprout will NOT process ${...} syntax - it's passed through unchanged
 # DB_NAME=${DB_NAME}
@@ -152,7 +156,7 @@ Show the version of sprout.
 
 ## Template Syntax
 
-sprout supports two types of placeholders in `.env.example`:
+sprout supports three types of placeholders in `.env.example`:
 
 1. **Variable Placeholders**: `{{ VARIABLE_NAME }}`
    - **First**: Checks if the variable exists in your environment (e.g., `export API_KEY=xxx`)
@@ -165,7 +169,12 @@ sprout supports two types of placeholders in `.env.example`:
    - Checks system port availability
    - Ensures global uniqueness even in monorepo setups
 
-3. **Docker Compose Syntax (Preserved)**: `${VARIABLE}`
+3. **Branch Name**: `{{ branch() }}`
+   - Replaced with the current branch/subtree name
+   - Useful for branch-specific configurations
+   - Example: `SERVICE_NAME=myapp-{{ branch() }}` becomes `SERVICE_NAME=myapp-feature-auth`
+
+4. **Docker Compose Syntax (Preserved)**: `${VARIABLE}`
    - NOT processed by sprout - passed through as-is
    - Useful for Docker Compose variable substitution
    - Example: `${DB_NAME:-default}` remains unchanged in generated `.env`

{sprout_cli-0.5.0 → sprout_cli-0.7.0}/src/sprout/__init__.py

@@ -1,3 +1,3 @@
 """sprout - CLI tool to automate git worktree and Docker Compose development workflows."""
 
-__version__ = "0.5.0"
+__version__ = "0.7.0"

{sprout_cli-0.5.0 → sprout_cli-0.7.0}/src/sprout/commands/create.py

@@ -109,7 +109,10 @@ def create_worktree(branch_name: BranchName, path_only: bool = False) -> Never:
 
                 # Parse template with combined used ports
                 env_content = parse_env_template(
-                    env_example, silent=path_only, used_ports=all_used_ports | session_ports
+                    env_example,
+                    silent=path_only,
+                    used_ports=all_used_ports | session_ports,
+                    branch_name=branch_name,
                 )
 
                 # Extract ports from generated content and add to session_ports

{sprout_cli-0.5.0 → sprout_cli-0.7.0}/src/sprout/utils.py

@@ -126,7 +126,10 @@ def find_available_port() -> PortNumber:
 
 
 def parse_env_template(
-    template_path: Path, silent: bool = False, used_ports: PortSet | None = None
+    template_path: Path,
+    silent: bool = False,
+    used_ports: PortSet | None = None,
+    branch_name: str | None = None,
 ) -> str:
     """Parse .env.example template and process placeholders.
 
@@ -134,6 +137,7 @@ def parse_env_template(
         template_path: Path to the .env.example template file
         silent: If True, use stderr for prompts to keep stdout clean
         used_ports: Set of ports already in use (in addition to system-wide used ports)
+        branch_name: Branch name to use for {{ branch() }} placeholders
     """
     if not template_path.exists():
         raise SproutError(f".env.example file not found at {template_path}")
@@ -151,22 +155,56 @@ def parse_env_template(
         file_ports.update(used_ports)
 
     for line in content.splitlines():
-        # Process {{ auto_port() }} placeholders
+        # Process {{ auto_port() | default }} placeholders
         def replace_auto_port(match: re.Match[str]) -> str:
+            # Extract default value if present (group 1)
+            default_value = match.group(1)
+            if default_value is not None:
+                default_value = default_value.strip()
+
+            # Generate available port
             port = find_available_port()
             while port in file_ports:
                 port = find_available_port()
             file_ports.add(port)
             return str(port)
 
-        line = re.sub(r"{{\s*auto_port\(\)\s*}}", replace_auto_port, line)
+        line = re.sub(r"{{\s*auto_port\(\)(?:\s*\|\s*([^}]*))?\s*}}", replace_auto_port, line)
+
+        # Process {{ branch() | default }} placeholders
+        def replace_branch(match: re.Match[str]) -> str:
+            # Extract default value if present (group 1)
+            default_value = match.group(1)
+            if default_value is not None:
+                default_value = default_value.strip()
+
+            # Use branch_name if provided, otherwise use default
+            if branch_name:
+                return branch_name
+            elif default_value is not None:
+                return default_value
+            else:
+                # No branch name and no default - keep placeholder unchanged
+                return match.group(0)
 
-        # Process {{ VARIABLE }} placeholders
+        line = re.sub(r"{{\s*branch\(\)(?:\s*\|\s*([^}]*))?\s*}}", replace_branch, line)
+
+        # Process {{ VARIABLE | default }} placeholders
         def replace_variable(match: re.Match[str]) -> str:
             var_name = match.group(1).strip()
+            # Extract default value if present (group 2)
+            default_value = match.group(2)
+            if default_value is not None:
+                default_value = default_value.strip()
+
             # Check environment variable first
             value = os.environ.get(var_name)
             if value is None:
+                # If default value is provided, use it
+                if default_value is not None:
+                    return default_value
+
+                # No default value - prompt user for value
                 # Create a relative path for display
                 try:
                     display_path = template_path.relative_to(Path.cwd())
@@ -187,7 +225,9 @@ def parse_env_template(
                     value = console.input(prompt)
             return value
 
-        line = re.sub(r"{{\s*([^}]+)\s*}}", replace_variable, line)
+        # Only match variables that don't look like function calls (no parentheses)
+        # Now also captures optional | default_value
+        line = re.sub(r"{{\s*([^}()]+?)(?:\s*\|\s*([^}]*))?\s*}}", replace_variable, line)
 
         lines.append(line)
 

{sprout_cli-0.5.0 → sprout_cli-0.7.0}/tests/test_integration.py

@@ -198,6 +198,102 @@ class TestIntegrationWorkflow:
         worktree_path = git_repo / ".sprout" / "existing-branch"
         assert worktree_path.exists()
 
+    def test_branch_placeholder(self, git_repo, monkeypatch):
+        """Test that {{ branch() }} placeholder is replaced with branch name."""
+        git_repo, default_branch = git_repo
+        monkeypatch.chdir(git_repo)
+        monkeypatch.setenv("API_KEY", "test_key")
+
+        # Create .env.example with branch() placeholder
+        env_example = git_repo / ".env.example"
+        env_example.write_text(
+            "# Branch-specific configuration\n"
+            "BRANCH_NAME={{ branch() }}\n"
+            "SERVICE_NAME=myapp-{{ branch() }}\n"
+            "API_KEY={{ API_KEY }}\n"
+            "PORT={{ auto_port() }}\n"
+            "COMPOSE_VAR=${BRANCH_NAME}\n"
+        )
+
+        # Add to git
+        subprocess.run(["git", "add", ".env.example"], cwd=git_repo, check=True)
+        subprocess.run(
+            ["git", "commit", "-m", "Add .env.example with branch placeholder"],
+            cwd=git_repo,
+            check=True,
+        )
+
+        # Create worktree
+        branch_name = "feature-auth"
+        result = runner.invoke(app, ["create", branch_name])
+        assert result.exit_code == 0
+
+        # Verify .env was created with correct branch name substitution
+        env_file = git_repo / ".sprout" / branch_name / ".env"
+        env_content = env_file.read_text()
+
+        # Check branch name substitutions
+        assert f"BRANCH_NAME={branch_name}" in env_content
+        assert f"SERVICE_NAME=myapp-{branch_name}" in env_content
+        assert "API_KEY=test_key" in env_content
+        assert "PORT=" in env_content  # Should have a port number
+        assert "COMPOSE_VAR=${BRANCH_NAME}" in env_content  # Docker syntax preserved
+
+    def test_default_values(self, git_repo, monkeypatch):
+        """Test that default values work correctly in .env.example templates."""
+        git_repo, default_branch = git_repo
+        monkeypatch.chdir(git_repo)
+
+        # Set only some environment variables
+        monkeypatch.setenv("SET_VAR", "from_environment")
+        # UNSET_VAR is not set - should use default
+
+        # Create .env.example with default values
+        env_example = git_repo / ".env.example"
+        env_example.write_text(
+            "# Test default values\n"
+            "SET_VAR={{ SET_VAR | default_value }}\n"
+            "UNSET_VAR={{ UNSET_VAR | localhost }}\n"
+            "EMPTY_VAR={{ EMPTY_VAR | }}\n"
+            "PORT={{ auto_port() | 8080 }}\n"
+            "BRANCH={{ branch() | develop }}\n"
+            "NO_DEFAULT={{ NO_DEFAULT }}\n"  # Will be prompted
+        )
+
+        # Add to git
+        subprocess.run(["git", "add", ".env.example"], cwd=git_repo, check=True)
+        subprocess.run(
+            ["git", "commit", "-m", "Add .env.example with defaults"],
+            cwd=git_repo,
+            check=True,
+        )
+
+        # Set NO_DEFAULT to avoid prompt
+        monkeypatch.setenv("NO_DEFAULT", "prompted_value")
+
+        # Create worktree
+        branch_name = "feature-test"
+        result = runner.invoke(app, ["create", branch_name])
+        assert result.exit_code == 0
+
+        # Verify .env was created with correct values
+        env_file = git_repo / ".sprout" / branch_name / ".env"
+        env_content = env_file.read_text()
+
+        # Check that environment variable overrides default
+        assert "SET_VAR=from_environment" in env_content
+        # Check that default is used when variable is not set
+        assert "UNSET_VAR=localhost" in env_content
+        # Check empty string default
+        assert "EMPTY_VAR=" in env_content or "EMPTY_VAR=\n" in env_content
+        # Check that auto_port generates a port (default not used)
+        assert "PORT=" in env_content
+        assert "PORT=8080" not in env_content  # Should be a generated port
+        # Check that branch name is used (not default)
+        assert f"BRANCH={branch_name}" in env_content
+        # Check prompted value
+        assert "NO_DEFAULT=prompted_value" in env_content
+
     def test_error_cases(self, git_repo, monkeypatch, tmp_path):
         """Test various error conditions."""
         git_repo, default_branch = git_repo

{sprout_cli-0.5.0 → sprout_cli-0.7.0}/tests/test_utils.py

@@ -179,6 +179,140 @@ class TestEnvTemplateParser:
         result = parse_env_template(template)
         assert result == "COMPOSE_VAR=${COMPOSE_VAR:-default}"
 
+    def test_parse_env_template_branch_placeholder(self, tmp_path):
+        """Test parsing {{ branch() }} placeholders."""
+        template = tmp_path / ".env.example"
+        template.write_text("BRANCH_NAME={{ branch() }}\nFEATURE={{ branch() }}_feature")
+
+        result = parse_env_template(template, branch_name="feature-auth")
+        assert result == "BRANCH_NAME=feature-auth\nFEATURE=feature-auth_feature"
+
+    def test_parse_env_template_branch_placeholder_none(self, tmp_path):
+        """Test {{ branch() }} placeholder when branch_name is None."""
+        template = tmp_path / ".env.example"
+        template.write_text("BRANCH={{ branch() }}")
+
+        # When branch_name is None, placeholder should remain unchanged
+        result = parse_env_template(template, branch_name=None)
+        assert result == "BRANCH={{ branch() }}"
+
+    def test_parse_env_template_mixed_placeholders(self, tmp_path, mocker):
+        """Test parsing mixed placeholders in one template."""
+        mocker.patch("sprout.utils.find_available_port", return_value=8080)
+        mocker.patch.dict(os.environ, {"API_KEY": "secret"})
+        mocker.patch("sprout.utils.console.input", return_value="password123")
+
+        template = tmp_path / ".env.example"
+        template.write_text(
+            "API_KEY={{ API_KEY }}\n"
+            "PORT={{ auto_port() }}\n"
+            "BRANCH={{ branch() }}\n"
+            "DB_PASS={{ DB_PASS }}\n"
+            "COMPOSE_VAR=${COMPOSE_VAR}"
+        )
+
+        result = parse_env_template(template, branch_name="feature-xyz")
+        assert result == (
+            "API_KEY=secret\n"
+            "PORT=8080\n"
+            "BRANCH=feature-xyz\n"
+            "DB_PASS=password123\n"
+            "COMPOSE_VAR=${COMPOSE_VAR}"
+        )
+
+    def test_parse_env_template_variable_with_default(self, tmp_path, mocker):
+        """Test parsing {{ VARIABLE | default }} when variable is not set."""
+        # Ensure the variable is not in environment
+        mocker.patch.dict(os.environ, {}, clear=False)
+        if "TEST_VAR" in os.environ:
+            del os.environ["TEST_VAR"]
+
+        template = tmp_path / ".env.example"
+        template.write_text("TEST_VAR={{ TEST_VAR | localhost }}")
+
+        result = parse_env_template(template)
+        assert result == "TEST_VAR=localhost"
+
+    def test_parse_env_template_variable_with_default_env_set(self, tmp_path, mocker):
+        """Test that environment variable overrides default value."""
+        mocker.patch.dict(os.environ, {"TEST_VAR": "custom_value"})
+
+        template = tmp_path / ".env.example"
+        template.write_text("TEST_VAR={{ TEST_VAR | localhost }}")
+
+        result = parse_env_template(template)
+        assert result == "TEST_VAR=custom_value"
+
+    def test_parse_env_template_variable_with_empty_default(self, tmp_path, mocker):
+        """Test parsing {{ VARIABLE | }} with empty string as default."""
+        mocker.patch.dict(os.environ, {}, clear=False)
+        if "EMPTY_VAR" in os.environ:
+            del os.environ["EMPTY_VAR"]
+
+        template = tmp_path / ".env.example"
+        template.write_text("EMPTY_VAR={{ EMPTY_VAR | }}")
+
+        result = parse_env_template(template)
+        assert result == "EMPTY_VAR="
+
+    def test_parse_env_template_variable_whitespace_trimming(self, tmp_path, mocker):
+        """Test that whitespace is trimmed from default values."""
+        mocker.patch.dict(os.environ, {}, clear=False)
+        if "TEST_VAR" in os.environ:
+            del os.environ["TEST_VAR"]
+
+        template = tmp_path / ".env.example"
+        template.write_text("TEST_VAR={{ TEST_VAR |   localhost   }}")
+
+        result = parse_env_template(template)
+        assert result == "TEST_VAR=localhost"
+
+    def test_parse_env_template_branch_with_default(self, tmp_path):
+        """Test parsing {{ branch() | default }} when branch_name is None."""
+        template = tmp_path / ".env.example"
+        template.write_text("BRANCH={{ branch() | main }}")
+
+        result = parse_env_template(template, branch_name=None)
+        assert result == "BRANCH=main"
+
+    def test_parse_env_template_branch_with_default_branch_set(self, tmp_path):
+        """Test that branch_name overrides default value."""
+        template = tmp_path / ".env.example"
+        template.write_text("BRANCH={{ branch() | main }}")
+
+        result = parse_env_template(template, branch_name="feature-xyz")
+        assert result == "BRANCH=feature-xyz"
+
+    def test_parse_env_template_auto_port_with_default(self, tmp_path, mocker):
+        """Test {{ auto_port() | default }} - default is captured but not used."""
+        mocker.patch("sprout.utils.find_available_port", return_value=9000)
+
+        template = tmp_path / ".env.example"
+        template.write_text("PORT={{ auto_port() | 8080 }}")
+
+        # auto_port() always generates a port, so default is not used
+        result = parse_env_template(template)
+        assert result == "PORT=9000"
+
+    def test_parse_env_template_mixed_with_defaults(self, tmp_path, mocker):
+        """Test parsing mixed placeholders with default values."""
+        mocker.patch("sprout.utils.find_available_port", return_value=8080)
+        mocker.patch.dict(os.environ, {"SET_VAR": "from_env"}, clear=False)
+        if "UNSET_VAR" in os.environ:
+            del os.environ["UNSET_VAR"]
+
+        template = tmp_path / ".env.example"
+        template.write_text(
+            "SET_VAR={{ SET_VAR | default1 }}\n"
+            "UNSET_VAR={{ UNSET_VAR | default2 }}\n"
+            "PORT={{ auto_port() | 3000 }}\n"
+            "BRANCH={{ branch() | develop }}\n"
+            "EMPTY={{ EMPTY | }}"
+        )
+
+        result = parse_env_template(template, branch_name=None)
+        assert result == ("SET_VAR=from_env\nUNSET_VAR=default2\nPORT=8080\nBRANCH=develop\nEMPTY=")
+
     def test_parse_env_template_file_not_found(self, tmp_path):
         """Test error when template file doesn't exist."""
         template = tmp_path / "nonexistent.env"