tina4ruby 3.13.126 → 3.13.128

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f56bea80e9f63a3326a77f8903721890f45a2db216f39c24fe51c1363e0514b9
-  data.tar.gz: 61dd38932bcfb406abb603232dd584889223408888d3ca7aaa469775243727b7
+  metadata.gz: 63a254da7848fb136bf9c014d3ac291c31b9046ee2ad7bd40222189f5d8e031b
+  data.tar.gz: e9a23c45ec6b6c3ff46125454259447e743ffe6097a7866f486c6b5a8cc5aaad
 SHA512:
-  metadata.gz: d6ca97a0dcb6adf6776f89be49871d814b678a3d499d8ec740a6b87516af474f04d1e78d2c8746a113aa8877c2b3fcceec4ebd2f9d3cc02b2f4fd0accc63d095
-  data.tar.gz: 5c86231d8853e00c5cbbdf22a6ea02d477eed2fe045306c498ed1b82eff9ba5bc9c1e301b53f99a394f82731001c56503615206d566e2266b6e4208c2d64aecb
+  metadata.gz: dd3e42f53f1515ddfb137cd6713a11650309d4da359030cecde6be6368cad5309175b04943b25fa8bc5349e6b8505c2231a128b7de3c905c7a5605bf4d71c454
+  data.tar.gz: 81c929c2b3b06ce99682c440e1ce6385cb2bda7d836638e158fd0c0d2bcc41526eb7b7e055159c9aeab38468a16843d05b77b57f76beec525dab16ccc8cf9dec

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
@@ -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" },
@@ -516,7 +518,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 +1208,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)

data/lib/tina4/drivers/firebird_driver.rb

@@ -230,18 +230,24 @@ module Tina4
         rows.map { |row| decode_blobs(symbolize_keys(row)) }
       end
 
-      def execute(sql, params = [])
-        # Translate SQLite-canonical DDL to Firebird at APPLY time, mirroring the
-        # Python master's firebird.py _translate_sql: strip AUTOINCREMENT (Firebird
-        # uses generators), then rewrite the types Firebird rejects -- TEXT ->
-        # BLOB SUB_TYPE TEXT (-607), REAL -> DOUBLE PRECISION -- and drop
-        # CREATE TABLE IF NOT EXISTS. Both helpers only touch DDL keywords
-        # (AUTOINCREMENT / CREATE TABLE / ALTER TABLE), so a plain
-        # INSERT/UPDATE/DELETE/SELECT is returned untouched. This is what lets a
-        # REALLY-generated migration (id INTEGER PRIMARY KEY AUTOINCREMENT,
-        # bio TEXT, price REAL) apply on Firebird instead of raising -607/-104.
+      # Translate SQLite-canonical SQL to Firebird at APPLY time, mirroring the
+      # Python master's firebird.py _translate_sql: strip AUTOINCREMENT (Firebird
+      # uses generators), bare TRUE/FALSE -> 1/0 (Firebird has no boolean type; a
+      # TRUE/FALSE INSIDE a string literal is data and is left untouched), rewrite
+      # the types Firebird rejects -- TEXT -> BLOB SUB_TYPE TEXT (-607), REAL ->
+      # DOUBLE PRECISION -- and drop CREATE TABLE IF NOT EXISTS. Every helper only
+      # touches DDL keywords or bare boolean tokens, so a plain
+      # INSERT/UPDATE/DELETE/SELECT is returned untouched. This is what lets a
+      # REALLY-generated migration (id INTEGER PRIMARY KEY AUTOINCREMENT,
+      # bio TEXT, price REAL) apply on Firebird instead of raising -607/-104.
+      def translate_sql(sql)
         sql = Tina4::SQLTranslator.auto_increment_syntax(sql, "firebird")
-        sql = Tina4::SQLTranslator.ddl_types(sql, "firebird")
+        sql = Tina4::SQLTranslator.boolean_to_int(sql)
+        Tina4::SQLTranslator.ddl_types(sql, "firebird")
+      end
+
+      def execute(sql, params = [])
+        sql = translate_sql(sql)
         result = with_reconnect do
           if params.empty?
             @connection.execute(sql)

data/lib/tina4/drivers/mssql_driver.rb

@@ -58,15 +58,21 @@ module Tina4
         rows
       end
 
-      def execute(sql, params = [])
-        # Translate SQLite-canonical DDL to T-SQL at APPLY time, mirroring the
-        # Python master's mssql.py _translate_sql: AUTOINCREMENT -> IDENTITY(1,1),
-        # then strip CREATE TABLE IF NOT EXISTS (not T-SQL) and map TIMESTAMP ->
-        # DATETIME2 (MSSQL's TIMESTAMP is a rowversion, not a datetime). Both
-        # helpers only touch DDL keywords, so DML is returned untouched -- this is
-        # what lets a REALLY-generated migration apply on MSSQL.
+      # Translate SQLite-canonical SQL to T-SQL at APPLY time, mirroring the
+      # Python master's mssql.py _translate_sql: AUTOINCREMENT -> IDENTITY(1,1),
+      # bare TRUE/FALSE -> 1/0 (MSSQL has BIT, not a boolean type; a TRUE/FALSE
+      # INSIDE a string literal is data and is left untouched), strip CREATE TABLE
+      # IF NOT EXISTS (not T-SQL) and map TIMESTAMP -> DATETIME2 (MSSQL's TIMESTAMP
+      # is a rowversion). Every helper only touches DDL keywords or bare boolean
+      # tokens, so a plain INSERT/UPDATE/DELETE/SELECT is returned untouched.
+      def translate_sql(sql)
         sql = Tina4::SQLTranslator.auto_increment_syntax(sql, "mssql")
-        sql = Tina4::SQLTranslator.ddl_types(sql, "mssql")
+        sql = Tina4::SQLTranslator.boolean_to_int(sql)
+        Tina4::SQLTranslator.ddl_types(sql, "mssql")
+      end
+
+      def execute(sql, params = [])
+        sql = translate_sql(sql)
         effective_sql = interpolate_params(sql, params)
 
         # Capture the generated IDENTITY AT WRITE TIME — mirror of the Python

data/lib/tina4/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.126
+  version: 3.13.128
 platform: ruby
 authors:
 - Tina4 Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-29 00:00:00.000000000 Z
+date: 2026-08-31 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