just-bash 0.1.5__py3-none-any.whl

just_bash/commands/checksum/checksum.py

@@ -0,0 +1,179 @@
+"""Checksum command implementations (md5sum, sha1sum, sha256sum)."""
+
+import hashlib
+from ...types import CommandContext, ExecResult
+
+
+class ChecksumCommand:
+    """Base class for checksum commands."""
+
+    name = "checksum"
+    algorithm = "md5"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the checksum command."""
+        check_mode = False
+        binary_mode = False
+        quiet = False
+        status_only = False
+        files: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "-c" or arg == "--check":
+                check_mode = True
+            elif arg == "-b" or arg == "--binary":
+                binary_mode = True
+            elif arg == "-t" or arg == "--text":
+                binary_mode = False
+            elif arg == "--quiet":
+                quiet = True
+            elif arg == "--status":
+                status_only = True
+            elif arg == "--help":
+                return ExecResult(
+                    stdout=f"Usage: {self.name} [OPTION]... [FILE]...\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg == "--":
+                files.extend(args[i + 1:])
+                break
+            elif arg.startswith("-") and arg != "-":
+                return ExecResult(
+                    stdout="",
+                    stderr=f"{self.name}: invalid option -- '{arg[1]}'\n",
+                    exit_code=1,
+                )
+            else:
+                files.append(arg)
+            i += 1
+
+        if not files:
+            files = ["-"]
+
+        if check_mode:
+            return await self._check_sums(files, ctx, quiet, status_only)
+        else:
+            return await self._compute_sums(files, ctx, binary_mode)
+
+    async def _compute_sums(
+        self, files: list[str], ctx: CommandContext, binary_mode: bool
+    ) -> ExecResult:
+        """Compute checksums for files."""
+        stdout_parts = []
+        stderr = ""
+        exit_code = 0
+
+        for file in files:
+            try:
+                if file == "-":
+                    content = ctx.stdin.encode("utf-8")
+                else:
+                    path = ctx.fs.resolve_path(ctx.cwd, file)
+                    content = await ctx.fs.read_file_bytes(path)
+
+                h = hashlib.new(self.algorithm)
+                h.update(content)
+                checksum = h.hexdigest()
+
+                mode_char = "*" if binary_mode else " "
+                stdout_parts.append(f"{checksum} {mode_char}{file}")
+
+            except FileNotFoundError:
+                stderr += f"{self.name}: {file}: No such file or directory\n"
+                exit_code = 1
+            except IsADirectoryError:
+                stderr += f"{self.name}: {file}: Is a directory\n"
+                exit_code = 1
+
+        stdout = "\n".join(stdout_parts)
+        if stdout:
+            stdout += "\n"
+
+        return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)
+
+    async def _check_sums(
+        self, files: list[str], ctx: CommandContext, quiet: bool, status_only: bool
+    ) -> ExecResult:
+        """Check checksums from files."""
+        stdout_parts = []
+        stderr = ""
+        failed_count = 0
+        total_count = 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)
+
+                for line in content.strip().split("\n"):
+                    if not line:
+                        continue
+
+                    # Parse checksum line: "hash  filename" or "hash *filename"
+                    parts = line.split(None, 1)
+                    if len(parts) != 2:
+                        continue
+
+                    expected_hash = parts[0]
+                    filename = parts[1].lstrip("* ")
+                    total_count += 1
+
+                    try:
+                        file_path = ctx.fs.resolve_path(ctx.cwd, filename)
+                        file_content = await ctx.fs.read_file_bytes(file_path)
+                        h = hashlib.new(self.algorithm)
+                        h.update(file_content)
+                        actual_hash = h.hexdigest()
+
+                        if actual_hash == expected_hash:
+                            if not quiet and not status_only:
+                                stdout_parts.append(f"{filename}: OK")
+                        else:
+                            failed_count += 1
+                            if not status_only:
+                                stdout_parts.append(f"{filename}: FAILED")
+
+                    except FileNotFoundError:
+                        failed_count += 1
+                        if not status_only:
+                            stderr += f"{self.name}: {filename}: No such file or directory\n"
+
+            except FileNotFoundError:
+                stderr += f"{self.name}: {file}: No such file or directory\n"
+
+        if failed_count > 0 and not status_only:
+            stderr += f"{self.name}: WARNING: {failed_count} computed checksum did NOT match\n"
+
+        stdout = "\n".join(stdout_parts)
+        if stdout:
+            stdout += "\n"
+
+        exit_code = 1 if failed_count > 0 else 0
+        return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)
+
+
+class Md5sumCommand(ChecksumCommand):
+    """The md5sum command."""
+
+    name = "md5sum"
+    algorithm = "md5"
+
+
+class Sha1sumCommand(ChecksumCommand):
+    """The sha1sum command."""
+
+    name = "sha1sum"
+    algorithm = "sha1"
+
+
+class Sha256sumCommand(ChecksumCommand):
+    """The sha256sum command."""
+
+    name = "sha256sum"
+    algorithm = "sha256"

just_bash/commands/chmod/__init__.py

@@ -0,0 +1,5 @@
+"""Chmod command implementation."""
+
+from .chmod import ChmodCommand
+
+__all__ = ["ChmodCommand"]

just_bash/commands/chmod/chmod.py

@@ -0,0 +1,216 @@
+"""Chmod command implementation.
+
+Usage: chmod [OPTION]... MODE FILE...
+
+Change the mode of each FILE to MODE.
+
+MODE can be:
+  - Octal number (e.g., 755, 644)
+  - Symbolic mode (e.g., u+x, g-w, o=r, a+x)
+
+Options:
+  -R, --recursive  change files and directories recursively
+  -v, --verbose    output a diagnostic for every file processed
+"""
+
+import re
+from ...types import CommandContext, ExecResult
+
+
+class ChmodCommand:
+    """The chmod command."""
+
+    name = "chmod"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the chmod command."""
+        recursive = False
+        verbose = False
+        mode_str = None
+        files: list[str] = []
+
+        # Parse arguments
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "--":
+                files.extend(args[i + 1:])
+                break
+            elif arg.startswith("--"):
+                if arg == "--recursive":
+                    recursive = True
+                elif arg == "--verbose":
+                    verbose = True
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"chmod: unrecognized option '{arg}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-") and arg != "-" and not re.match(r'^-[0-7]+$', arg):
+                for c in arg[1:]:
+                    if c == "R":
+                        recursive = True
+                    elif c == "v":
+                        verbose = True
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"chmod: invalid option -- '{c}'\n",
+                            exit_code=1,
+                        )
+            elif mode_str is None:
+                mode_str = arg
+            else:
+                files.append(arg)
+            i += 1
+
+        if mode_str is None:
+            return ExecResult(
+                stdout="",
+                stderr="chmod: missing operand\n",
+                exit_code=1,
+            )
+
+        if not files:
+            return ExecResult(
+                stdout="",
+                stderr=f"chmod: missing operand after '{mode_str}'\n",
+                exit_code=1,
+            )
+
+        stdout = ""
+        stderr = ""
+        exit_code = 0
+
+        for f in files:
+            try:
+                path = ctx.fs.resolve_path(ctx.cwd, f)
+                await self._chmod_path(ctx, path, mode_str, recursive, verbose, f)
+                if verbose:
+                    stdout += f"mode of '{f}' changed\n"
+            except FileNotFoundError:
+                stderr += f"chmod: cannot access '{f}': No such file or directory\n"
+                exit_code = 1
+            except ValueError as e:
+                stderr += f"chmod: invalid mode: '{mode_str}'\n"
+                exit_code = 1
+            except OSError as e:
+                stderr += f"chmod: changing permissions of '{f}': {e}\n"
+                exit_code = 1
+
+        return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)
+
+    async def _chmod_path(
+        self,
+        ctx: CommandContext,
+        path: str,
+        mode_str: str,
+        recursive: bool,
+        verbose: bool,
+        display_name: str,
+    ) -> None:
+        """Change mode of a path, optionally recursively."""
+        # Get current stat
+        st = await ctx.fs.stat(path)
+        current_mode = st.mode & 0o7777  # Get permission bits
+
+        # Calculate new mode
+        new_mode = self._parse_mode(mode_str, current_mode)
+
+        # Apply mode
+        await ctx.fs.chmod(path, new_mode)
+
+        # Recurse into directories
+        if recursive and st.is_directory:
+            entries = await ctx.fs.readdir(path)
+            for entry in entries:
+                child_path = f"{path}/{entry}"
+                child_name = f"{display_name}/{entry}"
+                await self._chmod_path(ctx, child_path, mode_str, recursive, verbose, child_name)
+
+    def _parse_mode(self, mode_str: str, current_mode: int) -> int:
+        """Parse mode string and return numeric mode."""
+        # Try octal first
+        if re.match(r'^[0-7]+$', mode_str):
+            return int(mode_str, 8)
+
+        # Symbolic mode parsing
+        # Format: [ugoa]*([-+=]([rwxXst]*|[ugo]))+
+        new_mode = current_mode
+
+        # Split into clauses separated by commas
+        for clause in mode_str.split(","):
+            new_mode = self._apply_symbolic_mode(clause.strip(), new_mode)
+
+        return new_mode
+
+    def _apply_symbolic_mode(self, clause: str, current_mode: int) -> int:
+        """Apply a single symbolic mode clause."""
+        # Parse who (ugoa)
+        who_chars = ""
+        i = 0
+        while i < len(clause) and clause[i] in "ugoa":
+            who_chars += clause[i]
+            i += 1
+
+        # Default to 'a' if no who specified
+        if not who_chars:
+            who_chars = "a"
+
+        # Parse operations
+        while i < len(clause):
+            if clause[i] not in "+-=":
+                raise ValueError(f"Invalid operator in mode: {clause[i]}")
+
+            op = clause[i]
+            i += 1
+
+            # Parse permissions
+            perm_bits = 0
+            while i < len(clause) and clause[i] in "rwxXst":
+                c = clause[i]
+                if c == "r":
+                    perm_bits |= 0o4
+                elif c == "w":
+                    perm_bits |= 0o2
+                elif c == "x":
+                    perm_bits |= 0o1
+                elif c == "X":
+                    # Execute only if directory or already executable
+                    if current_mode & 0o111:
+                        perm_bits |= 0o1
+                elif c == "s":
+                    # setuid/setgid - not fully implemented
+                    pass
+                elif c == "t":
+                    # sticky bit - not fully implemented
+                    pass
+                i += 1
+
+            # Calculate mask based on who
+            mask = 0
+            if "u" in who_chars or "a" in who_chars:
+                mask |= perm_bits << 6
+            if "g" in who_chars or "a" in who_chars:
+                mask |= perm_bits << 3
+            if "o" in who_chars or "a" in who_chars:
+                mask |= perm_bits
+
+            # Apply operation
+            if op == "+":
+                current_mode |= mask
+            elif op == "-":
+                current_mode &= ~mask
+            elif op == "=":
+                # Clear and set
+                clear_mask = 0
+                if "u" in who_chars or "a" in who_chars:
+                    clear_mask |= 0o700
+                if "g" in who_chars or "a" in who_chars:
+                    clear_mask |= 0o070
+                if "o" in who_chars or "a" in who_chars:
+                    clear_mask |= 0o007
+                current_mode = (current_mode & ~clear_mask) | mask
+
+        return current_mode

