flow-toon-format 0.9.0b2__py3-none-any.whl

toon_format/cli.py

@@ -0,0 +1,217 @@
+# Copyright (c) 2025 TOON Format Organization
+# SPDX-License-Identifier: MIT
+"""Command-line interface for TOON encoding/decoding.
+
+Provides the `toon` command-line tool for converting between JSON and TOON formats.
+Supports auto-detection based on file extensions and content, with options for
+delimiters, indentation, and validation modes.
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from . import decode, encode
+from .types import DecodeOptions, EncodeOptions
+
+
+def main() -> int:
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        prog="toon",
+        description="Convert between JSON and TOON formats",
+    )
+
+    parser.add_argument(
+        "input",
+        type=str,
+        help="Input file path (or - for stdin)",
+    )
+
+    parser.add_argument(
+        "-o",
+        "--output",
+        type=str,
+        help="Output file path (prints to stdout if omitted)",
+    )
+
+    parser.add_argument(
+        "-e",
+        "--encode",
+        action="store_true",
+        help="Force encode mode (overrides auto-detection)",
+    )
+
+    parser.add_argument(
+        "-d",
+        "--decode",
+        action="store_true",
+        help="Force decode mode (overrides auto-detection)",
+    )
+
+    parser.add_argument(
+        "--delimiter",
+        type=str,
+        choices=[",", "\t", "|"],
+        default=",",
+        help='Array delimiter: , (comma), \\t (tab), | (pipe) (default: ",")',
+    )
+
+    parser.add_argument(
+        "--indent",
+        type=int,
+        default=2,
+        help="Indentation size (default: 2)",
+    )
+
+    parser.add_argument(
+        "--length-marker",
+        action="store_true",
+        help="Add # prefix to array lengths (e.g., items[#3])",
+    )
+
+    parser.add_argument(
+        "--no-strict",
+        action="store_true",
+        help="Disable strict validation when decoding",
+    )
+
+    args = parser.parse_args()
+
+    # Read input
+    try:
+        if args.input == "-":
+            input_text = sys.stdin.read()
+            input_path = None
+        else:
+            input_path = Path(args.input)
+            if not input_path.exists():
+                print(f"Error: Input file not found: {args.input}", file=sys.stderr)
+                return 1
+            input_text = input_path.read_text(encoding="utf-8")
+    except Exception as e:
+        print(f"Error reading input: {e}", file=sys.stderr)
+        return 1
+
+    # Determine operation mode
+    if args.encode and args.decode:
+        print("Error: Cannot specify both --encode and --decode", file=sys.stderr)
+        return 1
+
+    if args.encode:
+        mode = "encode"
+    elif args.decode:
+        mode = "decode"
+    else:
+        # Auto-detect based on file extension
+        if input_path:
+            if input_path.suffix.lower() == ".json":
+                mode = "encode"
+            elif input_path.suffix.lower() == ".toon":
+                mode = "decode"
+            else:
+                # Try to detect by content
+                try:
+                    json.loads(input_text)
+                    mode = "encode"
+                except json.JSONDecodeError:
+                    mode = "decode"
+        else:
+            # No file path, try to detect by content
+            try:
+                json.loads(input_text)
+                mode = "encode"
+            except json.JSONDecodeError:
+                mode = "decode"
+
+    # Process
+    try:
+        if mode == "encode":
+            output_text = encode_json_to_toon(
+                input_text,
+                delimiter=args.delimiter,
+                indent=args.indent,
+                length_marker=args.length_marker,
+            )
+        else:
+            output_text = decode_toon_to_json(
+                input_text,
+                indent=args.indent,
+                strict=not args.no_strict,
+            )
+    except Exception as e:
+        print(f"Error during {mode}: {e}", file=sys.stderr)
+        return 1
+
+    # Write output
+    try:
+        if args.output:
+            output_path = Path(args.output)
+            output_path.write_text(output_text, encoding="utf-8")
+        else:
+            print(output_text)
+    except Exception as e:
+        print(f"Error writing output: {e}", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+def encode_json_to_toon(
+    json_text: str,
+    delimiter: str = ",",
+    indent: int = 2,
+    length_marker: bool = False,
+) -> str:
+    """Encode JSON text to TOON format.
+
+    Args:
+        json_text: JSON input string
+        delimiter: Delimiter character
+        indent: Indentation size
+        length_marker: Whether to add # prefix
+
+    Returns:
+        TOON-formatted string
+
+    Raises:
+        json.JSONDecodeError: If JSON is invalid
+    """
+    data = json.loads(json_text)
+
+    options: EncodeOptions = {
+        "indent": indent,
+        "delimiter": delimiter,
+        "lengthMarker": "#" if length_marker else False,
+    }
+
+    return encode(data, options)
+
+
+def decode_toon_to_json(
+    toon_text: str,
+    indent: int = 2,
+    strict: bool = True,
+) -> str:
+    """Decode TOON text to JSON format.
+
+    Args:
+        toon_text: TOON input string
+        indent: Indentation size
+        strict: Whether to use strict validation
+
+    Returns:
+        JSON-formatted string
+
+    Raises:
+        ToonDecodeError: If TOON is invalid
+    """
+    options = DecodeOptions(indent=indent, strict=strict)
+    data = decode(toon_text, options)
+
+    return json.dumps(data, indent=2, ensure_ascii=False)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

toon_format/constants.py

@@ -0,0 +1,84 @@
+# Copyright (c) 2025 TOON Format Organization
+# SPDX-License-Identifier: MIT
+"""Constants for TOON format encoding and decoding.
+
+Defines all string literals, characters, and configuration values used throughout
+the TOON implementation. Centralizes magic values for maintainability.
+"""
+
+from typing import TYPE_CHECKING, Dict
+
+if TYPE_CHECKING:
+    from .types import Delimiter
+
+# region List markers
+LIST_ITEM_MARKER = "-"
+LIST_ITEM_PREFIX = "- "
+# endregion
+
+# region Structural characters
+COMMA: "Delimiter" = ","
+COLON = ":"
+SPACE = " "
+PIPE: "Delimiter" = "|"
+# endregion
+
+# region Brackets and braces
+OPEN_BRACKET = "["
+CLOSE_BRACKET = "]"
+OPEN_BRACE = "{"
+CLOSE_BRACE = "}"
+# endregion
+
+# region Literals
+NULL_LITERAL = "null"
+TRUE_LITERAL = "true"
+FALSE_LITERAL = "false"
+# endregion
+
+# region Escape characters
+BACKSLASH = "\\"
+DOUBLE_QUOTE = '"'
+NEWLINE = "\n"
+CARRIAGE_RETURN = "\r"
+TAB: "Delimiter" = "\t"
+# endregion
+
+# region Delimiters
+DELIMITERS: Dict[str, "Delimiter"] = {
+    "comma": COMMA,
+    "tab": TAB,
+    "pipe": PIPE,
+}
+
+DEFAULT_DELIMITER: "Delimiter" = DELIMITERS["comma"]
+# endregion
+
+# region Regex patterns
+# Pattern strings are compiled in modules that use them
+STRUCTURAL_CHARS_REGEX = r"[\[\]{}]"
+CONTROL_CHARS_REGEX = r"[\n\r\t]"
+NUMERIC_REGEX = r"^-?\d+(?:\.\d+)?(?:e[+-]?\d+)?$"
+OCTAL_REGEX = r"^0\d+$"
+VALID_KEY_REGEX = r"^[A-Z_][\w.]*$"
+HEADER_LENGTH_REGEX = r"^#?(\d+)([\|\t])?$"
+INTEGER_REGEX = r"^-?\d+$"
+# endregion
+
+# region Escape sequence maps
+ESCAPE_SEQUENCES = {
+    BACKSLASH: "\\\\",
+    DOUBLE_QUOTE: '\\"',
+    NEWLINE: "\\n",
+    CARRIAGE_RETURN: "\\r",
+    TAB: "\\t",
+}
+
+UNESCAPE_SEQUENCES = {
+    "n": NEWLINE,
+    "r": CARRIAGE_RETURN,
+    "t": TAB,
+    "\\": BACKSLASH,
+    '"': DOUBLE_QUOTE,
+}
+# endregion