just-bash 0.1.5__py3-none-any.whl → 0.1.10__py3-none-any.whl

just_bash/interpreter/conditionals.py

@@ -164,9 +164,17 @@ def compare_strings(op: str, left: str, right: str, allow_pattern: bool = False)
 def match_pattern(value: str, pattern: str) -> bool:
     """Match a value against a glob-style pattern.
 
-    Converts glob pattern to regex for matching.
+    Supports standard globs and extended glob patterns.
     """
-    # Use fnmatch for glob-style matching
+    import re as _re
+    # Use regex for extglob patterns, fnmatch for standard globs
+    if _re.search(r'[@?*+!]\(', pattern):
+        from .expansion import glob_to_regex
+        regex_pat = "^" + glob_to_regex(pattern) + "$"
+        try:
+            return bool(_re.match(regex_pat, value))
+        except _re.error:
+            pass
     return fnmatch.fnmatch(value, pattern)
 
 
@@ -356,15 +364,32 @@ async def evaluate_binary_file_test(
 
 def evaluate_variable_test(ctx: "InterpreterContext", name: str) -> bool:
     """Test if a variable is set (-v)."""
+    from .types import VariableStore
+    env = ctx.state.env
+
     # Handle array element syntax: arr[idx]
     if "[" in name and name.endswith("]"):
         base = name[:name.index("[")]
         idx = name[name.index("[") + 1:-1]
+        # Resolve nameref for array base
+        if isinstance(env, VariableStore) and env.is_nameref(base):
+            try:
+                base = env.resolve_nameref(base)
+            except ValueError:
+                return False
         # Check if array element exists
         key = f"{base}_{idx}"
-        return key in ctx.state.env
+        return key in env
+
+    # Resolve nameref
+    if isinstance(env, VariableStore) and env.is_nameref(name):
+        try:
+            resolved = env.resolve_nameref(name)
+            return resolved in env
+        except ValueError:
+            return False
 
-    return name in ctx.state.env
+    return name in env
 
 
 def evaluate_shell_option(ctx: "InterpreterContext", option: str) -> bool:

just_bash/interpreter/control_flow.py

@@ -21,8 +21,8 @@ from ..ast.types import (
     CaseNode,
 )
 from ..types import ExecResult
-from .errors import BreakError, ContinueError, ExecutionLimitError
-from .expansion import expand_word_async, expand_word_with_glob, evaluate_arithmetic
+from .errors import BreakError, ContinueError, ExecutionLimitError, ExitError
+from .expansion import expand_word_async, expand_word_for_case_pattern, expand_word_with_glob, evaluate_arithmetic
 
 if TYPE_CHECKING:
     from .types import InterpreterContext
@@ -75,9 +75,18 @@ async def execute_for(ctx: "InterpreterContext", node: ForNode) -> ExecResult:
     # Get words to iterate over
     words: list[str] = []
     if node.words is None:
-        # Iterate over positional parameters
-        params = ctx.state.env.get("@", "").split()
-        words = [p for p in params if p]
+        # Iterate over positional parameters ($1, $2, ...)
+        count = int(ctx.state.env.get("#", "0"))
+        words = []
+        for pi in range(1, count + 1):
+            val = ctx.state.env.get(str(pi), "")
+            if val:
+                words.append(val)
+        if not words:
+            # Fallback to $@ if positional params not set individually
+            at_val = ctx.state.env.get("@", "")
+            if at_val:
+                words = at_val.split()
     elif len(node.words) == 0:
         words = []
     else:
@@ -121,6 +130,9 @@ async def execute_for(ctx: "InterpreterContext", node: ForNode) -> ExecResult:
                     e.stderr = stderr
                     raise
                 continue
+            except ExitError as e:
+                e.prepend_output(stdout, stderr)
+                raise
     finally:
         ctx.state.loop_depth -= 1
 
@@ -177,6 +189,9 @@ async def execute_c_style_for(ctx: "InterpreterContext", node: CStyleForNode) ->
                 if node.update:
                     await evaluate_arithmetic(ctx, node.update.expression)
                 continue
+            except ExitError as e:
+                e.prepend_output(stdout, stderr)
+                raise
 
             # Execute update
             if node.update:
@@ -237,6 +252,9 @@ async def execute_while(ctx: "InterpreterContext", node: WhileNode, stdin: str =
                     e.levels -= 1
                     raise
                 continue
+            except ExitError as e:
+                e.prepend_output(stdout, stderr)
+                raise
     finally:
         ctx.state.loop_depth -= 1
 
@@ -293,6 +311,9 @@ async def execute_until(ctx: "InterpreterContext", node: UntilNode) -> ExecResul
                     e.levels -= 1
                     raise
                 continue
+            except ExitError as e:
+                e.prepend_output(stdout, stderr)
+                raise
     finally:
         ctx.state.loop_depth -= 1
 
@@ -302,6 +323,8 @@ async def execute_until(ctx: "InterpreterContext", node: UntilNode) -> ExecResul
 async def execute_case(ctx: "InterpreterContext", node: CaseNode) -> ExecResult:
     """Execute a case statement."""
     import fnmatch
+    import re as _re
+    from .expansion import glob_to_regex
 
     stdout = ""
     stderr = ""
@@ -310,22 +333,42 @@ async def execute_case(ctx: "InterpreterContext", node: CaseNode) -> ExecResult:
     # Expand the word to match against
     word_value = await expand_word_async(ctx, node.word)
 
+    def _case_match(value: str, pattern: str) -> bool:
+        """Match value against case pattern (supports extglob)."""
+        if _re.search(r'[@?*+!]\(', pattern):
+            regex_pat = "^" + glob_to_regex(pattern) + "$"
+            try:
+                return bool(_re.match(regex_pat, value))
+            except _re.error:
+                pass
+        return fnmatch.fnmatch(value, pattern)
+
+    fall_through = False
     for case_item in node.items:
-        # Check each pattern
-        matched = False
-        for pattern in case_item.patterns:
-            pattern_value = await expand_word_async(ctx, pattern)
-            if fnmatch.fnmatch(word_value, pattern_value):
-                matched = True
-                break
+        if not fall_through:
+            # Check each pattern
+            matched = False
+            for pattern in case_item.patterns:
+                pattern_value = await expand_word_for_case_pattern(ctx, pattern)
+                if _case_match(word_value, pattern_value):
+                    matched = True
+                    break
+        else:
+            # ;& fall-through: execute without pattern check
+            matched = True
+            fall_through = False
 
         if matched:
             # Execute the body for this case
-            for stmt in case_item.body:
-                result = await ctx.execute_statement(stmt)
-                stdout += result.stdout
-                stderr += result.stderr
-                exit_code = result.exit_code
+            try:
+                for stmt in case_item.body:
+                    result = await ctx.execute_statement(stmt)
+                    stdout += result.stdout
+                    stderr += result.stderr
+                    exit_code = result.exit_code
+            except ExitError as e:
+                e.prepend_output(stdout, stderr)
+                raise
 
             # Check terminator
             if case_item.terminator == ";;":
@@ -333,6 +376,7 @@ async def execute_case(ctx: "InterpreterContext", node: CaseNode) -> ExecResult:
                 break
             elif case_item.terminator == ";&":
                 # Fall through to next case body (without pattern check)
+                fall_through = True
                 continue
             elif case_item.terminator == ";;&":
                 # Continue checking patterns