just_bash/commands/column/__init__.py

@@ -0,0 +1,5 @@
+"""Column command."""
+
+from .column import ColumnCommand
+
+__all__ = ["ColumnCommand"]

just_bash/commands/column/column.py

@@ -0,0 +1,180 @@
+"""Column command implementation."""
+
+from ...types import CommandContext, ExecResult
+
+
+class ColumnCommand:
+    """The column command - columnate lists."""
+
+    name = "column"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the column command."""
+        table_mode = False
+        separator = None
+        output_separator = "  "
+        no_merge = False
+        column_width = 80
+        files: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "--help":
+                return ExecResult(
+                    stdout="Usage: column [OPTION]... [FILE]...\nColumnate lists.\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg in ("-t", "--table"):
+                table_mode = True
+            elif arg in ("-n", "--no-merge"):
+                no_merge = True
+            elif arg == "-s" and i + 1 < len(args):
+                i += 1
+                separator = args[i]
+            elif arg.startswith("-s"):
+                separator = arg[2:]
+            elif arg == "-o" and i + 1 < len(args):
+                i += 1
+                output_separator = args[i]
+            elif arg.startswith("-o"):
+                output_separator = arg[2:]
+            elif arg == "-c" and i + 1 < len(args):
+                i += 1
+                try:
+                    column_width = int(args[i])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"column: invalid column width: '{args[i]}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-c"):
+                try:
+                    column_width = int(arg[2:])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"column: invalid column width: '{arg[2:]}'\n",
+                        exit_code=1,
+                    )
+            elif arg == "--":
+                files.extend(args[i + 1:])
+                break
+            elif arg.startswith("-") and len(arg) > 1:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"column: invalid option -- '{arg[1]}'\n",
+                    exit_code=1,
+                )
+            else:
+                files.append(arg)
+            i += 1
+
+        # Read content
+        content = ""
+        if not files:
+            content = ctx.stdin
+        else:
+            parts = []
+            for file in files:
+                try:
+                    if file == "-":
+                        parts.append(ctx.stdin)
+                    else:
+                        path = ctx.fs.resolve_path(ctx.cwd, file)
+                        parts.append(await ctx.fs.read_file(path))
+                except FileNotFoundError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"column: {file}: No such file or directory\n",
+                        exit_code=1,
+                    )
+            content = "".join(parts)
+
+        if not content.strip():
+            return ExecResult(stdout="", stderr="", exit_code=0)
+
+        if table_mode:
+            result = self._format_table(content, separator, output_separator, no_merge)
+        else:
+            result = self._format_columns(content, column_width)
+
+        return ExecResult(stdout=result, stderr="", exit_code=0)
+
+    def _format_table(
+        self, content: str, separator: str | None, output_separator: str, no_merge: bool
+    ) -> str:
+        """Format content as a table."""
+        lines = content.rstrip("\n").split("\n")
+        rows: list[list[str]] = []
+
+        for line in lines:
+            if separator:
+                if no_merge:
+                    fields = line.split(separator)
+                else:
+                    fields = [f for f in line.split(separator) if f]
+            else:
+                if no_merge:
+                    fields = line.split()
+                else:
+                    fields = line.split()
+            rows.append(fields)
+
+        if not rows:
+            return ""
+
+        # Calculate column widths
+        max_cols = max(len(row) for row in rows)
+        col_widths = [0] * max_cols
+
+        for row in rows:
+            for i, field in enumerate(row):
+                if i < max_cols:
+                    col_widths[i] = max(col_widths[i], len(field))
+
+        # Format output
+        result_lines = []
+        for row in rows:
+            formatted = []
+            for i, field in enumerate(row):
+                if i < len(row) - 1:
+                    formatted.append(field.ljust(col_widths[i]))
+                else:
+                    formatted.append(field)
+            result_lines.append(output_separator.join(formatted))
+
+        return "\n".join(result_lines) + "\n"
+
+    def _format_columns(self, content: str, width: int) -> str:
+        """Format content as columns (fill mode)."""
+        lines = content.rstrip("\n").split("\n")
+        items = []
+        for line in lines:
+            items.extend(line.split())
+
+        if not items:
+            return ""
+
+        # Find maximum item width
+        max_item_width = max(len(item) for item in items)
+        col_width = max_item_width + 2
+
+        # Calculate number of columns
+        num_cols = max(1, width // col_width)
+
+        # Format output
+        result_lines = []
+        for i in range(0, len(items), num_cols):
+            row_items = items[i:i + num_cols]
+            formatted = []
+            for j, item in enumerate(row_items):
+                if j < len(row_items) - 1:
+                    formatted.append(item.ljust(col_width))
+                else:
+                    formatted.append(item)
+            result_lines.append("".join(formatted))
+
+        return "\n".join(result_lines) + "\n"

just_bash/commands/comm/__init__.py

@@ -0,0 +1,5 @@
+"""Comm command."""
+
+from .comm import CommCommand
+
+__all__ = ["CommCommand"]