just-bash 0.1.5__py3-none-any.whl

just_bash/commands/comm/comm.py

@@ -0,0 +1,150 @@
+"""Comm command implementation."""
+
+from ...types import CommandContext, ExecResult
+
+
+class CommCommand:
+    """The comm command - compare two sorted files line by line."""
+
+    name = "comm"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the comm command."""
+        suppress_col1 = False  # Lines unique to file1
+        suppress_col2 = False  # Lines unique to file2
+        suppress_col3 = False  # Lines common to both
+        files: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "--help":
+                return ExecResult(
+                    stdout="Usage: comm [OPTION]... FILE1 FILE2\nCompare two sorted files line by line.\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg == "-1":
+                suppress_col1 = True
+            elif arg == "-2":
+                suppress_col2 = True
+            elif arg == "-3":
+                suppress_col3 = True
+            elif arg.startswith("-") and len(arg) > 1 and not arg.startswith("--"):
+                # Handle combined flags like -12, -23, -13, -123
+                for c in arg[1:]:
+                    if c == "1":
+                        suppress_col1 = True
+                    elif c == "2":
+                        suppress_col2 = True
+                    elif c == "3":
+                        suppress_col3 = True
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"comm: invalid option -- '{c}'\n",
+                            exit_code=1,
+                        )
+            elif arg == "--":
+                files.extend(args[i + 1:])
+                break
+            else:
+                files.append(arg)
+            i += 1
+
+        if len(files) < 2:
+            return ExecResult(
+                stdout="",
+                stderr="comm: missing operand\n",
+                exit_code=1,
+            )
+
+        file1, file2 = files[0], files[1]
+
+        # Read files
+        try:
+            if file1 == "-":
+                content1 = ctx.stdin
+            else:
+                path1 = ctx.fs.resolve_path(ctx.cwd, file1)
+                content1 = await ctx.fs.read_file(path1)
+        except FileNotFoundError:
+            return ExecResult(
+                stdout="",
+                stderr=f"comm: {file1}: No such file or directory\n",
+                exit_code=1,
+            )
+
+        try:
+            if file2 == "-":
+                content2 = ctx.stdin
+            else:
+                path2 = ctx.fs.resolve_path(ctx.cwd, file2)
+                content2 = await ctx.fs.read_file(path2)
+        except FileNotFoundError:
+            return ExecResult(
+                stdout="",
+                stderr=f"comm: {file2}: No such file or directory\n",
+                exit_code=1,
+            )
+
+        lines1 = content1.rstrip("\n").split("\n") if content1.strip() else []
+        lines2 = content2.rstrip("\n").split("\n") if content2.strip() else []
+
+        result = self._compare(lines1, lines2, suppress_col1, suppress_col2, suppress_col3)
+        return ExecResult(stdout=result, stderr="", exit_code=0)
+
+    def _compare(
+        self,
+        lines1: list[str],
+        lines2: list[str],
+        suppress_col1: bool,
+        suppress_col2: bool,
+        suppress_col3: bool,
+    ) -> str:
+        """Compare two sorted lists of lines."""
+        result_lines = []
+        i, j = 0, 0
+
+        while i < len(lines1) or j < len(lines2):
+            if i >= len(lines1):
+                # Only file2 lines left (unique to file2 = column 2)
+                if not suppress_col2:
+                    prefix = ""
+                    if not suppress_col1:
+                        prefix += "\t"
+                    result_lines.append(prefix + lines2[j])
+                j += 1
+            elif j >= len(lines2):
+                # Only file1 lines left (unique to file1 = column 1)
+                if not suppress_col1:
+                    result_lines.append(lines1[i])
+                i += 1
+            elif lines1[i] < lines2[j]:
+                # Line unique to file1 (column 1)
+                if not suppress_col1:
+                    result_lines.append(lines1[i])
+                i += 1
+            elif lines1[i] > lines2[j]:
+                # Line unique to file2 (column 2)
+                if not suppress_col2:
+                    prefix = ""
+                    if not suppress_col1:
+                        prefix += "\t"
+                    result_lines.append(prefix + lines2[j])
+                j += 1
+            else:
+                # Lines are equal (common = column 3)
+                if not suppress_col3:
+                    prefix = ""
+                    if not suppress_col1:
+                        prefix += "\t"
+                    if not suppress_col2:
+                        prefix += "\t"
+                    result_lines.append(prefix + lines1[i])
+                i += 1
+                j += 1
+
+        if result_lines:
+            return "\n".join(result_lines) + "\n"
+        return ""

just_bash/commands/compression/__init__.py

@@ -0,0 +1,5 @@
+"""Compression commands."""
+
+from .compression import GzipCommand, GunzipCommand, ZcatCommand
+
+__all__ = ["GzipCommand", "GunzipCommand", "ZcatCommand"]

just_bash/commands/compression/compression.py

@@ -0,0 +1,298 @@
+"""Compression command implementations (gzip, gunzip, zcat)."""
+
+import gzip
+import struct
+from ...types import CommandContext, ExecResult
+
+
+class GzipCommand:
+    """The gzip command - compress files."""
+
+    name = "gzip"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the gzip command."""
+        decompress = False
+        keep_original = False
+        force = False
+        stdout_mode = False
+        verbose = False
+        quiet = False
+        list_mode = False
+        test_mode = False
+        recursive = False
+        suffix = ".gz"
+        level = 6
+        files: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg in ("-d", "--decompress", "--uncompress"):
+                decompress = True
+            elif arg in ("-k", "--keep"):
+                keep_original = True
+            elif arg in ("-f", "--force"):
+                force = True
+            elif arg in ("-c", "--stdout", "--to-stdout"):
+                stdout_mode = True
+            elif arg in ("-v", "--verbose"):
+                verbose = True
+            elif arg in ("-q", "--quiet"):
+                quiet = True
+            elif arg in ("-l", "--list"):
+                list_mode = True
+            elif arg in ("-t", "--test"):
+                test_mode = True
+            elif arg in ("-r", "--recursive"):
+                recursive = True
+            elif arg in ("-S", "--suffix"):
+                i += 1
+                if i < len(args):
+                    suffix = args[i]
+                    if not suffix.startswith("."):
+                        suffix = "." + suffix
+            elif arg.startswith("--suffix="):
+                suffix = arg[9:]
+                if not suffix.startswith("."):
+                    suffix = "." + suffix
+            elif arg in ("-1", "--fast"):
+                level = 1
+            elif arg in ("-9", "--best"):
+                level = 9
+            elif arg.startswith("-") and len(arg) == 2 and arg[1].isdigit():
+                level = int(arg[1])
+            elif arg == "--help":
+                return ExecResult(
+                    stdout="Usage: gzip [OPTION]... [FILE]...\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg == "--":
+                files.extend(args[i + 1:])
+                break
+            elif arg.startswith("-"):
+                # Handle combined short options
+                for c in arg[1:]:
+                    if c == "d":
+                        decompress = True
+                    elif c == "k":
+                        keep_original = True
+                    elif c == "f":
+                        force = True
+                    elif c == "c":
+                        stdout_mode = True
+                    elif c == "v":
+                        verbose = True
+                    elif c == "q":
+                        quiet = True
+                    elif c == "l":
+                        list_mode = True
+                    elif c == "t":
+                        test_mode = True
+                    elif c == "r":
+                        recursive = True
+                    elif c.isdigit():
+                        level = int(c)
+            else:
+                files.append(arg)
+            i += 1
+
+        # Read from stdin if no files
+        if not files:
+            if ctx.stdin:
+                return await self._process_stdin(ctx, decompress, level)
+            return ExecResult(
+                stdout="",
+                stderr="gzip: missing operand\n",
+                exit_code=1,
+            )
+
+        # Expand files if recursive
+        if recursive:
+            files = await self._expand_recursive(ctx, files)
+
+        stdout_parts = []
+        stderr_parts = []
+        exit_code = 0
+
+        # List mode
+        if list_mode:
+            stdout_parts.append(f"{'compressed':>12} {'uncompressed':>12} {'ratio':>6}  name\n")
+            total_compressed = 0
+            total_uncompressed = 0
+
+            for file in files:
+                try:
+                    path = ctx.fs.resolve_path(ctx.cwd, file)
+                    content = await ctx.fs.read_file_bytes(path)
+                    compressed_size = len(content)
+
+                    try:
+                        decompressed = gzip.decompress(content)
+                        uncompressed_size = len(decompressed)
+                        ratio = (1.0 - compressed_size / uncompressed_size) * 100 if uncompressed_size > 0 else 0
+                        stdout_parts.append(f"{compressed_size:>12} {uncompressed_size:>12} {ratio:>5.1f}%  {file}\n")
+                        total_compressed += compressed_size
+                        total_uncompressed += uncompressed_size
+                    except Exception:
+                        if not quiet:
+                            stderr_parts.append(f"gzip: {file}: not in gzip format\n")
+                        exit_code = 1
+                except FileNotFoundError:
+                    if not quiet:
+                        stderr_parts.append(f"gzip: {file}: No such file or directory\n")
+                    exit_code = 1
+
+            if len(files) > 1 and total_uncompressed > 0:
+                total_ratio = (1.0 - total_compressed / total_uncompressed) * 100
+                stdout_parts.append(f"{total_compressed:>12} {total_uncompressed:>12} {total_ratio:>5.1f}%  (totals)\n")
+
+            return ExecResult(stdout="".join(stdout_parts), stderr="".join(stderr_parts), exit_code=exit_code)
+
+        # Test mode
+        if test_mode:
+            for file in files:
+                try:
+                    path = ctx.fs.resolve_path(ctx.cwd, file)
+                    content = await ctx.fs.read_file_bytes(path)
+                    try:
+                        gzip.decompress(content)
+                        if verbose and not quiet:
+                            stderr_parts.append(f"{file}:\tOK\n")
+                    except Exception as e:
+                        if not quiet:
+                            stderr_parts.append(f"gzip: {file}: {e}\n")
+                        exit_code = 1
+                except FileNotFoundError:
+                    if not quiet:
+                        stderr_parts.append(f"gzip: {file}: No such file or directory\n")
+                    exit_code = 1
+
+            return ExecResult(stdout="", stderr="".join(stderr_parts), exit_code=exit_code)
+
+        for file in files:
+            try:
+                path = ctx.fs.resolve_path(ctx.cwd, file)
+                content = await ctx.fs.read_file_bytes(path)
+                original_size = len(content)
+
+                if decompress:
+                    if not file.endswith(suffix) and not force:
+                        if not quiet:
+                            stderr_parts.append(f"gzip: {file}: unknown suffix -- ignored\n")
+                        continue
+                    try:
+                        result = gzip.decompress(content)
+                    except Exception as e:
+                        if not quiet:
+                            stderr_parts.append(f"gzip: {file}: {e}\n")
+                        exit_code = 1
+                        continue
+
+                    if stdout_mode:
+                        stdout_parts.append(result.decode("utf-8", errors="replace"))
+                    else:
+                        # Remove suffix to get output path
+                        if path.endswith(suffix):
+                            new_path = path[:-len(suffix)]
+                        else:
+                            new_path = path + ".out"
+                        await ctx.fs.write_file(new_path, result)
+                        if not keep_original:
+                            await ctx.fs.rm(path)
+
+                    if verbose and not quiet:
+                        ratio = (1.0 - original_size / len(result)) * 100 if len(result) > 0 else 0
+                        stderr_parts.append(f"{file}:\t{ratio:.1f}% -- replaced with {new_path if not stdout_mode else 'stdout'}\n")
+                else:
+                    result = gzip.compress(content, compresslevel=level)
+
+                    if stdout_mode:
+                        # Can't output binary to stdout in text mode
+                        stdout_parts.append(f"<binary gzip data, {len(result)} bytes>")
+                    else:
+                        new_path = path + suffix
+                        await ctx.fs.write_file(new_path, result)
+                        if not keep_original:
+                            await ctx.fs.rm(path)
+
+                    if verbose and not quiet:
+                        ratio = (1.0 - len(result) / original_size) * 100 if original_size > 0 else 0
+                        stderr_parts.append(f"{file}:\t{ratio:.1f}% -- replaced with {new_path if not stdout_mode else 'stdout'}\n")
+
+            except FileNotFoundError:
+                if not quiet:
+                    stderr_parts.append(f"gzip: {file}: No such file or directory\n")
+                exit_code = 1
+            except IsADirectoryError:
+                if not quiet:
+                    stderr_parts.append(f"gzip: {file}: Is a directory\n")
+                exit_code = 1
+
+        stdout = "".join(stdout_parts)
+        stderr = "".join(stderr_parts)
+        return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)
+
+    async def _expand_recursive(self, ctx: CommandContext, paths: list[str]) -> list[str]:
+        """Expand directories recursively to list of files."""
+        result = []
+        for path in paths:
+            full_path = ctx.fs.resolve_path(ctx.cwd, path)
+            try:
+                stat = await ctx.fs.stat(full_path)
+                if stat.is_directory:
+                    # List directory contents
+                    entries = await ctx.fs.readdir(full_path)
+                    sub_paths = [f"{path}/{e}" for e in entries]
+                    result.extend(await self._expand_recursive(ctx, sub_paths))
+                else:
+                    result.append(path)
+            except Exception:
+                result.append(path)  # Let the main loop handle errors
+        return result
+
+    async def _process_stdin(
+        self, ctx: CommandContext, decompress: bool, level: int
+    ) -> ExecResult:
+        """Process stdin."""
+        try:
+            content = ctx.stdin.encode("utf-8")
+            if decompress:
+                result = gzip.decompress(content)
+                return ExecResult(
+                    stdout=result.decode("utf-8", errors="replace"),
+                    stderr="",
+                    exit_code=0,
+                )
+            else:
+                result = gzip.compress(content, compresslevel=level)
+                return ExecResult(
+                    stdout=f"<binary gzip data, {len(result)} bytes>",
+                    stderr="",
+                    exit_code=0,
+                )
+        except Exception as e:
+            return ExecResult(stdout="", stderr=f"gzip: {e}\n", exit_code=1)
+
+
+class GunzipCommand:
+    """The gunzip command - decompress files."""
+
+    name = "gunzip"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute gunzip (gzip -d)."""
+        gzip_cmd = GzipCommand()
+        return await gzip_cmd.execute(["-d"] + args, ctx)
+
+
+class ZcatCommand:
+    """The zcat command - decompress to stdout."""
+
+    name = "zcat"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute zcat (gzip -dc)."""
+        gzip_cmd = GzipCommand()
+        return await gzip_cmd.execute(["-dc"] + args, ctx)

