tasktree 0.0.11__tar.gz → 0.0.12__tar.gz

{tasktree-0.0.11 → tasktree-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktree
-Version: 0.0.11
+Version: 0.0.12
 Summary: A task automation tool with incremental execution
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.0
@@ -718,10 +718,13 @@ For more complex scenarios, define environment variables in the `variables` sect
 
 ```yaml
 variables:
-  # Direct env reference (resolved at parse time)
+  # Required env var (error if not set)
   api_key: { env: API_KEY }
-  db_host: { env: DATABASE_HOST }
-
+  
+  # Optional env var with default
+  port: { env: PORT, default: "8080" }
+  log_level: { env: LOG_LEVEL, default: "info" }
+  
   # Or using string substitution
   deploy_user: "{{ env.DEPLOY_USER }}"
 

{tasktree-0.0.11 → tasktree-0.0.12}/README.md

@@ -703,10 +703,13 @@ For more complex scenarios, define environment variables in the `variables` sect
 
 ```yaml
 variables:
-  # Direct env reference (resolved at parse time)
+  # Required env var (error if not set)
   api_key: { env: API_KEY }
-  db_host: { env: DATABASE_HOST }
-
+  
+  # Optional env var with default
+  port: { env: PORT, default: "8080" }
+  log_level: { env: LOG_LEVEL, default: "info" }
+  
   # Or using string substitution
   deploy_user: "{{ env.DEPLOY_USER }}"
 

{tasktree-0.0.11 → tasktree-0.0.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tasktree"
-version = "0.0.11"
+version = "0.0.12"
 description = "A task automation tool with incremental execution"
 readme = "README.md"
 requires-python = ">=3.11"

{tasktree-0.0.11 → tasktree-0.0.12}/src/tasktree/parser.py

@@ -287,26 +287,35 @@ def _is_env_variable_reference(value: Any) -> bool:
     return isinstance(value, dict) and "env" in value
 
 
-def _validate_env_variable_reference(var_name: str, value: dict) -> str:
-    """Validate and extract environment variable name from reference.
+def _validate_env_variable_reference(var_name: str, value: dict) -> tuple[str, str | None]:
+    """Validate and extract environment variable name and optional default from reference.
 
     Args:
         var_name: Name of the variable being defined
-        value: Dict that should be { env: ENV_VAR_NAME }
+        value: Dict that should be { env: ENV_VAR_NAME } or { env: ENV_VAR_NAME, default: "value" }
 
     Returns:
-        Environment variable name
+        Tuple of (environment variable name, default value or None)
 
     Raises:
         ValueError: If reference is invalid
     """
-    # Validate dict structure
-    if len(value) != 1:
-        extra_keys = [k for k in value.keys() if k != "env"]
+    # Validate dict structure - allow 'env' and optionally 'default'
+    valid_keys = {"env", "default"}
+    invalid_keys = set(value.keys()) - valid_keys
+    if invalid_keys:
         raise ValueError(
             f"Invalid environment variable reference in variable '{var_name}'.\n"
-            f"Expected: {{ env: VARIABLE_NAME }}\n"
-            f"Found extra keys: {', '.join(extra_keys)}"
+            f"Expected: {{ env: VARIABLE_NAME }} or {{ env: VARIABLE_NAME, default: \"value\" }}\n"
+            f"Found invalid keys: {', '.join(invalid_keys)}"
+        )
+
+    # Validate 'env' key is present
+    if "env" not in value:
+        raise ValueError(
+            f"Invalid environment variable reference in variable '{var_name}'.\n"
+            f"Missing required 'env' key.\n"
+            f"Expected: {{ env: VARIABLE_NAME }} or {{ env: VARIABLE_NAME, default: \"value\" }}"
         )
 
     env_var_name = value["env"]
@@ -315,7 +324,7 @@ def _validate_env_variable_reference(var_name: str, value: dict) -> str:
     if not env_var_name or not isinstance(env_var_name, str):
         raise ValueError(
             f"Invalid environment variable reference in variable '{var_name}'.\n"
-            f"Expected: {{ env: VARIABLE_NAME }}\n"
+            f"Expected: {{ env: VARIABLE_NAME }} or {{ env: VARIABLE_NAME, default: \"value\" }}"
             f"Found: {{ env: {env_var_name!r} }}"
         )
 
@@ -327,23 +336,36 @@ def _validate_env_variable_reference(var_name: str, value: dict) -> str:
             f"and contain only alphanumerics and underscores."
         )
 
-    return env_var_name
+    # Extract and validate default if present
+    default = value.get("default")
+    if default is not None:
+        # Default must be a string (env vars are always strings)
+        if not isinstance(default, str):
+            raise ValueError(
+                f"Invalid default value in variable '{var_name}'.\n"
+                f"Environment variable defaults must be strings.\n"
+                f"Got: {default!r} (type: {type(default).__name__})\n"
+                f"Use a quoted string: {{ env: {env_var_name}, default: \"{default}\" }}"
+            )
+
+    return env_var_name, default
 
 
-def _resolve_env_variable(var_name: str, env_var_name: str) -> str:
+def _resolve_env_variable(var_name: str, env_var_name: str, default: str | None = None) -> str:
     """Resolve environment variable value.
 
     Args:
         var_name: Name of the variable being defined
         env_var_name: Name of environment variable to read
+        default: Optional default value to use if environment variable is not set
 
     Returns:
-        Environment variable value as string
+        Environment variable value as string, or default if not set and default provided
 
     Raises:
-        ValueError: If environment variable is not set
+        ValueError: If environment variable is not set and no default provided
     """
-    value = os.environ.get(env_var_name)
+    value = os.environ.get(env_var_name, default)
 
     if value is None:
         raise ValueError(
@@ -730,11 +752,11 @@ def _resolve_variable_value(
 
         # Check if this is an environment variable reference
         if _is_env_variable_reference(raw_value):
-            # Validate and extract env var name
-            env_var_name = _validate_env_variable_reference(name, raw_value)
+            # Validate and extract env var name and optional default
+            env_var_name, default = _validate_env_variable_reference(name, raw_value)
 
-            # Resolve from os.environ
-            string_value = _resolve_env_variable(name, env_var_name)
+            # Resolve from os.environ (with optional default)
+            string_value = _resolve_env_variable(name, env_var_name, default)
 
             # Still perform variable-in-variable substitution
             from tasktree.substitution import substitute_variables

{tasktree-0.0.11 → tasktree-0.0.12}/tests/integration/test_variables.py

@@ -693,6 +693,238 @@ tasks:
             finally:
                 os.chdir(original_cwd)
 
+    def test_env_variable_with_default_when_not_set(self):
+        """Test default value is used when environment variable is not set."""
+        # Ensure env var is NOT set
+        if "TEST_PORT_DEFAULT" in os.environ:
+            del os.environ["TEST_PORT_DEFAULT"]
+
+        with TemporaryDirectory() as tmpdir:
+            project_root = Path(tmpdir)
+
+            recipe_file = project_root / "tasktree.yaml"
+            recipe_file.write_text("""
+variables:
+  port: { env: TEST_PORT_DEFAULT, default: "8080" }
+
+tasks:
+  test:
+    outputs: [config.txt]
+    cmd: echo "Port={{ var.port }}" > config.txt
+""")
+
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(project_root)
+
+                # Run task
+                result = self.runner.invoke(app, ["test"], env=self.env)
+                self.assertEqual(result.exit_code, 0)
+
+                # Verify default value was used
+                output_file = project_root / "config.txt"
+                self.assertTrue(output_file.exists())
+                content = output_file.read_text().strip()
+                self.assertEqual(content, "Port=8080")
+
+            finally:
+                os.chdir(original_cwd)
+
+    def test_env_variable_with_default_when_set(self):
+        """Test environment variable value is used when set, ignoring default."""
+        # Set environment variable
+        os.environ["TEST_PORT_OVERRIDE"] = "9000"
+
+        try:
+            with TemporaryDirectory() as tmpdir:
+                project_root = Path(tmpdir)
+
+                recipe_file = project_root / "tasktree.yaml"
+                recipe_file.write_text("""
+variables:
+  port: { env: TEST_PORT_OVERRIDE, default: "8080" }
+
+tasks:
+  test:
+    outputs: [config.txt]
+    cmd: echo "Port={{ var.port }}" > config.txt
+""")
+
+                original_cwd = os.getcwd()
+                try:
+                    os.chdir(project_root)
+
+                    # Run task
+                    result = self.runner.invoke(app, ["test"], env=self.env)
+                    self.assertEqual(result.exit_code, 0)
+
+                    # Verify env var value was used, not default
+                    output_file = project_root / "config.txt"
+                    self.assertTrue(output_file.exists())
+                    content = output_file.read_text().strip()
+                    self.assertEqual(content, "Port=9000")
+
+                finally:
+                    os.chdir(original_cwd)
+
+        finally:
+            del os.environ["TEST_PORT_OVERRIDE"]
+
+    def test_env_variable_empty_string_vs_default(self):
+        """Test that empty string env var is used, not the default."""
+        # Set environment variable to empty string
+        os.environ["TEST_EMPTY_VAR"] = ""
+
+        try:
+            with TemporaryDirectory() as tmpdir:
+                project_root = Path(tmpdir)
+
+                recipe_file = project_root / "tasktree.yaml"
+                recipe_file.write_text("""
+variables:
+  value: { env: TEST_EMPTY_VAR, default: "default_value" }
+
+tasks:
+  test:
+    outputs: [output.txt]
+    cmd: echo "Value=[{{ var.value }}]" > output.txt
+""")
+
+                original_cwd = os.getcwd()
+                try:
+                    os.chdir(project_root)
+
+                    # Run task
+                    result = self.runner.invoke(app, ["test"], env=self.env)
+                    self.assertEqual(result.exit_code, 0)
+
+                    # Verify empty string was used (not default)
+                    output_file = project_root / "output.txt"
+                    self.assertTrue(output_file.exists())
+                    content = output_file.read_text().strip()
+                    self.assertEqual(content, "Value=[]")
+
+                finally:
+                    os.chdir(original_cwd)
+
+        finally:
+            del os.environ["TEST_EMPTY_VAR"]
+
+    def test_env_variable_default_must_be_string(self):
+        """Test that non-string defaults are rejected."""
+        with TemporaryDirectory() as tmpdir:
+            project_root = Path(tmpdir)
+
+            recipe_file = project_root / "tasktree.yaml"
+            recipe_file.write_text("""
+variables:
+  port: { env: TEST_PORT, default: 8080 }
+
+tasks:
+  test:
+    cmd: echo test
+""")
+
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(project_root)
+
+                # Should fail at parse time with clear error
+                result = self.runner.invoke(app, ["test"], env=self.env)
+                self.assertNotEqual(result.exit_code, 0)
+
+                # Error should mention that default must be string
+                output = result.stdout
+                self.assertIn("default", output.lower())
+                self.assertIn("string", output.lower())
+
+            finally:
+                os.chdir(original_cwd)
+
+    def test_env_variable_multiple_with_defaults(self):
+        """Test multiple env variables with defaults work together."""
+        # Set only one env var
+        os.environ["TEST_HOST"] = "prod.example.com"
+
+        try:
+            # Ensure other env var is NOT set
+            if "TEST_PORT" in os.environ:
+                del os.environ["TEST_PORT"]
+
+            with TemporaryDirectory() as tmpdir:
+                project_root = Path(tmpdir)
+
+                recipe_file = project_root / "tasktree.yaml"
+                recipe_file.write_text("""
+variables:
+  host: { env: TEST_HOST, default: "localhost" }
+  port: { env: TEST_PORT, default: "8080" }
+  url: "{{ var.host }}:{{ var.port }}"
+
+tasks:
+  test:
+    outputs: [config.txt]
+    cmd: echo "URL={{ var.url }}" > config.txt
+""")
+
+                original_cwd = os.getcwd()
+                try:
+                    os.chdir(project_root)
+
+                    # Run task
+                    result = self.runner.invoke(app, ["test"], env=self.env)
+                    self.assertEqual(result.exit_code, 0)
+
+                    # Verify one used env var, one used default
+                    output_file = project_root / "config.txt"
+                    self.assertTrue(output_file.exists())
+                    content = output_file.read_text().strip()
+                    self.assertEqual(content, "URL=prod.example.com:8080")
+
+                finally:
+                    os.chdir(original_cwd)
+
+        finally:
+            del os.environ["TEST_HOST"]
+
+    def test_env_variable_default_with_variable_substitution(self):
+        """Test default value can contain variable references."""
+        # Ensure env var is NOT set
+        if "TEST_OVERRIDE" in os.environ:
+            del os.environ["TEST_OVERRIDE"]
+
+        with TemporaryDirectory() as tmpdir:
+            project_root = Path(tmpdir)
+
+            recipe_file = project_root / "tasktree.yaml"
+            recipe_file.write_text("""
+variables:
+  base_url: "https://api.example.com"
+  endpoint: { env: TEST_OVERRIDE, default: "{{ var.base_url }}/users" }
+
+tasks:
+  test:
+    outputs: [config.txt]
+    cmd: echo "Endpoint={{ var.endpoint }}" > config.txt
+""")
+
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(project_root)
+
+                # Run task
+                result = self.runner.invoke(app, ["test"], env=self.env)
+                self.assertEqual(result.exit_code, 0)
+
+                # Verify default with variable substitution worked
+                output_file = project_root / "config.txt"
+                self.assertTrue(output_file.exists())
+                content = output_file.read_text().strip()
+                self.assertEqual(content, "Endpoint=https://api.example.com/users")
+
+            finally:
+                os.chdir(original_cwd)
+
 
 if __name__ == "__main__":
     unittest.main()

{tasktree-0.0.11 → tasktree-0.0.12}/tests/unit/test_parser.py

@@ -1703,7 +1703,7 @@ tasks:
             recipe_path = Path(tmpdir) / "tasktree.yaml"
             recipe_path.write_text("""
 variables:
-  my_var: { env: TEST_VAR, default: "foo" }
+  my_var: { env: TEST_VAR, foo: "bar" }
 
 tasks:
   test:
@@ -1714,8 +1714,8 @@ tasks:
                 parse_recipe(recipe_path)
 
             error_msg = str(cm.exception)
-            self.assertIn("extra keys", error_msg.lower())
-            self.assertIn("default", error_msg)
+            self.assertIn("found invalid keys", error_msg.lower())
+            self.assertIn("foo", error_msg)
 
     def test_parse_env_variable_invalid_name_empty(self):
         """Test error for { env: } with empty value."""