tina4ruby 3.13.127 → 3.13.129

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0765c0228c99d3b8d5e26124c0afe5079ccc9ac675a3f067fc38e2e829bded7f
-  data.tar.gz: 6134c34d7f1ea98ea558862e1f98dbb0532b2d6fb3156b8bad5b9e129e362475
+  metadata.gz: e0792f247e0fc7d10a52db84896d8cd475d509e258a1b121b06564e45cfa3913
+  data.tar.gz: 91ecd21265adabfd4874596c68b63f10c36bab1cb39fd49c4be4b0db1d8ec289
 SHA512:
-  metadata.gz: '0979843fa3654d0c48c62c19bbc8e5615a7b4b582286e14b3c517b76f3d9a50eb3246feb125b365b071c2c76adf7cdcbf93f802a576d75e5959d337cd19543c0'
-  data.tar.gz: f5ba6720f96dee12b2b7d751282fba8835771a11b368afafd64bf311c9ca1d8bf8501fd3b28493dd42126dfb0b4159a4c50a407422d5b8f63b680b7b67dbe038
+  metadata.gz: a464c761ff621eeb3a10068a1ad436fe1b71d1403792885a07442b1f8dc475d80c1f64736e3a456c2a71edd72c0fee6fabd215e8fb61e6eb543e2d2b02531831
+  data.tar.gz: 86c6e9cb683134790b85159c797225c3bb8d126fe8fbc1d0bfc8d0f3aeaf1dfcf781b5a21ae4d8cf414c04875726a32db98cc5cfd12b87b10603e815d805e17a

data/lib/tina4/cli.rb

@@ -6,6 +6,7 @@ require "set"
 require "json"
 require "tmpdir"    # Dir.mktmpdir — used by the ADR-0063 sandbox edit-hint scan
 require "stringio"  # StringIO — captures generator stdout during the sandbox run
+require "open3"     # Open3.capture2e — captures `ruby -c` output+status for `lint`
 require_relative "port_takeover"
 
 module Tina4
