just-bash 0.1.5__py3-none-any.whl

just_bash/commands/join/join.py

@@ -0,0 +1,252 @@
+"""Join command implementation."""
+
+from ...types import CommandContext, ExecResult
+
+
+class JoinCommand:
+    """The join command - join lines of two files on a common field."""
+
+    name = "join"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the join command."""
+        field1 = 1
+        field2 = 1
+        separator = None
+        output_format = None
+        print_unpaired_1 = False
+        print_unpaired_2 = False
+        only_unpaired_1 = False
+        only_unpaired_2 = False
+        empty_replacement = None
+        ignore_case = False
+        files: list[str] = []
+
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "--help":
+                return ExecResult(
+                    stdout="Usage: join [OPTION]... FILE1 FILE2\nJoin lines of two files on a common field.\n",
+                    stderr="",
+                    exit_code=0,
+                )
+            elif arg == "-1" and i + 1 < len(args):
+                i += 1
+                try:
+                    field1 = int(args[i])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"join: invalid field number: '{args[i]}'\n",
+                        exit_code=1,
+                    )
+            elif arg == "-2" and i + 1 < len(args):
+                i += 1
+                try:
+                    field2 = int(args[i])
+                except ValueError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"join: invalid field number: '{args[i]}'\n",
+                        exit_code=1,
+                    )
+            elif arg == "-t" and i + 1 < len(args):
+                i += 1
+                separator = args[i]
+            elif arg.startswith("-t"):
+                separator = arg[2:]
+            elif arg == "-a" and i + 1 < len(args):
+                i += 1
+                if args[i] == "1":
+                    print_unpaired_1 = True
+                elif args[i] == "2":
+                    print_unpaired_2 = True
+            elif arg == "-v" and i + 1 < len(args):
+                i += 1
+                if args[i] == "1":
+                    only_unpaired_1 = True
+                elif args[i] == "2":
+                    only_unpaired_2 = True
+            elif arg == "-e" and i + 1 < len(args):
+                i += 1
+                empty_replacement = args[i]
+            elif arg == "-o" and i + 1 < len(args):
+                i += 1
+                output_format = args[i]
+            elif arg in ("-i", "--ignore-case"):
+                ignore_case = True
+            elif arg == "--":
+                files.extend(args[i + 1:])
+                break
+            elif arg.startswith("-") and len(arg) > 1:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"join: invalid option -- '{arg[1]}'\n",
+                    exit_code=1,
+                )
+            else:
+                files.append(arg)
+            i += 1
+
+        if len(files) < 2:
+            return ExecResult(
+                stdout="",
+                stderr="join: 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"join: {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"join: {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._join(
+            lines1, lines2, field1, field2, separator, output_format,
+            print_unpaired_1, print_unpaired_2, only_unpaired_1, only_unpaired_2,
+            empty_replacement, ignore_case
+        )
+        return ExecResult(stdout=result, stderr="", exit_code=0)
+
+    def _join(
+        self,
+        lines1: list[str],
+        lines2: list[str],
+        field1: int,
+        field2: int,
+        separator: str | None,
+        output_format: str | None,
+        print_unpaired_1: bool,
+        print_unpaired_2: bool,
+        only_unpaired_1: bool,
+        only_unpaired_2: bool,
+        empty_replacement: str | None,
+        ignore_case: bool,
+    ) -> str:
+        """Join two lists of lines."""
+        sep = separator if separator else " "
+
+        # Parse lines into fields
+        def parse_line(line: str) -> list[str]:
+            if separator:
+                return line.split(separator)
+            return line.split()
+
+        def get_key(fields: list[str], field_num: int) -> str:
+            if field_num <= 0 or field_num > len(fields):
+                return ""
+            key = fields[field_num - 1]
+            return key.lower() if ignore_case else key
+
+        # Build index for file2
+        index2: dict[str, list[tuple[int, list[str]]]] = {}
+        for idx, line in enumerate(lines2):
+            fields = parse_line(line)
+            key = get_key(fields, field2)
+            if key not in index2:
+                index2[key] = []
+            index2[key].append((idx, fields))
+
+        result_lines = []
+        matched2 = set()
+
+        # Process file1
+        for line1 in lines1:
+            fields1 = parse_line(line1)
+            key1 = get_key(fields1, field1)
+
+            if key1 in index2:
+                for idx2, fields2 in index2[key1]:
+                    matched2.add(idx2)
+                    if not only_unpaired_1 and not only_unpaired_2:
+                        output = self._format_output(
+                            key1, fields1, fields2, field1, field2,
+                            sep, output_format, empty_replacement
+                        )
+                        result_lines.append(output)
+            else:
+                if print_unpaired_1 or only_unpaired_1:
+                    result_lines.append(sep.join(fields1))
+
+        # Print unmatched from file2
+        if print_unpaired_2 or only_unpaired_2:
+            for idx, line2 in enumerate(lines2):
+                if idx not in matched2:
+                    fields2 = parse_line(line2)
+                    result_lines.append(sep.join(fields2))
+
+        if result_lines:
+            return "\n".join(result_lines) + "\n"
+        return ""
+
+    def _format_output(
+        self,
+        key: str,
+        fields1: list[str],
+        fields2: list[str],
+        field1: int,
+        field2: int,
+        sep: str,
+        output_format: str | None,
+        empty_replacement: str | None,
+    ) -> str:
+        """Format the output line."""
+        if output_format:
+            # Parse output format like "1.1,2.2,1.3"
+            parts = []
+            for spec in output_format.split(","):
+                spec = spec.strip()
+                if spec == "0":
+                    parts.append(key)
+                elif "." in spec:
+                    file_num, field_num = spec.split(".")
+                    file_num = int(file_num)
+                    field_num = int(field_num)
+                    if file_num == 1:
+                        if field_num <= len(fields1):
+                            parts.append(fields1[field_num - 1])
+                        elif empty_replacement:
+                            parts.append(empty_replacement)
+                    elif file_num == 2:
+                        if field_num <= len(fields2):
+                            parts.append(fields2[field_num - 1])
+                        elif empty_replacement:
+                            parts.append(empty_replacement)
+            return sep.join(parts)
+        else:
+            # Default: key + other fields from both files
+            parts = [key]
+            for i, f in enumerate(fields1):
+                if i + 1 != field1:
+                    parts.append(f)
+            for i, f in enumerate(fields2):
+                if i + 1 != field2:
+                    parts.append(f)
+            return sep.join(parts)

just_bash/commands/jq/__init__.py

@@ -0,0 +1,5 @@
+"""Jq command implementation."""
+
+from .jq import JqCommand
+
+__all__ = ["JqCommand"]

just_bash/commands/jq/jq.py

@@ -0,0 +1,280 @@
+"""Jq command implementation.
+
+Usage: jq [OPTIONS] FILTER [FILE...]
+
+JSON processor using jq-style expressions.
+
+Options:
+  -r, --raw-output     output strings without quotes
+  -c, --compact        compact output (no pretty printing)
+  -s, --slurp          read all inputs into an array
+  -e                   exit with 1 if last output is false or null
+  -n, --null-input     don't read any input
+  -R, --raw-input      read each line as a string
+  -j, --join-output    no newlines between outputs
+  -S, --sort-keys      sort object keys alphabetically
+  --tab                use tabs for indentation
+  -a, --ascii-output   escape non-ASCII characters
+
+Filters:
+  .                   identity (output input unchanged)
+  .foo                object field access
+  .foo.bar            nested field access
+  .[N]                array index access
+  .[]                 array/object iterator
+  .[N:M]              array slice
+  |                   pipe (chain filters)
+  ,                   output multiple values
+  select(expr)        filter values
+  map(expr)           apply expression to each element
+  keys                get object keys
+  values              get object values
+  length              get length
+  type                get type name
+  empty               output nothing
+  add                 sum/concatenate
+  first, last         first/last element
+  reverse             reverse array
+  sort                sort array
+  unique              unique elements
+  flatten             flatten nested arrays
+  group_by(expr)      group by expression
+  min, max            minimum/maximum
+  has(key)            check if key exists
+  in(object)          check if key is in object
+  contains(x)         check if contains x
+  split(s)            split string by s
+  join(s)             join array by s
+  ascii_downcase      lowercase
+  ascii_upcase        uppercase
+  ltrimstr(s)         remove prefix
+  rtrimstr(s)         remove suffix
+  startswith(s)       check prefix
+  endswith(s)         check suffix
+  test(regex)         regex match
+  @base64             encode to base64
+  @base64d            decode from base64
+  @uri                URI encode
+  @csv                CSV format
+  @json               JSON encode
+  @text               convert to text
+"""
+
+import json
+from typing import Any
+from ...types import CommandContext, ExecResult
+from ...query_engine import parse, evaluate, EvalContext
+
+
+class JqCommand:
+    """The jq command."""
+
+    name = "jq"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the jq command."""
+        raw_output = False
+        compact = False
+        slurp = False
+        exit_on_false = False
+        null_input = False
+        raw_input = False
+        join_output = False
+        sort_keys = False
+        use_tabs = False
+        ascii_output = False
+        filter_str: str | None = 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 in ("-r", "--raw-output"):
+                raw_output = True
+            elif arg in ("-c", "--compact"):
+                compact = True
+            elif arg in ("-s", "--slurp"):
+                slurp = True
+            elif arg == "-e":
+                exit_on_false = True
+            elif arg in ("-n", "--null-input"):
+                null_input = True
+            elif arg in ("-R", "--raw-input"):
+                raw_input = True
+            elif arg in ("-j", "--join-output"):
+                join_output = True
+            elif arg in ("-S", "--sort-keys"):
+                sort_keys = True
+            elif arg == "--tab":
+                use_tabs = True
+            elif arg in ("-a", "--ascii-output"):
+                ascii_output = True
+            elif arg.startswith("-") and len(arg) > 1:
+                # Combined flags
+                for c in arg[1:]:
+                    if c == "r":
+                        raw_output = True
+                    elif c == "c":
+                        compact = True
+                    elif c == "s":
+                        slurp = True
+                    elif c == "e":
+                        exit_on_false = True
+                    elif c == "n":
+                        null_input = True
+                    elif c == "R":
+                        raw_input = True
+                    elif c == "j":
+                        join_output = True
+                    elif c == "S":
+                        sort_keys = True
+                    elif c == "a":
+                        ascii_output = True
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"jq: Unknown option: -{c}\n",
+                            exit_code=2,
+                        )
+            elif filter_str is None:
+                # First positional argument is the filter
+                filter_str = arg
+            else:
+                files.append(arg)
+            i += 1
+
+        # Default filter if none provided
+        if filter_str is None:
+            filter_str = "."
+
+        # Parse the filter using query engine
+        try:
+            ast = parse(filter_str)
+        except ValueError as e:
+            return ExecResult(
+                stdout="",
+                stderr=f"jq: {e}\n",
+                exit_code=2,
+            )
+
+        # Get input
+        inputs: list[Any] = []
+        stderr = ""
+
+        if null_input:
+            inputs = [None]
+        elif not files:
+            files = ["-"]
+
+        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)
+
+                if raw_input:
+                    # Each line is a string
+                    for line in content.split("\n"):
+                        if line:
+                            inputs.append(line)
+                else:
+                    # Parse JSON
+                    content = content.strip()
+                    if content:
+                        # Handle multiple JSON objects
+                        decoder = json.JSONDecoder()
+                        pos = 0
+                        while pos < len(content):
+                            # Skip whitespace
+                            while pos < len(content) and content[pos] in " \t\n\r":
+                                pos += 1
+                            if pos >= len(content):
+                                break
+                            try:
+                                obj, end = decoder.raw_decode(content, pos)
+                                inputs.append(obj)
+                                pos = end
+                            except json.JSONDecodeError as e:
+                                stderr += f"jq: parse error: {e}\n"
+                                break
+
+            except FileNotFoundError:
+                stderr += f"jq: error: {f}: No such file or directory\n"
+
+        if stderr:
+            return ExecResult(stdout="", stderr=stderr, exit_code=2)
+
+        # Apply slurp
+        if slurp and not null_input:
+            inputs = [inputs]
+
+        # Create evaluation context
+        eval_ctx = EvalContext(env=dict(ctx.env))
+
+        # Apply filter using query engine
+        outputs: list[Any] = []
+        for inp in inputs:
+            try:
+                results = evaluate(inp, ast, eval_ctx)
+                outputs.extend(results)
+            except Exception as e:
+                stderr += f"jq: error: {e}\n"
+
+        # Format output
+        output = ""
+        for val in outputs:
+            formatted = self._format_value(
+                val, raw_output, compact, sort_keys, use_tabs, ascii_output
+            )
+            if join_output:
+                output += formatted
+            else:
+                output += formatted + "\n"
+
+        # Determine exit code
+        exit_code = 0
+        if exit_on_false and outputs:
+            last = outputs[-1]
+            if last is None or last is False:
+                exit_code = 1
+
+        if stderr:
+            return ExecResult(stdout=output, stderr=stderr, exit_code=2)
+
+        return ExecResult(stdout=output, stderr="", exit_code=exit_code)
+
+    def _format_value(
+        self,
+        value: Any,
+        raw: bool,
+        compact: bool,
+        sort_keys: bool = False,
+        use_tabs: bool = False,
+        ascii_output: bool = False,
+    ) -> str:
+        """Format a value for output."""
+        if value is None:
+            return "null"
+        elif isinstance(value, bool):
+            return "true" if value else "false"
+        elif isinstance(value, str):
+            if raw:
+                return value
+            return json.dumps(value, ensure_ascii=ascii_output)
+        elif isinstance(value, (int, float)):
+            return json.dumps(value)
+        else:
+            indent_val = "\t" if use_tabs else (None if compact else 2)
+            return json.dumps(
+                value,
+                indent=indent_val,
+                separators=(",", ":") if compact else None,
+                sort_keys=sort_keys,
+                ensure_ascii=ascii_output,
+            )

