just-bash 0.1.5__py3-none-any.whl

just_bash/commands/nl/nl.py

@@ -0,0 +1,180 @@
+"""Nl command implementation - number lines."""
+
+from ...types import CommandContext, ExecResult
+
+
+class NlCommand:
+    """The nl command - number lines."""
+
+    name = "nl"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the nl command."""
+        body_style = "t"  # t=non-empty, a=all, n=none
+        number_format = "rn"  # rn=right, ln=left, rz=right-zero
+        width = 6
+        separator = "\t"
+        start_num = 1
+        increment = 1
+        files: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "-b" and i + 1 < len(args):
+                i += 1
+                body_style = args[i]
+            elif arg.startswith("-b"):
+                body_style = arg[2:]
+            elif arg == "-n" and i + 1 < len(args):
+                i += 1
+                number_format = args[i]
+            elif arg.startswith("-n"):
+                number_format = arg[2:]
+            elif arg == "-w" and i + 1 < len(args):
+                i += 1
+                try:
+                    width = int(args[i])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"nl: invalid width: '{args[i]}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-w"):
+                try:
+                    width = int(arg[2:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"nl: invalid width: '{arg[2:]}'\n",
+                        exit_code=1,
+                    )
+            elif arg == "-s" and i + 1 < len(args):
+                i += 1
+                separator = args[i]
+            elif arg.startswith("-s"):
+                separator = arg[2:]
+            elif arg == "-v" and i + 1 < len(args):
+                i += 1
+                try:
+                    start_num = int(args[i])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"nl: invalid starting number: '{args[i]}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-v"):
+                try:
+                    start_num = int(arg[2:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"nl: invalid starting number: '{arg[2:]}'\n",
+                        exit_code=1,
+                    )
+            elif arg == "-i" and i + 1 < len(args):
+                i += 1
+                try:
+                    increment = int(args[i])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"nl: invalid increment: '{args[i]}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-i"):
+                try:
+                    increment = int(arg[2:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"nl: invalid increment: '{arg[2:]}'\n",
+                        exit_code=1,
+                    )
+            elif arg == "--help":
+                return ExecResult(
+                    stdout="Usage: nl [OPTION]... [FILE]...\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg == "--":
+                files.extend(args[i + 1:])
+                break
+            elif arg.startswith("-") and len(arg) > 1:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"nl: invalid option -- '{arg[1]}'\n",
+                    exit_code=1,
+                )
+            else:
+                files.append(arg)
+            i += 1
+
+        # Validate body style
+        if body_style not in ("a", "t", "n"):
+            return ExecResult(
+                stdout="",
+                stderr=f"nl: invalid body numbering style: '{body_style}'\n",
+                exit_code=1,
+            )
+
+        # Validate number format
+        if number_format not in ("ln", "rn", "rz"):
+            return ExecResult(
+                stdout="",
+                stderr=f"nl: invalid line number format: '{number_format}'\n",
+                exit_code=1,
+            )
+
+        # Read content
+        if files:
+            content_parts = []
+            for f in files:
+                try:
+                    path = ctx.fs.resolve_path(ctx.cwd, f)
+                    content_parts.append(await ctx.fs.read_file(path))
+                except FileNotFoundError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"nl: {f}: No such file or directory\n",
+                        exit_code=1,
+                    )
+            content = "".join(content_parts)
+        else:
+            content = ctx.stdin
+
+        if not content:
+            return ExecResult(stdout="", stderr="", exit_code=0)
+
+        # Number lines
+        lines = content.splitlines()
+        output_lines = []
+        line_num = start_num
+
+        for line in lines:
+            should_number = False
+            if body_style == "a":
+                should_number = True
+            elif body_style == "t":
+                should_number = bool(line.strip())
+            # body_style == "n" means never number
+
+            if should_number:
+                if number_format == "ln":
+                    num_str = str(line_num).ljust(width)
+                elif number_format == "rz":
+                    num_str = str(line_num).zfill(width)
+                else:  # rn
+                    num_str = str(line_num).rjust(width)
+                output_lines.append(f"{num_str}{separator}{line}")
+                line_num += increment
+            else:
+                output_lines.append(" " * width + separator + line)
+
+        output = "\n".join(output_lines)
+        if content.endswith("\n"):
+            output += "\n"
+
+        return ExecResult(stdout=output, stderr="", exit_code=0)

just_bash/commands/od/__init__.py

@@ -0,0 +1,5 @@
+"""Od command."""
+
+from .od import OdCommand
+
+__all__ = ["OdCommand"]

just_bash/commands/od/od.py

@@ -0,0 +1,157 @@
+"""Od command implementation."""
+
+from ...types import CommandContext, ExecResult
+
+
+class OdCommand:
+    """The od command - dump files in various formats."""
+
+    name = "od"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the od command."""
+        format_type = "o"  # octal (default)
+        address_format = "o"  # octal addresses
+        suppress_address = False
+        files: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "--help":
+                return ExecResult(
+                    stdout="Usage: od [OPTION]... [FILE]...\nDump files in various formats.\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg == "-c":
+                format_type = "c"  # character
+            elif arg == "-x":
+                format_type = "x"  # hexadecimal
+            elif arg == "-o":
+                format_type = "o"  # octal
+            elif arg == "-d":
+                format_type = "d"  # decimal
+            elif arg == "-An":
+                suppress_address = True
+            elif arg == "-Ad":
+                address_format = "d"
+            elif arg == "-Ao":
+                address_format = "o"
+            elif arg == "-Ax":
+                address_format = "x"
+            elif arg == "--":
+                files.extend(args[i + 1:])
+                break
+            elif arg.startswith("-") and len(arg) > 1:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"od: invalid option -- '{arg[1]}'\n",
+                    exit_code=1,
+                )
+            else:
+                files.append(arg)
+            i += 1
+
+        # Read from stdin if no files
+        if not files:
+            content = ctx.stdin.encode("utf-8", errors="replace")
+            result = self._dump(content, format_type, address_format, suppress_address)
+            return ExecResult(stdout=result, stderr="", exit_code=0)
+
+        stdout_parts = []
+        stderr = ""
+        exit_code = 0
+
+        for file in files:
+            try:
+                if file == "-":
+                    content = ctx.stdin.encode("utf-8", errors="replace")
+                else:
+                    path = ctx.fs.resolve_path(ctx.cwd, file)
+                    content = await ctx.fs.read_file_bytes(path)
+
+                result = self._dump(content, format_type, address_format, suppress_address)
+                stdout_parts.append(result)
+
+            except FileNotFoundError:
+                stderr += f"od: {file}: No such file or directory\n"
+                exit_code = 1
+
+        return ExecResult(stdout="".join(stdout_parts), stderr=stderr, exit_code=exit_code)
+
+    def _dump(
+        self, data: bytes, format_type: str, address_format: str, suppress_address: bool
+    ) -> str:
+        """Dump data in specified format."""
+        result_lines = []
+        bytes_per_line = 16
+        offset = 0
+
+        while offset < len(data):
+            line_data = data[offset:offset + bytes_per_line]
+            parts = []
+
+            # Add address
+            if not suppress_address:
+                if address_format == "d":
+                    parts.append(f"{offset:07d}")
+                elif address_format == "x":
+                    parts.append(f"{offset:07x}")
+                else:
+                    parts.append(f"{offset:07o}")
+
+            # Add data
+            if format_type == "c":
+                # Character format
+                chars = []
+                for byte in line_data:
+                    if byte == 0:
+                        chars.append("\\0")
+                    elif byte == 7:
+                        chars.append("\\a")
+                    elif byte == 8:
+                        chars.append("\\b")
+                    elif byte == 9:
+                        chars.append("\\t")
+                    elif byte == 10:
+                        chars.append("\\n")
+                    elif byte == 11:
+                        chars.append("\\v")
+                    elif byte == 12:
+                        chars.append("\\f")
+                    elif byte == 13:
+                        chars.append("\\r")
+                    elif 32 <= byte <= 126:
+                        chars.append(f"  {chr(byte)}")
+                    else:
+                        chars.append(f"{byte:03o}")
+                parts.append(" ".join(chars))
+            elif format_type == "x":
+                # Hexadecimal format
+                hex_vals = [f"{byte:02x}" for byte in line_data]
+                parts.append(" ".join(hex_vals))
+            elif format_type == "d":
+                # Decimal format
+                dec_vals = [f"{byte:3d}" for byte in line_data]
+                parts.append(" ".join(dec_vals))
+            else:
+                # Octal format (default)
+                oct_vals = [f"{byte:03o}" for byte in line_data]
+                parts.append(" ".join(oct_vals))
+
+            result_lines.append(" ".join(parts))
+            offset += bytes_per_line
+
+        # Final address marker
+        if not suppress_address and data:
+            if address_format == "d":
+                result_lines.append(f"{len(data):07d}")
+            elif address_format == "x":
+                result_lines.append(f"{len(data):07x}")
+            else:
+                result_lines.append(f"{len(data):07o}")
+
+        if result_lines:
+            return "\n".join(result_lines) + "\n"
+        return ""

