tina4-python 3.13.127__tar.gz → 3.13.129__tar.gz

{tina4_python-3.13.127 → tina4_python-3.13.129}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tina4-python
-Version: 3.13.127
+Version: 3.13.129
 Summary: Tina4 Python v3 — Zero-dependency, lightweight web framework
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.13.127 → tina4_python-3.13.129}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.13.127"
+version = "3.13.129"
 description = "Tina4 Python v3 — Zero-dependency, lightweight web framework"
 authors = [
     {name = "Andre van Zuydam", email = "andrevanzuydam@gmail.com"}
@@ -105,7 +105,6 @@ dev = [
     "pytest-asyncio>=0.23",
     "pytest-cov>=5.0",
     "reportlab>=4.4.10",
-    "ruff>=0.4",
     "setuptools>=82.0.1",
     "uvicorn>=0.42.0",
 ]

{tina4_python-3.13.127 → tina4_python-3.13.129}/tina4_python/__init__.py

@@ -51,7 +51,7 @@ def _resolve_version() -> str:
     #
     # test_version_constant.py now asserts this literal equals the pyproject
     # version, so the release bump cannot leave it behind again.
-    return "3.13.125"
+    return "3.13.129"
 
 
 __version__ = _resolve_version()

{tina4_python-3.13.127 → tina4_python-3.13.129}/tina4_python/cli/__init__.py

@@ -95,6 +95,46 @@ def _to_table(name: str) -> str:
     return table
 
 
+def _resolve_table(name: str, flags: dict | None = None, *, announce: bool = False) -> str:
+    """The table name a generator uses, honouring ``--table-name`` and speaking up
+    instead of renaming silently.
+
+    ``announce`` prints the note/warning; it is True only for ``_gen_model`` (where
+    the table is born). Composite generators (crud) let the model sub-call
+    announce, and generators that target an EXISTING table (route/seeder/form/view)
+    still honour ``--table-name`` but stay quiet so the note is not repeated.
+
+    * ``--table-name <name>`` wins verbatim. If that name is ITSELF a reserved
+      word, warn loudly: Tina4 interpolates table names UNQUOTED, so the ORM's
+      generated SQL will fail on it and quoting it in raw SQL + migrations is now
+      the developer's job (we do not silently quote -- identifier quoting is a
+      global storage invariant, not a local fix).
+    * Otherwise fall back to :func:`_to_table`. When that auto-pluralises a
+      reserved-word class name (``Order`` -> ``orders``), print a one-line note
+      naming the rename and the ``--table-name`` escape hatch, so the developer is
+      informed rather than surprised.
+
+    Called once per generate (``_gen_model`` threads the result into the migration
+    and test), so the note prints once.
+    """
+    flags = flags or {}
+    override = flags.get("table-name")
+    if override and not isinstance(override, bool):
+        if announce and _to_snake(override) in SQL_RESERVED_TABLE_NAMES:
+            print(f"  ! table_name '{override}' is a SQL reserved word. Tina4 interpolates "
+                  f"table names UNQUOTED, so the ORM's generated SQL will fail on it -- "
+                  f"quote it yourself in raw SQL and migrations.")
+        return override
+    bare = _to_snake(name)
+    if bare in SQL_RESERVED_TABLE_NAMES:
+        table = _pluralize_table(bare)
+        if announce:
+            print(f"  · '{bare}' is a SQL reserved word; using table_name '{table}' "
+                  f"(Tina4 interpolates table names unquoted). Override with --table-name <name>.")
+        return table
+    return bare
+
+
 def _parse_fields(fields_str: str) -> list[tuple[str, str]]:
     """Parse 'name:string,price:float' → [('name','string'), ('price','float')]."""
     if not fields_str or not fields_str.strip():
@@ -129,7 +169,7 @@ def _parse_flags(args: list[str]) -> tuple[dict, list[str]]:
     """Parse --key value and --flag from args. Returns (flags, positional)."""
     # Boolean-only flags that never take a value argument
     boolean_flags = {"no-browser", "no-reload", "no-kill", "production", "managed", "all", "clear",
-                     "json", "public", "no-migration", "once", "dry-run", "quote"}
+                     "json", "public", "no-migration", "once", "dry-run", "fix", "no-install"}
 
     flags = {}
     positional = []
@@ -927,6 +967,103 @@ def _test(args):
     sys.exit(1 if (inline_failed or pytest_code) else 0)
 
 