just_bash/commands/cp/__init__.py

@@ -0,0 +1,5 @@
+"""Cp command implementation."""
+
+from .cp import CpCommand
+
+__all__ = ["CpCommand"]

just_bash/commands/cp/cp.py

@@ -0,0 +1,149 @@
+"""Cp command implementation.
+
+Usage: cp [OPTION]... SOURCE... DEST
+
+Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.
+
+Options:
+  -r, -R, --recursive  copy directories recursively
+  -n, --no-clobber     do not overwrite an existing file
+  -v, --verbose        explain what is being done
+"""
+
+from ...types import CommandContext, ExecResult
+
+
+class CpCommand:
+    """The cp command."""
+
+    name = "cp"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the cp command."""
+        recursive = False
+        no_clobber = False
+        verbose = False
+        paths: list[str] = []
+
+        # Parse arguments
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "--":
+                paths.extend(args[i + 1:])
+                break
+            elif arg.startswith("--"):
+                if arg == "--recursive":
+                    recursive = True
+                elif arg == "--no-clobber":
+                    no_clobber = True
+                elif arg == "--verbose":
+                    verbose = True
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"cp: unrecognized option '{arg}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-") and arg != "-":
+                for c in arg[1:]:
+                    if c in ("r", "R"):
+                        recursive = True
+                    elif c == "n":
+                        no_clobber = True
+                    elif c == "v":
+                        verbose = True
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"cp: invalid option -- '{c}'\n",
+                            exit_code=1,
+                        )
+            else:
+                paths.append(arg)
+            i += 1
+
+        if len(paths) < 2:
+            if len(paths) == 0:
+                return ExecResult(
+                    stdout="",
+                    stderr="cp: missing file operand\n",
+                    exit_code=1,
+                )
+            return ExecResult(
+                stdout="",
+                stderr=f"cp: missing destination file operand after '{paths[0]}'\n",
+                exit_code=1,
+            )
+
+        sources = paths[:-1]
+        dest = paths[-1]
+        dest_path = ctx.fs.resolve_path(ctx.cwd, dest)
+
+        # Check if destination is a directory
+        dest_is_dir = False
+        try:
+            st = await ctx.fs.stat(dest_path)
+            dest_is_dir = st.is_directory
+        except FileNotFoundError:
+            pass
+
+        # Multiple sources require destination to be a directory
+        if len(sources) > 1 and not dest_is_dir:
+            return ExecResult(
+                stdout="",
+                stderr=f"cp: target '{dest}' is not a directory\n",
+                exit_code=1,
+            )
+
+        stdout = ""
+        stderr = ""
+        exit_code = 0
+
+        for src in sources:
+            try:
+                src_path = ctx.fs.resolve_path(ctx.cwd, src)
+
+                # Check if source is a directory
+                try:
+                    st = await ctx.fs.stat(src_path)
+                    if st.is_directory and not recursive:
+                        stderr += f"cp: -r not specified; omitting directory '{src}'\n"
+                        exit_code = 1
+                        continue
+                except FileNotFoundError:
+                    stderr += f"cp: cannot stat '{src}': No such file or directory\n"
+                    exit_code = 1
+                    continue
+
+                # Determine target path
+                if dest_is_dir:
+                    # Get basename of source
+                    basename = src.rstrip("/").split("/")[-1]
+                    target_path = ctx.fs.resolve_path(dest_path, basename)
+                else:
+                    target_path = dest_path
+
+                # Check no-clobber
+                if no_clobber:
+                    try:
+                        await ctx.fs.stat(target_path)
+                        # File exists, skip
+                        continue
+                    except FileNotFoundError:
+                        pass
+
+                await ctx.fs.cp(src_path, target_path, recursive=recursive)
+                if verbose:
+                    stdout += f"'{src}' -> '{dest}'\n"
+            except FileNotFoundError:
+                stderr += f"cp: cannot stat '{src}': No such file or directory\n"
+                exit_code = 1
+            except IsADirectoryError:
+                stderr += f"cp: -r not specified; omitting directory '{src}'\n"
+                exit_code = 1
+            except OSError as e:
+                stderr += f"cp: cannot copy '{src}': {e}\n"
+                exit_code = 1
+
+        return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)

just_bash/commands/curl/__init__.py

@@ -0,0 +1,5 @@
+"""Curl command."""
+
+from .curl import CurlCommand
+
+__all__ = ["CurlCommand"]