just-bash 0.1.5__py3-none-any.whl

just_bash/commands/expand/expand.py

@@ -0,0 +1,299 @@
+"""Expand and unexpand command implementations."""
+
+from ...types import CommandContext, ExecResult
+
+
+class ExpandCommand:
+    """The expand command - convert tabs to spaces."""
+
+    name = "expand"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the expand command."""
+        tab_width = 8
+        tab_stops: list[int] = []
+        initial_only = False
+        files: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "--help":
+                return ExecResult(
+                    stdout="Usage: expand [OPTION]... [FILE]...\nConvert tabs to spaces.\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg in ("-i", "--initial"):
+                initial_only = True
+            elif arg == "-t" and i + 1 < len(args):
+                i += 1
+                tab_stops = self._parse_tab_stops(args[i])
+                if tab_stops:
+                    tab_width = tab_stops[0]
+            elif arg.startswith("-t"):
+                tab_stops = self._parse_tab_stops(arg[2:])
+                if tab_stops:
+                    tab_width = tab_stops[0]
+            elif arg.startswith("--tabs="):
+                tab_stops = self._parse_tab_stops(arg[7:])
+                if tab_stops:
+                    tab_width = tab_stops[0]
+            elif arg == "--":
+                files.extend(args[i + 1:])
+                break
+            elif arg.startswith("-") and len(arg) > 1:
+                # Could be -N for tab width
+                try:
+                    tab_width = int(arg[1:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"expand: invalid option -- '{arg[1]}'\n",
+                        exit_code=1,
+                    )
+            else:
+                files.append(arg)
+            i += 1
+
+        if tab_width <= 0:
+            return ExecResult(
+                stdout="",
+                stderr="expand: tab size must be greater than 0\n",
+                exit_code=1,
+            )
+
+        # Read from stdin if no files
+        if not files:
+            content = ctx.stdin
+            result = self._expand_content(content, tab_width, tab_stops, initial_only)
+            return ExecResult(stdout=result, stderr="", exit_code=0)
+
+        stdout_parts = []
+        stderr = ""
+        exit_code = 0
+
+        for file in files:
+            try:
+                if file == "-":
+                    content = ctx.stdin
+                else:
+                    path = ctx.fs.resolve_path(ctx.cwd, file)
+                    content = await ctx.fs.read_file(path)
+
+                result = self._expand_content(content, tab_width, tab_stops, initial_only)
+                stdout_parts.append(result)
+
+            except FileNotFoundError:
+                stderr += f"expand: {file}: No such file or directory\n"
+                exit_code = 1
+
+        return ExecResult(stdout="".join(stdout_parts), stderr=stderr, exit_code=exit_code)
+
+    def _parse_tab_stops(self, s: str) -> list[int]:
+        """Parse tab stop specification."""
+        if not s:
+            return []
+        try:
+            if "," in s:
+                return [int(x) for x in s.split(",") if x]
+            return [int(s)]
+        except ValueError:
+            return []
+
+    def _expand_content(
+        self, content: str, tab_width: int, tab_stops: list[int], initial_only: bool
+    ) -> str:
+        """Expand tabs in content."""
+        lines = content.split("\n")
+        result_lines = []
+
+        for line in lines:
+            result_lines.append(self._expand_line(line, tab_width, tab_stops, initial_only))
+
+        return "\n".join(result_lines)
+
+    def _expand_line(
+        self, line: str, tab_width: int, tab_stops: list[int], initial_only: bool
+    ) -> str:
+        """Expand tabs in a single line."""
+        result = []
+        column = 0
+        in_initial = True
+
+        for char in line:
+            if char == "\t":
+                if initial_only and not in_initial:
+                    result.append(char)
+                    column += 1
+                else:
+                    # Calculate spaces needed to reach next tab stop
+                    if tab_stops and len(tab_stops) > 1:
+                        # Find next tab stop
+                        next_stop = None
+                        for stop in tab_stops:
+                            if stop > column:
+                                next_stop = stop
+                                break
+                        if next_stop is None:
+                            # Use last interval
+                            interval = tab_stops[-1] - tab_stops[-2] if len(tab_stops) > 1 else tab_width
+                            next_stop = column + interval - (column - tab_stops[-1]) % interval
+                        spaces = next_stop - column
+                    else:
+                        spaces = tab_width - (column % tab_width)
+                    result.append(" " * spaces)
+                    column += spaces
+            else:
+                if char != " ":
+                    in_initial = False
+                result.append(char)
+                column += 1
+
+        return "".join(result)
+
+
+class UnexpandCommand:
+    """The unexpand command - convert spaces to tabs."""
+
+    name = "unexpand"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the unexpand command."""
+        tab_width = 8
+        all_spaces = False
+        files: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "--help":
+                return ExecResult(
+                    stdout="Usage: unexpand [OPTION]... [FILE]...\nConvert spaces to tabs.\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg in ("-a", "--all"):
+                all_spaces = True
+            elif arg == "-t" and i + 1 < len(args):
+                i += 1
+                try:
+                    tab_width = int(args[i])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"unexpand: invalid tab size: '{args[i]}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-t"):
+                try:
+                    tab_width = int(arg[2:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"unexpand: invalid tab size: '{arg[2:]}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("--tabs="):
+                try:
+                    tab_width = int(arg[7:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"unexpand: invalid tab size: '{arg[7:]}'\n",
+                        exit_code=1,
+                    )
+            elif arg == "--":
+                files.extend(args[i + 1:])
+                break
+            elif arg.startswith("-") and len(arg) > 1:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"unexpand: invalid option -- '{arg[1]}'\n",
+                    exit_code=1,
+                )
+            else:
+                files.append(arg)
+            i += 1
+
+        if tab_width <= 0:
+            return ExecResult(
+                stdout="",
+                stderr="unexpand: tab size must be greater than 0\n",
+                exit_code=1,
+            )
+
+        # Read from stdin if no files
+        if not files:
+            content = ctx.stdin
+            result = self._unexpand_content(content, tab_width, all_spaces)
+            return ExecResult(stdout=result, stderr="", exit_code=0)
+
+        stdout_parts = []
+        stderr = ""
+        exit_code = 0
+
+        for file in files:
+            try:
+                if file == "-":
+                    content = ctx.stdin
+                else:
+                    path = ctx.fs.resolve_path(ctx.cwd, file)
+                    content = await ctx.fs.read_file(path)
+
+                result = self._unexpand_content(content, tab_width, all_spaces)
+                stdout_parts.append(result)
+
+            except FileNotFoundError:
+                stderr += f"unexpand: {file}: No such file or directory\n"
+                exit_code = 1
+
+        return ExecResult(stdout="".join(stdout_parts), stderr=stderr, exit_code=exit_code)
+
+    def _unexpand_content(self, content: str, tab_width: int, all_spaces: bool) -> str:
+        """Unexpand spaces in content."""
+        lines = content.split("\n")
+        result_lines = []
+
+        for line in lines:
+            result_lines.append(self._unexpand_line(line, tab_width, all_spaces))
+
+        return "\n".join(result_lines)
+
+    def _unexpand_line(self, line: str, tab_width: int, all_spaces: bool) -> str:
+        """Unexpand spaces in a single line."""
+        if not line:
+            return line
+
+        result = []
+        space_count = 0
+        column = 0
+        in_leading = True
+
+        for char in line:
+            if char == " ":
+                space_count += 1
+                column += 1
+
+                # Check if we've reached a tab stop
+                if column % tab_width == 0:
+                    if in_leading or all_spaces:
+                        result.append("\t")
+                    else:
+                        result.append(" " * space_count)
+                    space_count = 0
+            else:
+                # Flush pending spaces
+                if space_count > 0:
+                    result.append(" " * space_count)
+                    space_count = 0
+                result.append(char)
+                column += 1
+                if char != " ":
+                    in_leading = False
+
+        # Flush any remaining spaces
+        if space_count > 0:
+            result.append(" " * space_count)
+
+        return "".join(result)

just_bash/commands/expr/__init__.py

@@ -0,0 +1,5 @@
+"""Expr command implementation."""
+
+from .expr import ExprCommand
+
+__all__ = ["ExprCommand"]

just_bash/commands/expr/expr.py

@@ -0,0 +1,273 @@
+"""Expr command implementation.
+
+Usage: expr EXPRESSION
+
+Print the value of EXPRESSION to standard output.
+
+EXPRESSION may be:
+  ARG1 | ARG2       ARG1 if it is neither null nor 0, otherwise ARG2
+  ARG1 & ARG2       ARG1 if neither argument is null or 0, otherwise 0
+  ARG1 < ARG2       ARG1 is less than ARG2
+  ARG1 <= ARG2      ARG1 is less than or equal to ARG2
+  ARG1 = ARG2       ARG1 is equal to ARG2
+  ARG1 != ARG2      ARG1 is not equal to ARG2
+  ARG1 >= ARG2      ARG1 is greater than or equal to ARG2
+  ARG1 > ARG2       ARG1 is greater than ARG2
+  ARG1 + ARG2       arithmetic sum of ARG1 and ARG2
+  ARG1 - ARG2       arithmetic difference of ARG1 and ARG2
+  ARG1 * ARG2       arithmetic product of ARG1 and ARG2
+  ARG1 / ARG2       arithmetic quotient of ARG1 divided by ARG2
+  ARG1 % ARG2       arithmetic remainder of ARG1 divided by ARG2
+  STRING : REGEXP   anchored pattern match of REGEXP in STRING
+  match STRING REGEXP  same as STRING : REGEXP
+  substr STRING POS LENGTH  substring of STRING, POS counted from 1
+  index STRING CHARS  index in STRING where any CHARS is found, or 0
+  length STRING    length of STRING
+  + TOKEN          interpret TOKEN as a string
+  ( EXPRESSION )   value of EXPRESSION
+"""
+
+import re
+from ...types import CommandContext, ExecResult
+
+
+class ExprCommand:
+    """The expr command."""
+
+    name = "expr"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the expr command."""
+        if not args:
+            return ExecResult(
+                stdout="",
+                stderr="expr: missing operand\n",
+                exit_code=2,
+            )
+
+        try:
+            result, _ = self._evaluate(args, 0)
+            # Exit code is 1 if result is empty or 0
+            exit_code = 1 if result == "" or result == "0" else 0
+            return ExecResult(stdout=str(result) + "\n", stderr="", exit_code=exit_code)
+        except ValueError as e:
+            return ExecResult(stdout="", stderr=f"expr: {e}\n", exit_code=2)
+        except ZeroDivisionError:
+            return ExecResult(stdout="", stderr="expr: division by zero\n", exit_code=2)
+
+    def _evaluate(self, args: list[str], pos: int) -> tuple[str, int]:
+        """Evaluate expression starting at position."""
+        return self._parse_or(args, pos)
+
+    def _parse_or(self, args: list[str], pos: int) -> tuple[str, int]:
+        """Parse OR expression: ARG1 | ARG2."""
+        left, pos = self._parse_and(args, pos)
+
+        while pos < len(args) and args[pos] == "|":
+            pos += 1
+            right, pos = self._parse_and(args, pos)
+            if left != "" and left != "0":
+                pass  # keep left
+            else:
+                left = right
+
+        return left, pos
+
+    def _parse_and(self, args: list[str], pos: int) -> tuple[str, int]:
+        """Parse AND expression: ARG1 & ARG2."""
+        left, pos = self._parse_comparison(args, pos)
+
+        while pos < len(args) and args[pos] == "&":
+            pos += 1
+            right, pos = self._parse_comparison(args, pos)
+            if (left == "" or left == "0") or (right == "" or right == "0"):
+                left = "0"
+            # else keep left
+
+        return left, pos
+
+    def _parse_comparison(self, args: list[str], pos: int) -> tuple[str, int]:
+        """Parse comparison: <, <=, =, !=, >=, >."""
+        left, pos = self._parse_additive(args, pos)
+
+        if pos < len(args) and args[pos] in ("<", "<=", "=", "!=", ">=", ">"):
+            op = args[pos]
+            pos += 1
+            right, pos = self._parse_additive(args, pos)
+
+            # Try numeric comparison first
+            try:
+                l_num = int(left)
+                r_num = int(right)
+                if op == "<":
+                    result = l_num < r_num
+                elif op == "<=":
+                    result = l_num <= r_num
+                elif op == "=":
+                    result = l_num == r_num
+                elif op == "!=":
+                    result = l_num != r_num
+                elif op == ">=":
+                    result = l_num >= r_num
+                elif op == ">":
+                    result = l_num > r_num
+            except ValueError:
+                # String comparison
+                if op == "<":
+                    result = left < right
+                elif op == "<=":
+                    result = left <= right
+                elif op == "=":
+                    result = left == right
+                elif op == "!=":
+                    result = left != right
+                elif op == ">=":
+                    result = left >= right
+                elif op == ">":
+                    result = left > right
+
+            left = "1" if result else "0"
+
+        return left, pos
+
+    def _parse_additive(self, args: list[str], pos: int) -> tuple[str, int]:
+        """Parse additive: + and -."""
+        left, pos = self._parse_multiplicative(args, pos)
+
+        while pos < len(args) and args[pos] in ("+", "-"):
+            op = args[pos]
+            pos += 1
+            right, pos = self._parse_multiplicative(args, pos)
+
+            try:
+                l_num = int(left)
+                r_num = int(right)
+                if op == "+":
+                    left = str(l_num + r_num)
+                else:
+                    left = str(l_num - r_num)
+            except ValueError:
+                raise ValueError("non-integer argument")
+
+        return left, pos
+
+    def _parse_multiplicative(self, args: list[str], pos: int) -> tuple[str, int]:
+        """Parse multiplicative: *, /, %."""
+        left, pos = self._parse_match(args, pos)
+
+        while pos < len(args) and args[pos] in ("*", "/", "%"):
+            op = args[pos]
+            pos += 1
+            right, pos = self._parse_match(args, pos)
+
+            try:
+                l_num = int(left)
+                r_num = int(right)
+                if op == "*":
+                    left = str(l_num * r_num)
+                elif op == "/":
+                    left = str(l_num // r_num)
+                else:
+                    left = str(l_num % r_num)
+            except ValueError:
+                raise ValueError("non-integer argument")
+
+        return left, pos
+
+    def _parse_match(self, args: list[str], pos: int) -> tuple[str, int]:
+        """Parse match expression: STRING : REGEXP."""
+        left, pos = self._parse_primary(args, pos)
+
+        if pos < len(args) and args[pos] == ":":
+            pos += 1
+            right, pos = self._parse_primary(args, pos)
+            # Anchored match at start
+            pattern = "^(" + right + ")"
+            try:
+                match = re.match(pattern, left)
+                if match:
+                    if match.groups():
+                        left = match.group(1)
+                    else:
+                        left = str(len(match.group(0)))
+                else:
+                    left = ""
+            except re.error as e:
+                raise ValueError(f"invalid pattern: {e}")
+
+        return left, pos
+
+    def _parse_primary(self, args: list[str], pos: int) -> tuple[str, int]:
+        """Parse primary expression."""
+        if pos >= len(args):
+            raise ValueError("missing operand")
+
+        token = args[pos]
+
+        # Parentheses
+        if token == "(":
+            pos += 1
+            result, pos = self._evaluate(args, pos)
+            if pos >= len(args) or args[pos] != ")":
+                raise ValueError("unmatched '('")
+            pos += 1
+            return result, pos
+
+        # Built-in functions
+        if token == "match" and pos + 2 < len(args):
+            pos += 1
+            string = args[pos]
+            pos += 1
+            pattern = args[pos]
+            pos += 1
+            # Anchored match
+            try:
+                match = re.match("^(" + pattern + ")", string)
+                if match:
+                    if match.groups():
+                        return match.group(1), pos
+                    return str(len(match.group(0))), pos
+                return "", pos
+            except re.error as e:
+                raise ValueError(f"invalid pattern: {e}")
+
+        if token == "substr" and pos + 3 < len(args):
+            pos += 1
+            string = args[pos]
+            pos += 1
+            try:
+                start = int(args[pos]) - 1  # 1-indexed
+                pos += 1
+                length = int(args[pos])
+                pos += 1
+                if start < 0:
+                    start = 0
+                return string[start:start + length], pos
+            except ValueError:
+                raise ValueError("non-integer argument")
+
+        if token == "index" and pos + 2 < len(args):
+            pos += 1
+            string = args[pos]
+            pos += 1
+            chars = args[pos]
+            pos += 1
+            for i, c in enumerate(string):
+                if c in chars:
+                    return str(i + 1), pos  # 1-indexed
+            return "0", pos
+
+        if token == "length" and pos + 1 < len(args):
+            pos += 1
+            string = args[pos]
+            pos += 1
+            return str(len(string)), pos
+
+        # Quote next token as string
+        if token == "+":
+            pos += 1
+            if pos >= len(args):
+                raise ValueError("missing operand after '+'")
+            return args[pos], pos + 1
+
+        return token, pos + 1

just_bash/commands/file/__init__.py

@@ -0,0 +1,5 @@
+"""File command."""
+
+from .file import FileCommand
+
+__all__ = ["FileCommand"]