+def _resolve_ruff(root: Path):
+    """Locate the PROJECT's own ruff and return its command prefix (a list), or
+    None. Only the project virtualenv is consulted (where ``uv add --dev ruff``
+    puts it), on POSIX and Windows layouts -- deliberately NOT a global ruff on
+    PATH: linting must be reproducible from the project's own pinned dev
+    dependency, and a global tool is not the project's choice. When the project
+    has none, the caller installs it dev-only rather than borrowing a stray
+    global one (which would also make a global install non-deterministic)."""
+    for candidate in (root / ".venv" / "bin" / "ruff", root / ".venv" / "Scripts" / "ruff.exe"):
+        if candidate.is_file():
+            return [str(candidate)]
+    return None
+
+
+def _lint(args):
+    """Lint the project's source. The framework ships NO linter (so a Tina4 app
+    stays zero-dependency); ``tina4 lint`` uses the project's own ``ruff`` and
+    INSTALLS it as a DEV dependency on demand when it is absent. Layers:
+
+    * **ruff present** (on PATH or in the project ``.venv``): run it. ``--fix``
+      runs ``ruff check --fix`` (safe autofixes). ruff reports syntax too, so it
+      is the whole pass when present.
+    * **ruff absent:** silently ``uv add --dev ruff`` -- running ``tina4 lint`` is
+      the consent to add it -- then run it. It lands in the DEV group only, never
+      the app's runtime dependencies. ``--no-install`` skips this.
+    * **Baseline (zero dependency):** the built-in ``compile()`` syntax parse --
+      no execution, no ``.pyc``, no dependency. Used with ``--no-install`` or when
+      the install cannot run (no ``uv`` on PATH, offline).
+
+    Contract (identical across all four frameworks): exit 0 = clean, non-zero =
+    findings; the summary names the tool that ran. Scope is the user's app
+    (``src/`` + ``app.py``), mirroring how ``tina4 test`` runs the project's own
+    tests -- not the framework's code.
+
+        tina4 lint               # ruff (installed dev-only on demand), else baseline
+        tina4 lint --fix         # ruff --fix
+        tina4 lint --no-install  # ruff if already present, else the syntax baseline
+    """
+    flags, _ = _parse_flags(list(args))
+    fix = bool(flags.get("fix"))
+    no_install = bool(flags.get("no-install"))
+    root = Path.cwd()
+
+    py_files = []
+    src = root / "src"
+    if src.is_dir():
+        py_files.extend(sorted(src.rglob("*.py")))
+    if (root / "app.py").is_file():
+        py_files.append(root / "app.py")
+    if not py_files:
+        print("  lint: nothing to lint (no src/ or app.py).")
+        sys.exit(0)
+
+    ruff = _resolve_ruff(root)
+
+    # Silent on-demand install: running `tina4 lint` is the consent to add ruff
+    # as a DEV dependency of the project. --no-install opts out (CI / offline) and
+    # falls through to the zero-dependency baseline. Needs `uv` on PATH.
+    if not ruff and not no_install and shutil.which("uv"):
+        print("  · ruff not found -- adding it as a dev dependency (uv add --dev ruff)...")
+        rc = subprocess.run(["uv", "add", "--dev", "ruff"]).returncode
+        if rc == 0:
+            ruff = _resolve_ruff(root)
+        else:
+            print("  · could not install ruff -- using the zero-dependency syntax baseline.")
+
+    if ruff:
+        cmd = ruff + ["check"] + (["--fix"] if fix else []) + [str(p) for p in py_files]
+        code = subprocess.run(cmd).returncode
+        label = "ruff --fix" if fix else "ruff"
+        if code != 0:
+            print(f"  ✗ lint failed -- {len(py_files)} file(s) [{label}]")
+            sys.exit(1)
+        print(f"  ✓ lint clean -- {len(py_files)} file(s) [{label}]")
+        sys.exit(0)
+
+    # Zero-dependency baseline: built-in compile() syntax parse. No execution,
+    # no bytecode written, no dependency added.
+    if fix:
+        print("  · syntax baseline has no autofix (--no-install, or ruff unavailable).")
+    syntax_errors = 0
+    for pf in py_files:
+        try:
+            compile(pf.read_text(encoding="utf-8", errors="ignore"), str(pf), "exec")
+        except SyntaxError as exc:
+            print(f"  ✗ {pf.relative_to(root)}:{exc.lineno}: {exc.msg}")
+            syntax_errors += 1
+        except OSError as exc:
+            print(f"  ✗ {pf.relative_to(root)}: cannot read ({exc})")
+            syntax_errors += 1
+    if syntax_errors:
+        print(f"  ✗ lint failed -- {syntax_errors} syntax error(s) in {len(py_files)} file(s) [compile]")
+        sys.exit(1)
+    print(f"  ✓ lint clean -- {len(py_files)} file(s) [compile, syntax only]")
+    sys.exit(0)
+
+
 def _build(args):
     """Build the deployable Docker image for this Tina4 app.
 
@@ -1176,7 +1313,7 @@ def _resolve_generation(target: str, name: str, flags: dict,
 
     if target == "model":
         raw_table = _to_snake(name)
-        table = _to_table(name)
+        table = _resolve_table(name, flags)
         transformations = []
         if raw_table in SQL_RESERVED_TABLE_NAMES and raw_table != table:
             transformations.append({
@@ -1185,8 +1322,8 @@ def _resolve_generation(target: str, name: str, flags: dict,
                 "to": table,
                 "reason": f"SQL reserved word '{raw_table}' would break CREATE TABLE",
                 "override": (
-                    f"--table {raw_table} --quote (requires quoted-identifier "
-                    "mode, not yet implemented)"
+                    "--table-name <name> (table names interpolate unquoted; "
+                    "forcing a reserved name is yours to quote in raw SQL)"
                 ),
             })
         migration_filename = f"{ts}_create_{table}.sql"
@@ -1340,11 +1477,11 @@ def _format_resolution_block(name: str, target: str, resolution: dict,
 
     if pluralize:
         lines.append("")
-        lines.append(f"  To keep the raw name '{pluralize['from']}' as the table:")
+        lines.append("  To set the table name yourself:")
+        lines.append(f"    tina4 generate {target} {name} --table-name <name>")
         lines.append(
-            f"    tina4 generate {target} {name} "
-            f"--table {pluralize['from']} --quote  "
-            "(opt-in, ADR-0062 forthcoming)"
+            f"  Tina4 interpolates table names unquoted; if you force the "
+            f"reserved '{pluralize['from']}', you own the quoting in raw SQL."
         )
 
     # ADR-0063 additive sections. Each renders only when there is content, so
@@ -1540,7 +1677,7 @@ def _gen_model(name: str, flags: dict, *, emit_test: bool = True):
     and emit their own broader test instead.
     """
     fields = _fields_or_default(flags.get("fields", ""))