just_bash/commands/paste/__init__.py

@@ -0,0 +1,5 @@
+"""Paste command."""
+
+from .paste import PasteCommand
+
+__all__ = ["PasteCommand"]

just_bash/commands/paste/paste.py

@@ -0,0 +1,100 @@
+"""Paste command implementation."""
+
+from ...types import CommandContext, ExecResult
+
+
+class PasteCommand:
+    """The paste command - merge lines of files."""
+
+    name = "paste"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the paste command."""
+        delimiter = "\t"
+        serial = False
+        files: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "-d" and i + 1 < len(args):
+                i += 1
+                delimiter = args[i]
+            elif arg.startswith("-d"):
+                delimiter = arg[2:]
+            elif arg in ("-s", "--serial"):
+                serial = True
+            elif arg == "--help":
+                return ExecResult(
+                    stdout="Usage: paste [OPTION]... [FILE]...\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg == "--":
+                files.extend(args[i + 1:])
+                break
+            elif arg.startswith("--"):
+                return ExecResult(
+                    stdout="",
+                    stderr=f"paste: unrecognized option '{arg}'\n",
+                    exit_code=1,
+                )
+            elif arg.startswith("-") and len(arg) > 1 and arg != "-":
+                return ExecResult(
+                    stdout="",
+                    stderr=f"paste: invalid option -- '{arg[1]}'\n",
+                    exit_code=1,
+                )
+            else:
+                files.append(arg)
+            i += 1
+
+        if not files:
+            return ExecResult(
+                stdout="",
+                stderr="paste: missing operand\n",
+                exit_code=1,
+            )
+
+        # Read all files
+        file_contents: list[list[str]] = []
+        for f in files:
+            try:
+                if f == "-":
+                    content = ctx.stdin
+                else:
+                    path = ctx.fs.resolve_path(ctx.cwd, f)
+                    content = await ctx.fs.read_file(path)
+                file_contents.append(content.splitlines())
+            except FileNotFoundError:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"paste: {f}: No such file or directory\n",
+                    exit_code=1,
+                )
+
+        if serial:
+            # Serial mode: paste all lines of each file into one line
+            output_lines = []
+            for lines in file_contents:
+                output_lines.append(delimiter.join(lines))
+            output = "\n".join(output_lines) + "\n"
+        else:
+            # Normal mode: paste corresponding lines
+            max_lines = max(len(lines) for lines in file_contents) if file_contents else 0
+            output_lines = []
+
+            for line_idx in range(max_lines):
+                parts = []
+                for file_idx, lines in enumerate(file_contents):
+                    if line_idx < len(lines):
+                        parts.append(lines[line_idx])
+                    else:
+                        parts.append("")
+                output_lines.append(delimiter.join(parts))
+
+            output = "\n".join(output_lines)
+            if output:
+                output += "\n"
+
+        return ExecResult(stdout=output, stderr="", exit_code=0)

just_bash/commands/printf/__init__.py

@@ -0,0 +1,5 @@
+"""Printf command."""
+
+from .printf import PrintfCommand
+
+__all__ = ["PrintfCommand"]

just_bash/commands/printf/printf.py

@@ -0,0 +1,157 @@
+"""Printf command implementation."""
+
+import re
+from ...types import CommandContext, ExecResult
+
+
+class PrintfCommand:
+    """The printf command."""
+
+    name = "printf"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the printf command."""
+        if not args:
+            return ExecResult(
+                stdout="",
+                stderr="printf: usage: printf format [arguments]\n",
+                exit_code=2,
+            )
+
+        format_str = args[0]
+        arguments = args[1:]
+
+        try:
+            output = self._format(format_str, arguments)
+            return ExecResult(stdout=output, stderr="", exit_code=0)
+        except ValueError as e:
+            return ExecResult(stdout="", stderr=f"printf: {e}\n", exit_code=1)
+
+    def _format(self, format_str: str, arguments: list[str]) -> str:
+        """Format the string with arguments."""
+        result = []
+        arg_index = 0
+        i = 0
+
+        while i < len(format_str):
+            if format_str[i] == "\\" and i + 1 < len(format_str):
+                # Handle escape sequences
+                escape_char = format_str[i + 1]
+                if escape_char == "n":
+                    result.append("\n")
+                elif escape_char == "t":
+                    result.append("\t")
+                elif escape_char == "r":
+                    result.append("\r")
+                elif escape_char == "\\":
+                    result.append("\\")
+                elif escape_char == "a":
+                    result.append("\a")
+                elif escape_char == "b":
+                    result.append("\b")
+                elif escape_char == "f":
+                    result.append("\f")
+                elif escape_char == "v":
+                    result.append("\v")
+                elif escape_char == "e" or escape_char == "E":
+                    result.append("\x1b")
+                elif escape_char == "0":
+                    # Octal escape
+                    octal = ""
+                    j = i + 2
+                    while j < len(format_str) and len(octal) < 3 and format_str[j] in "01234567":
+                        octal += format_str[j]
+                        j += 1
+                    if octal:
+                        result.append(chr(int(octal, 8)))
+                        i = j
+                        continue
+                    else:
+                        result.append("\0")
+                elif escape_char == "x":
+                    # Hex escape
+                    hex_digits = ""
+                    j = i + 2
+                    while j < len(format_str) and len(hex_digits) < 2 and format_str[j] in "0123456789abcdefABCDEF":
+                        hex_digits += format_str[j]
+                        j += 1
+                    if hex_digits:
+                        result.append(chr(int(hex_digits, 16)))
+                        i = j
+                        continue
+                    else:
+                        result.append(escape_char)
+                else:
+                    result.append(escape_char)
+                i += 2
+            elif format_str[i] == "%" and i + 1 < len(format_str):
+                # Handle format specifiers
+                if format_str[i + 1] == "%":
+                    result.append("%")
+                    i += 2
+                    continue
+
+                # Parse format specifier
+                spec_match = re.match(r"-?(\d+)?(\.\d+)?([diouxXeEfFgGsbc])", format_str[i + 1:])
+                if spec_match:
+                    spec = spec_match.group(0)
+                    full_spec = "%" + spec
+                    spec_type = spec_match.group(3)
+
+                    # Get argument
+                    if arg_index < len(arguments):
+                        arg = arguments[arg_index]
+                        arg_index += 1
+                    else:
+                        arg = ""
+
+                    # Format based on type
+                    try:
+                        if spec_type in "diouxX":
+                            val = int(arg) if arg else 0
+                            result.append(full_spec % val)
+                        elif spec_type in "eEfFgG":
+                            val = float(arg) if arg else 0.0
+                            result.append(full_spec % val)
+                        elif spec_type == "s":
+                            result.append(full_spec % arg)
+                        elif spec_type == "c":
+                            result.append(arg[0] if arg else "")
+                        elif spec_type == "b":
+                            # %b is like %s but interprets escapes
+                            result.append(self._process_escapes(arg))
+                    except (ValueError, TypeError):
+                        result.append(full_spec % 0 if spec_type in "diouxXeEfFgG" else "")
+
+                    i += 1 + len(spec)
+                else:
+                    result.append(format_str[i])
+                    i += 1
+            else:
+                result.append(format_str[i])
+                i += 1
+
+        return "".join(result)
+
+    def _process_escapes(self, s: str) -> str:
+        """Process escape sequences in a string."""
+        result = []
+        i = 0
+        while i < len(s):
+            if s[i] == "\\" and i + 1 < len(s):
+                c = s[i + 1]
+                if c == "n":
+                    result.append("\n")
+                elif c == "t":
+                    result.append("\t")
+                elif c == "r":
+                    result.append("\r")
+                elif c == "\\":
+                    result.append("\\")
+                else:
+                    result.append(c)
+                i += 2
+            else:
+                result.append(s[i])
+                i += 1
+        return "".join(result)

just_bash/commands/pwd/__init__.py

@@ -0,0 +1,5 @@
+"""Pwd command implementation."""
+
+from .pwd import PwdCommand
+
+__all__ = ["PwdCommand"]

just_bash/commands/pwd/pwd.py

@@ -0,0 +1,23 @@
+"""Pwd command implementation.
+
+Usage: pwd [-LP]
+
+Print the name of the current working directory.
+
+Options:
+  -L    Print the value of $PWD if it names the current working directory
+  -P    Print the physical directory, without any symbolic links
+"""
+
+from ...types import CommandContext, ExecResult
+
+
+class PwdCommand:
+    """The pwd command."""
+
+    name = "pwd"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the pwd command."""
+        # For now, just return cwd (ignore -L/-P options in virtual fs)
+        return ExecResult(stdout=f"{ctx.cwd}\n", stderr="", exit_code=0)

just_bash/commands/read/__init__.py

@@ -0,0 +1,5 @@
+"""Read command module."""
+
+from .read import ReadCommand
+
+__all__ = ["ReadCommand"]