just-bash 0.1.5__py3-none-any.whl

just_bash/commands/cut/__init__.py

@@ -0,0 +1,5 @@
+"""Cut command implementation."""
+
+from .cut import CutCommand
+
+__all__ = ["CutCommand"]

just_bash/commands/cut/cut.py

@@ -0,0 +1,327 @@
+"""Cut command implementation.
+
+Usage: cut OPTION... [FILE]...
+
+Print selected parts of lines from each FILE to standard output.
+
+Options:
+  -b, --bytes=LIST       select only these bytes
+  -c, --characters=LIST  select only these characters
+  -d, --delimiter=DELIM  use DELIM instead of TAB for field delimiter
+  -f, --fields=LIST      select only these fields
+  -s, --only-delimited   do not print lines not containing delimiters
+  --output-delimiter=STRING  use STRING as the output delimiter
+
+LIST is made up of one range, or many ranges separated by commas.
+Each range is one of:
+  N     N'th byte, character or field, counted from 1
+  N-    from N'th byte, character or field, to end of line
+  N-M   from N'th to M'th byte, character or field
+  -M    from first to M'th byte, character or field
+"""
+
+from ...types import CommandContext, ExecResult
+
+
+class CutCommand:
+    """The cut command."""
+
+    name = "cut"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the cut command."""
+        byte_list = ""
+        char_list = ""
+        field_list = ""
+        delimiter = "\t"
+        output_delimiter = None
+        only_delimited = False
+        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.startswith("--bytes="):
+                    byte_list = arg[8:]
+                elif arg.startswith("--characters="):
+                    char_list = arg[13:]
+                elif arg.startswith("--delimiter="):
+                    delimiter = arg[12:]
+                    if len(delimiter) != 1:
+                        return ExecResult(
+                            stdout="",
+                            stderr="cut: the delimiter must be a single character\n",
+                            exit_code=1,
+                        )
+                elif arg.startswith("--fields="):
+                    field_list = arg[9:]
+                elif arg == "--only-delimited":
+                    only_delimited = True
+                elif arg.startswith("--output-delimiter="):
+                    output_delimiter = arg[19:]
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"cut: unrecognized option '{arg}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-") and arg != "-":
+                j = 1
+                while j < len(arg):
+                    c = arg[j]
+                    if c == "b":
+                        # -b requires a value
+                        if j + 1 < len(arg):
+                            byte_list = arg[j + 1:]
+                            break
+                        elif i + 1 < len(args):
+                            i += 1
+                            byte_list = args[i]
+                            break
+                        else:
+                            return ExecResult(
+                                stdout="",
+                                stderr="cut: option requires an argument -- 'b'\n",
+                                exit_code=1,
+                            )
+                    elif c == "c":
+                        # -c requires a value
+                        if j + 1 < len(arg):
+                            char_list = arg[j + 1:]
+                            break
+                        elif i + 1 < len(args):
+                            i += 1
+                            char_list = args[i]
+                            break
+                        else:
+                            return ExecResult(
+                                stdout="",
+                                stderr="cut: option requires an argument -- 'c'\n",
+                                exit_code=1,
+                            )
+                    elif c == "d":
+                        # -d requires a value
+                        if j + 1 < len(arg):
+                            delimiter = arg[j + 1:]
+                            break
+                        elif i + 1 < len(args):
+                            i += 1
+                            delimiter = args[i]
+                            break
+                        else:
+                            return ExecResult(
+                                stdout="",
+                                stderr="cut: option requires an argument -- 'd'\n",
+                                exit_code=1,
+                            )
+                        if len(delimiter) != 1:
+                            return ExecResult(
+                                stdout="",
+                                stderr="cut: the delimiter must be a single character\n",
+                                exit_code=1,
+                            )
+                    elif c == "f":
+                        # -f requires a value
+                        if j + 1 < len(arg):
+                            field_list = arg[j + 1:]
+                            break
+                        elif i + 1 < len(args):
+                            i += 1
+                            field_list = args[i]
+                            break
+                        else:
+                            return ExecResult(
+                                stdout="",
+                                stderr="cut: option requires an argument -- 'f'\n",
+                                exit_code=1,
+                            )
+                    elif c == "s":
+                        only_delimited = True
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"cut: invalid option -- '{c}'\n",
+                            exit_code=1,
+                        )
+                    j += 1
+            else:
+                files.append(arg)
+            i += 1
+
+        # Validate - need exactly one of -b, -c, or -f
+        modes = sum([bool(byte_list), bool(char_list), bool(field_list)])
+        if modes == 0:
+            return ExecResult(
+                stdout="",
+                stderr="cut: you must specify a list of bytes, characters, or fields\n",
+                exit_code=1,
+            )
+        if modes > 1:
+            return ExecResult(
+                stdout="",
+                stderr="cut: only one type of list may be specified\n",
+                exit_code=1,
+            )
+
+        # Parse the list
+        try:
+            if byte_list:
+                ranges = self._parse_list(byte_list)
+                mode = "bytes"
+            elif char_list:
+                ranges = self._parse_list(char_list)
+                mode = "chars"
+            else:
+                ranges = self._parse_list(field_list)
+                mode = "fields"
+        except ValueError as e:
+            return ExecResult(
+                stdout="",
+                stderr=f"cut: {e}\n",
+                exit_code=1,
+            )
+
+        # Set output delimiter
+        if output_delimiter is None:
+            output_delimiter = delimiter
+
+        # Default to stdin
+        if not files:
+            files = ["-"]
+
+        stdout = ""
+        stderr = ""
+        exit_code = 0
+
+        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)
+
+                lines = content.split("\n")
+                # Remove trailing empty line if present
+                if lines and lines[-1] == "":
+                    lines = lines[:-1]
+
+                for line in lines:
+                    if mode == "fields":
+                        result = self._cut_fields(line, ranges, delimiter, output_delimiter, only_delimited)
+                    else:
+                        result = self._cut_chars(line, ranges)
+
+                    if result is not None:
+                        stdout += result + "\n"
+
+            except FileNotFoundError:
+                stderr += f"cut: {f}: No such file or directory\n"
+                exit_code = 1
+
+        return ExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)
+
+    def _parse_list(self, list_str: str) -> list[tuple[int, int | None]]:
+        """Parse a list specification into ranges.
+
+        Returns list of (start, end) tuples. end=None means to end of line.
+        Indices are 0-based internally.
+        """
+        ranges: list[tuple[int, int | None]] = []
+
+        for part in list_str.split(","):
+            part = part.strip()
+            if not part:
+                continue
+
+            if "-" in part:
+                if part.startswith("-"):
+                    # -M: from start to M
+                    try:
+                        end = int(part[1:])
+                        ranges.append((0, end))
+                    except ValueError:
+                        raise ValueError(f"invalid byte, character or field list: {list_str}")
+                elif part.endswith("-"):
+                    # N-: from N to end
+                    try:
+                        start = int(part[:-1])
+                        if start < 1:
+                            raise ValueError(f"fields and positions are numbered from 1")
+                        ranges.append((start - 1, None))
+                    except ValueError:
+                        raise ValueError(f"invalid byte, character or field list: {list_str}")
+                else:
+                    # N-M
+                    parts = part.split("-", 1)
+                    try:
+                        start = int(parts[0])
+                        end = int(parts[1])
+                        if start < 1:
+                            raise ValueError(f"fields and positions are numbered from 1")
+                        ranges.append((start - 1, end))
+                    except ValueError:
+                        raise ValueError(f"invalid byte, character or field list: {list_str}")
+            else:
+                # Single number
+                try:
+                    n = int(part)
+                    if n < 1:
+                        raise ValueError(f"fields and positions are numbered from 1")
+                    ranges.append((n - 1, n))
+                except ValueError:
+                    raise ValueError(f"invalid byte, character or field list: {list_str}")
+
+        return ranges
+
+    def _cut_chars(self, line: str, ranges: list[tuple[int, int | None]]) -> str:
+        """Cut characters/bytes from a line."""
+        result_chars: list[str] = []
+        included = set()
+
+        for start, end in ranges:
+            if end is None:
+                end = len(line)
+            for i in range(start, min(end, len(line))):
+                if i not in included:
+                    included.add(i)
+                    result_chars.append((i, line[i]))
+
+        # Sort by position and extract chars
+        result_chars.sort(key=lambda x: x[0])
+        return "".join(c for _, c in result_chars)
+
+    def _cut_fields(
+        self,
+        line: str,
+        ranges: list[tuple[int, int | None]],
+        delimiter: str,
+        output_delimiter: str,
+        only_delimited: bool,
+    ) -> str | None:
+        """Cut fields from a line."""
+        if delimiter not in line:
+            if only_delimited:
+                return None
+            return line
+
+        fields = line.split(delimiter)
+        result_fields: list[tuple[int, str]] = []
+        included = set()
+
+        for start, end in ranges:
+            if end is None:
+                end = len(fields)
+            for i in range(start, min(end, len(fields))):
+                if i not in included:
+                    included.add(i)
+                    result_fields.append((i, fields[i]))
+
+        # Sort by position and extract fields
+        result_fields.sort(key=lambda x: x[0])
+        return output_delimiter.join(f for _, f in result_fields)

just_bash/commands/date/__init__.py

@@ -0,0 +1,5 @@
+"""Date command implementation."""
+
+from .date import DateCommand
+
+__all__ = ["DateCommand"]

just_bash/commands/date/date.py

@@ -0,0 +1,258 @@
+"""Date command implementation.
+
+Usage: date [OPTION]... [+FORMAT]
+
+Display the current time in the given FORMAT.
+
+Options:
+  -d, --date=STRING   display time described by STRING
+  -u, --utc           print Coordinated Universal Time (UTC)
+  -I, --iso-8601      output date/time in ISO 8601 format
+  -R, --rfc-email     output date and time in RFC 5322 format
+
+FORMAT controls the output. Common sequences:
+  %a  abbreviated weekday name (Sun..Sat)
+  %A  full weekday name (Sunday..Saturday)
+  %b  abbreviated month name (Jan..Dec)
+  %B  full month name (January..December)
+  %d  day of month (01..31)
+  %H  hour (00..23)
+  %I  hour (01..12)
+  %j  day of year (001..366)
+  %m  month (01..12)
+  %M  minute (00..59)
+  %p  AM or PM
+  %S  second (00..60)
+  %Y  year
+  %Z  timezone name
+  %z  +hhmm numeric timezone
+  %F  full date; same as %Y-%m-%d
+  %T  time; same as %H:%M:%S
+  %s  seconds since 1970-01-01 00:00:00 UTC
+  %%  a literal %
+"""
+
+from datetime import datetime, timezone
+from ...types import CommandContext, ExecResult
+
+
+class DateCommand:
+    """The date command."""
+
+    name = "date"
+
+    async def execute(self, args: list[str], ctx: CommandContext) -> ExecResult:
+        """Execute the date command."""
+        date_string = None
+        use_utc = False
+        iso_format = False
+        rfc_format = False
+        format_str = None
+
+        # Parse arguments
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg.startswith("--"):
+                if arg == "--utc" or arg == "--universal":
+                    use_utc = True
+                elif arg.startswith("--date="):
+                    date_string = arg[7:]
+                elif arg == "--iso-8601":
+                    iso_format = True
+                elif arg == "--rfc-email" or arg == "--rfc-2822":
+                    rfc_format = True
+                else:
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"date: unrecognized option '{arg}'\n",
+                        exit_code=1,
+                    )
+            elif arg.startswith("-") and arg != "-":
+                j = 1
+                while j < len(arg):
+                    c = arg[j]
+                    if c == "u":
+                        use_utc = True
+                    elif c == "d":
+                        # -d requires a value
+                        if j + 1 < len(arg):
+                            date_string = arg[j + 1:]
+                            break
+                        elif i + 1 < len(args):
+                            i += 1
+                            date_string = args[i]
+                            break
+                        else:
+                            return ExecResult(
+                                stdout="",
+                                stderr="date: option requires an argument -- 'd'\n",
+                                exit_code=1,
+                            )
+                    elif c == "I":
+                        iso_format = True
+                    elif c == "R":
+                        rfc_format = True
+                    else:
+                        return ExecResult(
+                            stdout="",
+                            stderr=f"date: invalid option -- '{c}'\n",
+                            exit_code=1,
+                        )
+                    j += 1
+            elif arg.startswith("+"):
+                format_str = arg[1:]
+            else:
+                return ExecResult(
+                    stdout="",
+                    stderr=f"date: invalid date '{arg}'\n",
+                    exit_code=1,
+                )
+            i += 1
+
+        # Get the datetime
+        try:
+            if date_string:
+                dt = self._parse_date_string(date_string)
+            else:
+                dt = datetime.now()
+
+            if use_utc:
+                dt = dt.astimezone(timezone.utc)
+        except ValueError as e:
+            return ExecResult(
+                stdout="",
+                stderr=f"date: invalid date '{date_string}'\n",
+                exit_code=1,
+            )
+
+        # Format output
+        if iso_format:
+            output = dt.strftime("%Y-%m-%dT%H:%M:%S%z")
+            if not output.endswith("Z") and len(output) > 5 and output[-5] in "+-":
+                # Insert colon in timezone offset
+                output = output[:-2] + ":" + output[-2:]
+        elif rfc_format:
+            output = dt.strftime("%a, %d %b %Y %H:%M:%S %z")
+        elif format_str:
+            output = self._format_date(dt, format_str)
+        else:
+            # Default format
+            output = dt.strftime("%a %b %d %H:%M:%S %Z %Y")
+            if not output.strip():
+                output = dt.strftime("%a %b %d %H:%M:%S UTC %Y")
+
+        return ExecResult(stdout=output + "\n", stderr="", exit_code=0)
+
+    def _parse_date_string(self, s: str) -> datetime:
+        """Parse a date string."""
+        s = s.strip()
+
+        # Handle special keywords
+        if s.lower() == "now":
+            return datetime.now()
+        if s.lower() == "today":
+            return datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+        if s.lower() == "yesterday":
+            from datetime import timedelta
+            return (datetime.now() - timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
+        if s.lower() == "tomorrow":
+            from datetime import timedelta
+            return (datetime.now() + timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
+
+        # Try ISO format
+        for fmt in [
+            "%Y-%m-%dT%H:%M:%S%z",
+            "%Y-%m-%dT%H:%M:%S",
+            "%Y-%m-%d %H:%M:%S",
+            "%Y-%m-%d",
+            "%m/%d/%Y",
+            "%d %b %Y",
+            "%b %d %Y",
+        ]:
+            try:
+                return datetime.strptime(s, fmt)
+            except ValueError:
+                continue
+
+        # Try parsing as Unix timestamp
+        try:
+            ts = float(s)
+            return datetime.fromtimestamp(ts)
+        except ValueError:
+            pass
+
+        raise ValueError(f"Unable to parse date: {s}")
+
+    def _format_date(self, dt: datetime, fmt: str) -> str:
+        """Format a date using strftime-like codes."""
+        result = ""
+        i = 0
+        while i < len(fmt):
+            if fmt[i] == "%" and i + 1 < len(fmt):
+                code = fmt[i + 1]
+                if code == "%":
+                    result += "%"
+                elif code == "a":
+                    result += dt.strftime("%a")
+                elif code == "A":
+                    result += dt.strftime("%A")
+                elif code == "b":
+                    result += dt.strftime("%b")
+                elif code == "B":
+                    result += dt.strftime("%B")
+                elif code == "d":
+                    result += dt.strftime("%d")
+                elif code == "D":
+                    result += dt.strftime("%m/%d/%y")
+                elif code == "e":
+                    result += f"{dt.day:2d}"
+                elif code == "F":
+                    result += dt.strftime("%Y-%m-%d")
+                elif code == "H":
+                    result += dt.strftime("%H")
+                elif code == "I":
+                    result += dt.strftime("%I")
+                elif code == "j":
+                    result += dt.strftime("%j")
+                elif code == "m":
+                    result += dt.strftime("%m")
+                elif code == "M":
+                    result += dt.strftime("%M")
+                elif code == "n":
+                    result += "\n"
+                elif code == "p":
+                    result += dt.strftime("%p")
+                elif code == "P":
+                    result += dt.strftime("%p").lower()
+                elif code == "S":
+                    result += dt.strftime("%S")
+                elif code == "s":
+                    result += str(int(dt.timestamp()))
+                elif code == "t":
+                    result += "\t"
+                elif code == "T":
+                    result += dt.strftime("%H:%M:%S")
+                elif code == "u":
+                    # Day of week (1=Monday, 7=Sunday)
+                    result += str(dt.isoweekday())
+                elif code == "w":
+                    # Day of week (0=Sunday, 6=Saturday)
+                    result += str((dt.weekday() + 1) % 7)
+                elif code == "W":
+                    result += dt.strftime("%W")
+                elif code == "Y":
+                    result += dt.strftime("%Y")
+                elif code == "y":
+                    result += dt.strftime("%y")
+                elif code == "z":
+                    result += dt.strftime("%z") or "+0000"
+                elif code == "Z":
+                    result += dt.strftime("%Z") or "UTC"
+                else:
+                    result += "%" + code
+                i += 2
+            else:
+                result += fmt[i]
+                i += 1
+        return result

just_bash/commands/diff/__init__.py

@@ -0,0 +1,5 @@
+"""Diff command."""
+
+from .diff import DiffCommand
+
+__all__ = ["DiffCommand"]