-    table = _to_table(name)
+    table = _resolve_table(name, flags, announce=True)
 
     # Determine which ORM field types we need to import
     used_types = {"IntegerField"}  # always need for id
@@ -1822,7 +1959,7 @@ def _gen_crud(name: str, flags: dict):
     tina4python generate crud Product --fields "name:string,price:float"
     """
     fields = _fields_or_default(flags.get("fields", ""))
-    table = _to_table(name)
+    table = _resolve_table(name, flags)
     route_name = table + "s"  # routes are plural
 
     print(f"\n  Generating CRUD for {name}...\n")
@@ -2920,7 +3057,7 @@ def _gen_seeder(name: str, flags: dict = None):
 
     tina4python generate seeder Product
     """
-    table = _to_table(name)
+    table = _resolve_table(name, flags)
     target = Path("src/seeds")
     target.mkdir(parents=True, exist_ok=True)
     path = target / f"{table}_seeder.py"
@@ -3096,7 +3233,7 @@ def _gen_form(name: str, flags: dict = None):
     """
     flags = flags or {}
     fields = _fields_or_default(flags.get("fields", ""))
-    table = _to_table(name)
+    table = _resolve_table(name, flags)
     route_name = table + "s"
 
     # Input type mapping
@@ -3180,7 +3317,7 @@ def _gen_view(name: str, flags: dict = None):
     """
     flags = flags or {}
     fields = _fields_or_default(flags.get("fields", ""))
-    table = _to_table(name)
+    table = _resolve_table(name, flags)
     route_name = table + "s"
 
     target = Path("src/templates/pages")
@@ -3725,7 +3862,7 @@ def _commands(args=None):
 #                       "subcommands"?: [str]}  # sub-names for the manifest (generate)
 
 GENERATORS = {
-    "model":      {"handler": _gen_model,      "usage": '<Name> [--fields "name:string,price:float"]', "summary": "ORM model + matching migration"},
+    "model":      {"handler": _gen_model,      "usage": '<Name> [--fields "name:string,price:float"] [--table-name <name>]', "summary": "ORM model + matching migration"},
     "route":      {"handler": _gen_route,      "usage": "<name> [--model Name] [--public]",            "summary": "CRUD route file, secure by default (--public opens writes)"},
     "crud":       {"handler": _gen_crud,       "usage": '<Name> [--fields "..."] [--public]',          "summary": "Model + migration + routes + form + view + test"},
     "migration":  {"handler": _gen_migration,  "usage": "<description>",                               "summary": "Timestamped migration file (UP/DOWN)"},
@@ -3756,6 +3893,7 @@ COMMANDS = {
     "test":             {"handler": _test,             "summary": "Run test suite"},
     "queue":            {"handler": _queue,            "usage": "<work|stats|retry|clear> [topic]", "subcommands": list(_QUEUE_SUBCOMMANDS), "summary": "Run queue workers and manage jobs"},
     "build":            {"handler": _build,            "usage": "[--tag NAME] [--file PATH]", "summary": "Build the deployable Docker image"},
+    "lint":             {"handler": _lint,             "usage": "[--fix] [--no-install]", "summary": "Lint src/ + app.py (installs ruff dev-only on demand; zero-dep syntax baseline with --no-install)"},
     "ai":               {"handler": _ai,               "usage": "[--all]", "summary": "Install AI coding assistant context"},
     "generate":         {"handler": _generate,         "usage": "<what> <name> [options]", "subcommands": list(GENERATORS), "summary": "Generate scaffolding (see Generators below)"},
     "console":          {"handler": _console,          "summary": "Start interactive REPL with framework loaded"},