just_bash/commands/ln/__init__.py

@@ -0,0 +1,5 @@
+"""Ln command implementation."""
+
+from .ln import LnCommand
+
+__all__ = ["LnCommand"]

just_bash/commands/ln/ln.py

@@ -0,0 +1,127 @@
+"""Ln command implementation.
+
+Usage: ln [OPTION]... TARGET LINK_NAME
+
+Create a link to TARGET with the name LINK_NAME.
+
+Options:
+  -s, --symbolic   make symbolic links instead of hard links
+  -f, --force      remove existing destination files
+  -v, --verbose    print name of each linked file
+"""
+
+from ...types import CommandContext, ExecResult
+
+
+class LnCommand:
+    """The ln command."""
+
+    name = "ln"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the ln command."""
+        symbolic = False
+        force = 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 == "--symbolic":
+                    symbolic = True
+                elif arg == "--force":
+                    force = True
+                elif arg == "--verbose":
+                    verbose = True
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"ln: unrecognized option '{arg}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-") and arg != "-":
+                for c in arg[1:]:
+                    if c == "s":
+                        symbolic = True
+                    elif c == "f":
+                        force = True
+                    elif c == "v":
+                        verbose = True
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"ln: 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="ln: missing file operand\n",
+                    exit_code=1,
+                )
+            return ExecResult(
+                stdout="",
+                stderr=f"ln: missing destination file operand after '{paths[0]}'\n",
+                exit_code=1,
+            )
+
+        target = paths[0]
+        link_name = paths[1]
+
+        target_path = ctx.fs.resolve_path(ctx.cwd, target)
+        link_path = ctx.fs.resolve_path(ctx.cwd, link_name)
+
+        stdout = ""
+        stderr = ""
+        exit_code = 0
+
+        try:
+            # For hard links, target must exist
+            if not symbolic:
+                try:
+                    await ctx.fs.stat(target_path)
+                except FileNotFoundError:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"ln: failed to access '{target}': No such file or directory\n",
+                        exit_code=1,
+                    )
+
+            # Remove existing link if force
+            if force:
+                try:
+                    await ctx.fs.rm(link_path, recursive=False, force=True)
+                except (FileNotFoundError, IsADirectoryError):
+                    pass
+
+            # Create the link
+            if symbolic:
+                await ctx.fs.symlink(target, link_path)
+            else:
+                await ctx.fs.link(target_path, link_path)
+
+            if verbose:
+                stdout += f"'{link_name}' -> '{target}'\n"
+
+        except FileExistsError:
+            stderr += f"ln: failed to create {'symbolic ' if symbolic else ''}link '{link_name}': File exists\n"
+            exit_code = 1
+        except FileNotFoundError:
+            stderr += f"ln: failed to create {'symbolic ' if symbolic else ''}link '{link_name}': No such file or directory\n"
+            exit_code = 1
+        except OSError as e:
+            stderr += f"ln: failed to create link: {e}\n"
+            exit_code = 1
+
+        return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)

just_bash/commands/ls/__init__.py

@@ -0,0 +1,5 @@
+"""Ls command implementation."""
+
+from .ls import LsCommand
+
+__all__ = ["LsCommand"]