@@ -29,7 +30,7 @@ module Tina4
     # handlers take (name, flags); COMMANDS handlers take (argv).
 
     GENERATORS = {
-      "model"      => { handler: :generate_model,      usage: '<Name> [--fields "name:string,price:float"]', summary: "ORM model + matching migration" },
+      "model"      => { handler: :generate_model,      usage: '<Name> [--fields "name:string,price:float"] [--table-name <name>]', summary: "ORM model + matching migration" },
       "route"      => { handler: :generate_route,      usage: "<name> [--model Name] [--public]",             summary: "CRUD route file, secure by default (--public opens writes)" },
       "crud"       => { handler: :generate_crud,       usage: '<Name> [--fields "..."] [--public]',           summary: "Model + migration + routes + form + view + test" },
       "migration"  => { handler: :generate_migration,  usage: "<description>",                                 summary: "Timestamped migration file (UP/DOWN)" },
@@ -70,6 +71,7 @@ module Tina4
       "test"             => { handler: :cmd_test,                                                          summary: "Run inline tests" },
       "queue"            => { handler: :cmd_queue,            usage: "<work|stats|retry|clear> [topic]", subcommands: QUEUE_SUBCOMMANDS.keys, summary: "Run queue workers and manage jobs" },
       "build"            => { handler: :cmd_build,            usage: "[--tag NAME] [--file PATH]",         summary: "Build the deployable Docker image" },
+      "lint"             => { handler: :cmd_lint,             usage: "[--fix] [--no-install]",             summary: "Lint src/ + app.rb (rubocop, installed dev-only on demand, else ruby -c)" },
       "version"          => { handler: :cmd_version,                                                       summary: "Show Tina4 version" },
       "routes"           => { handler: :cmd_routes,                                                        summary: "List all registered routes" },
       "console"          => { handler: :cmd_console,                                                       summary: "Start an interactive console" },
@@ -282,6 +284,52 @@ module Tina4
       pluralize_table(to_snake_case(name))
     end
 
+    # The table name a generator uses, honouring `--table-name` and speaking up
+    # instead of renaming silently (issue #123). Mirrors `_resolve_table` in
+    # tina4-python/tina4_python/cli/__init__.py:98.
+    #
+    # `announce` prints the note/warning; it is TRUE only for `generate_model`
+    # (where the table is born). Composite generators (crud) let the model
+    # sub-call announce, and generators that target an EXISTING table
+    # (seeder/form/view) still honour `--table-name` but stay quiet so the note
+    # is not repeated. `build_model_resolution` calls it with announce:false too,
+    # so the envelope's table_name/migration_path equal what lands on disk.
+    #
+    # * `--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 `to_table_name`. 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.
+    def resolve_table(name, flags = {}, announce: false)
+      flags ||= {}
+      override = flags["table-name"]
+      # A real value only — a bare `--table-name` parses to `true` and an empty
+      # `--table-name ""` to "", both of which fall through to the pluralise path
+      # (parity with Python's `if override and not isinstance(override, bool)`).
+      if override.is_a?(String) && !override.empty?
+        if announce && SQL_RESERVED_TABLE_NAMES.include?(to_snake_case(override))
+          puts "  ! table_name '#{override}' is a SQL reserved word. Tina4 interpolates " \
+               "table names UNQUOTED, so the ORM's generated SQL will fail on it -- " \
+               "quote it yourself in raw SQL and migrations."
+        end
+        return override
+      end
+      bare = to_snake_case(name)
+      if SQL_RESERVED_TABLE_NAMES.include?(bare)
+        table = pluralize_table(bare)
+        if announce
+          puts "  · '#{bare}' is a SQL reserved word; using table_name '#{table}' " \
+               "(Tina4 interpolates table names unquoted). Override with --table-name <name>."
+        end
+        return table
+      end
+      bare
+    end
+
     # Called without --fields, the generators fall back to a single `name`
     # string column. That default MUST be materialised here, in one place, and
     # then flow into the model, the migration, the form, the view and the spec
@@ -516,7 +564,7 @@ module Tina4
     # Parse --key value and --flag from args. Returns [flags_hash, positional_array]
     def parse_flags(args)
       # Boolean-only flags that never take a value argument
-      boolean_flags = %w[no-browser no-reload production managed all clear dev json public no-migration once dry-run]
+      boolean_flags = %w[no-browser no-reload production managed all clear dev json public no-migration once dry-run fix no-install]
 
       flags = {}
       positional = []
@@ -1206,6 +1254,126 @@ module Tina4
       puts "  Run: docker run -p 7147:7147 #{tag}"
     end
 
+    # ── lint ──────────────────────────────────────────────────────────────
+    #
+    # Lint the project's source. The framework ships NO linter (so a Tina4 app
+    # stays zero-dependency); `tina4ruby lint` uses the project's own rubocop and
+    # INSTALLS it as a DEV dependency on demand when it is absent. Layers:
+    #
+    #   * rubocop present (bundled via the project Gemfile, or on PATH): run it.
+    #     `--fix` runs `rubocop -a` (safe autocorrect). rubocop reports syntax
+    #     too, so it is the whole pass when present.
+    #   * rubocop absent: silently `bundle add rubocop --group development` --
+    #     running `tina4ruby lint` is the consent to add it -- then run it. It
+    #     lands in the development group only, never the app's runtime
+    #     dependencies. `--no-install` skips this.
+    #   * Baseline (zero dependency): the built-in `ruby -c` syntax parse -- no
+    #     execution, nothing written, no dependency. Used with `--no-install` or
+    #     when the install cannot run (no bundler/Gemfile, offline).
+    #
+    # Contract (identical across all four frameworks): exit 0 = clean, non-zero =
+    # findings; the summary names the tool that ran in [brackets]. Scope is the
+    # user's app (`src/` recursively + `app.rb`), mirroring how `tina4ruby test`
+    # runs the project's own specs -- not the framework's code. Ruby mirror of
+    # the Python master's `_lint` (tina4-python/tina4_python/cli/__init__.py).
+    #
+    #   tina4ruby lint            # rubocop (installed dev-only on demand), else baseline
+    #   tina4ruby lint --fix      # rubocop -a
+    #   tina4ruby lint --no-install  # rubocop if already present, else the syntax baseline
+    def cmd_lint(argv)
+      flags, _positional = parse_flags(argv)
+      fix = flags["fix"] == true
+      no_install = flags["no-install"] == true
+
+      rb_files = []
+      rb_files.concat(Dir.glob(File.join("src", "**", "*.rb")).sort) if File.directory?("src")
+      rb_files << "app.rb" if File.file?("app.rb")
+
+      if rb_files.empty?
+        puts "  lint: nothing to lint (no src/ or app.rb)."
+        exit 0
+      end
+
+      rubocop = resolve_rubocop
+
+      # Silent on-demand install: running `tina4ruby lint` is the consent to add
+      # rubocop as a DEV dependency of the project. --no-install opts out (CI /
+      # offline) and falls through to the zero-dependency baseline. Needs bundler
+      # AND a Gemfile to mutate.
+      if rubocop.nil? && !no_install
+        bundle = which_executable("bundle")
+        if bundle && File.file?("Gemfile")
+          puts "  · rubocop not found -- adding it as a dev dependency (bundle add rubocop --group development)..."
+          if system(bundle, "add", "rubocop", "--group", "development")
+            rubocop = resolve_rubocop
+          else
+            puts "  · could not install rubocop -- using the zero-dependency syntax baseline."
+          end
+        end
+      end
+
+      if rubocop
+        label = fix ? "rubocop -a" : "rubocop"
+        command = rubocop + (fix ? ["-a"] : []) + rb_files
+        ok = system(*command)   # inherits stdio — rubocop prints its own report
+        if ok
+          puts "  ✓ lint clean -- #{rb_files.length} file(s) [#{label}]"
+          exit 0
+        end
+        puts "  ✗ lint failed -- #{rb_files.length} file(s) [#{label}]"
+        exit 1
+      end
+
+      # Zero-dependency baseline: the built-in `ruby -c` syntax parse. No
+      # execution, nothing written, no dependency added.
+      puts "  · syntax baseline has no autofix (--no-install, or rubocop unavailable)." if fix
+
+      syntax_errors = 0
+      rb_files.each do |rel|
+        output, status = Open3.capture2e("ruby", "-c", rel)
+        next if status.success?   # "Syntax OK"
+
+        syntax_errors += 1
+        # `ruby -c` names the file+line in its first diagnostic line
+        # (e.g. "ruby: src/broken.rb:2: syntax errors found (SyntaxError)"); drop
+        # the redundant leading "ruby: " so the shape matches the Python master's
+        # "file:lineno: msg".
+        first_line = output.strip.sub(/\Aruby:\s*/, "").lines.first.to_s.rstrip
+        first_line = "#{rel}: syntax error" if first_line.empty?
+        puts "  ✗ #{first_line}"
+      end
+
+      if syntax_errors.positive?
+        puts "  ✗ lint failed -- #{syntax_errors} syntax error(s) in #{rb_files.length} file(s) [ruby -c]"
+        exit 1
+      end
+      puts "  ✓ lint clean -- #{rb_files.length} file(s) [ruby -c, syntax only]"
+      exit 0
+    end
+
+    # Resolve a runnable rubocop for the rich lint pass. Returns the argv PREFIX
+    # to invoke it (`[<bundle>, "exec", "rubocop"]` when the project's Gemfile
+    # bundles it — the version the project pins — or `[<rubocop-path>]` on PATH),
+    # or nil to fall back to the `ruby -c` baseline. Mirrors the Python master's
+    # `_resolve_ruff` (resolve the project's OWN linter). The bundler probe
+    # (`bundle exec rubocop --version`) is a REAL resolve check: exit 0 only when
+    # the gem is actually in the bundle. Bundler is preferred over a bare PATH
+    # rubocop because inside a bundled project the pinned version is the correct
+    # one (and a bare `rubocop` may trip Bundler's "not part of the bundle").
+    def resolve_rubocop
+      # Only the PROJECT's own bundled rubocop counts -- linting must be
+      # reproducible from the project's pinned dev dependency, NOT a stray global
+      # rubocop on PATH (which would also make the on-demand install
+      # non-deterministic: a global tool would preempt it). When the project has
+      # none, the caller installs it dev-only via `bundle add`.
+      bundle = which_executable("bundle")
+      if bundle && File.file?("Gemfile") &&
+         system(bundle, "exec", "rubocop", "--version", out: File::NULL, err: File::NULL)
+        return [bundle, "exec", "rubocop"]
+      end
+      nil
+    end
+
     # Locate an executable on PATH — the stdlib-only equivalent of Python's
     # shutil.which (no new gem). Honours PATHEXT on Windows.
     def which_executable(cmd)
@@ -1494,21 +1662,19 @@ module Tina4
 
     def build_model_resolution(name, flags)
       raw = to_snake_case(name)
+      # Honour --table-name (silent here; generate_model announces). The envelope
+      # thus reports the SAME table_name/migration_path the generator writes.
+      table = resolve_table(name, flags)
       transformations = []
-      table =
-        if SQL_RESERVED_TABLE_NAMES.include?(raw)
-          plural = pluralize_table(raw)
-          transformations << {
-            "kind"     => "reserved_word_pluralize",
-            "from"     => raw,
-            "to"       => plural,
-            "reason"   => "SQL reserved word '#{raw}' would break CREATE TABLE",
-            "override" => "--table #{raw} --quote (requires quoted-identifier mode, not yet implemented)"
-          }
-          plural
-        else
-          raw
-        end
+      if SQL_RESERVED_TABLE_NAMES.include?(raw) && raw != table
+        transformations << {
+          "kind"     => "reserved_word_pluralize",
+          "from"     => raw,
+          "to"       => table,
+          "reason"   => "SQL reserved word '#{raw}' would break CREATE TABLE",
+          "override" => "--table-name <name> (table names interpolate unquoted; forcing a reserved name is yours to quote in raw SQL)"
+        }
+      end
       # The migration filename embeds a timestamp; predict it deterministically
       # so a `--dry-run` and the real run agree on the same second. Two
       # generations within the same second collide anyway (existing behaviour).
@@ -1675,8 +1841,9 @@ module Tina4
       pluralized = resolution["transformations"].find { |t| t["kind"] == "reserved_word_pluralize" }
       if pluralized
         lines << ""
-        lines << "  To keep the raw name '#{pluralized['from']}' as the table:"
-        lines << "    tina4ruby generate #{target} #{name} --table #{pluralized['from']} --quote  (opt-in, ADR-0062 forthcoming)"
+        lines << "  To set the table name yourself:"
+        lines << "    tina4ruby generate #{target} #{name} --table-name <name>"
+        lines << "  Tina4 interpolates table names unquoted; if you force the reserved '#{pluralized['from']}', you own the quoting in raw SQL."
       end
       # ADR-0063 v1.1: surface `edit_hints[]` under "Edit these lines:" and
       # `next[]` under "Next:" — both additive; missing / empty arrays elide
@@ -1725,7 +1892,9 @@ module Tina4
 
     def generate_model(name, flags, emit_test: true)
       fields = fields_or_default(flags["fields"])
-      table = to_table_name(name)
+      # announce: this is where the table is born, so a reserved-word pluralise
+      # (Order -> orders) or a forced reserved --table-name speaks up (#123).
+      table = resolve_table(name, flags, announce: true)
       snake = to_snake_case(name)
 
       # Build field lines
@@ -1971,7 +2140,8 @@ module Tina4
     # ── Generator: crud ──────────────────────────────────────────────────
 
     def generate_crud(name, flags)
-      table = to_table_name(name)
+      # Quiet here — the generate_model sub-call below announces once (#123).
+      table = resolve_table(name, flags)
       # Always derive the plural route from the CLASS NAME, not by appending
       # "s" to the table — otherwise a reserved-word table (already plural,
       # Order -> orders) becomes orderss, and a `y`-ending class (Category)
@@ -2300,7 +2470,8 @@ module Tina4
 
     def generate_form(name, flags = {})
       fields = fields_or_default(flags["fields"])
-      table = to_table_name(name)
+      # Targets an existing table — honour --table-name but stay quiet (#123).
+      table = resolve_table(name, flags)
       route_name = to_route_name(name)
 
       # Input type mapping
@@ -2383,7 +2554,8 @@ module Tina4
 
     def generate_view(name, flags = {})
       fields = fields_or_default(flags["fields"])
-      table = to_table_name(name)
+      # Targets an existing table — honour --table-name but stay quiet (#123).
+      table = resolve_table(name, flags)
       route_name = to_route_name(name)
 
       cols = fields.map { |f, _| f }
@@ -2816,7 +2988,8 @@ module Tina4
     #
     #   tina4ruby generate seeder Product
     def generate_seeder(name, flags = {})
-      table = to_table_name(name)
+      # Targets an existing table — honour --table-name but stay quiet (#123).
+      table = resolve_table(name, flags)
       model_snake = to_snake_case(name)
       dir = "seeds"
       FileUtils.mkdir_p(dir)

data/lib/tina4/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tina4
-  VERSION = "3.13.127"
+  VERSION = "3.13.129"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.127
+  version: 3.13.129
 platform: ruby
 authors:
 - Tina4 Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-29 00:00:00.000000000 Z
+date: 2026-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -276,20 +276,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.12'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.50'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.50'
 - !ruby/object:Gem::Dependency
   name: openapi3_parser
   requirement: !ruby/object:Gem::Requirement