tina4ruby 3.13.139 → 3.13.140

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49ef08b44463d47d804c054dce8bb194276945134a618369e9d951ce239fd4cb
-  data.tar.gz: 69b761361564c42e91584a7029fcd5fb067d2d3dc9103614f37662a7a17be707
+  metadata.gz: 68bda3e81c456588a9a4db6501cb402b1eaa570d5f2bfbee0efb83bd9cb61beb
+  data.tar.gz: 61271a97c34bf49f68fcaf605d955d6e4f932f72fa370c884f4f0e91ef432e91
 SHA512:
-  metadata.gz: c7db9c5c8d7c0242fdbb2e3a7b43b80b5567d46443a3b029e7e546daf4b8f6eb508b7671ae077e3a661e8f07bf15e0ba809fe9e5259e5bb7117ee67afc35828d
-  data.tar.gz: 975471f353c0f9804bc7678e9f2bafdd8f47d7eb44f50d54347ea08454b8560fc15b3bb8c740851cef08926a28f349e7a8121c5c09e7ca90f4e9a797f418ad0d
+  metadata.gz: 847b4f0439265406da7152292469d91b081a04e468f177b78980c9b669c96e60cca17ac06820bbdb5c66034802145ff64b294c7949136e2392236575170aeb3e
+  data.tar.gz: f690d2726ce41de740e44b6db7cc0cd3104ac40cace6c30dc5a4a94eef832f7e09128608b9cfaebf6e167687403917ca14c156d5f4b94bd65b8c46930d191bce

data/CHANGELOG.md

@@ -6,6 +6,25 @@ number means the same thing everywhere.
 **The authoritative release notes for every shipped version live in the documentation:**
 https://tina4.com/ruby/36-releases
 
+## 3.13.140 — 2026-09-28
+
+A housekeeping release that tightens the guards and dedups the SQLite plumbing. The CLAUDE.md doc-drift gate now watches this repo, so a doc that names a Tina4 method the code no longer has fails loudly instead of drifting on quietly. The SQLite path resolver learnt some manners: an escaping relative path is refused, and it creates the parent folders itself at 0775 (ADR-0086). The framework still carries no required runtime dependencies.
+
+### Fixes
+- SQLite refuses a relative path that escapes the project and creates its parent directories at 0775, hardening ADR-0086.
+- The maintainer skills stale check resolves correctly and warns when an addGlobal closure would go stale (skill bugs 90/91).
+
+### Refactors
+- The SQLite `resolve_path` logic moves into one shared `SqlitePathResolver` module, so every caller reads the same path the same way.
+- `symbolize_rows` and `symbolize_keys` collapse into one shared module, characterised first so the behaviour cannot shift.
+
+### Docs
+- The Web Push skill mirrors sync back to the `.claude` canonical, so the two copies agree.
+
+### CI
+- A CLAUDE.md doc-drift gate lands, the tina4-js rtc.md mirror syncs, and the SQLTranslator doc drift is fixed.
+- The CLI crud generator locks in single pluralisation, so an `Order` model becomes `orders`, never `orderss`.
+
 ## 3.13.139
 
 Outbound requests from the Api client and Web Push are guarded against SSRF: private, loopback and link-local targets are refused unless explicitly allowed (ADR-0084). The development admin surface is hardened -- the health endpoint no longer discloses the framework version outside debug, and development binds loopback by default (ADR-0078). Production refuses to boot with a blank or short HMAC secret so tokens cannot be forged (ADR-0079). Queue reject() dead-letters immediately and size("dead") reports the dead-letter depth (ADR-0022, ADR-0023). Session table first-use is concurrency-safe across every engine. Mail encryption follows the configured TLS/STARTTLS contract (ADR-0071). Log output, driver-install hints and WSDL/mail diagnostics redact credentials and URLs. Publishing is gated behind a protected environment with release actions pinned by commit SHA, and a medium-severity API token-leak path is closed. The framework still has no required runtime dependencies.

data/lib/tina4/database/sqlite3_adapter.rb

@@ -7,10 +7,16 @@
 
 
 require_relative "../sqlite3_gem"
+require_relative "../sqlite_path_resolver"
+require_relative "../row_symbolizer"
 
 module Tina4
   module Adapters
     class Sqlite3Adapter
+      # Shared SQLite path resolution — one home for both SQLite resolvers.
+      extend Tina4::SqlitePathResolver
+      include Tina4::RowSymbolizer
+
       attr_reader :connection, :db_path
 
       def initialize(connection_string = nil)
@@ -30,32 +36,6 @@ module Tina4
         self
       end
 
-      # Resolve a SQLite URL / path against the project root (cwd).
-      # Convention matches Tina4::Drivers::SqliteDriver.resolve_path —
-      # three slashes = relative, four = absolute, drive letter = Windows abs.
-      def self.resolve_path(connection_string)
-        return ":memory:" if connection_string == "sqlite::memory:" || connection_string == "sqlite:///:memory:"
-
-        raw = connection_string.to_s
-          .sub(/^sqlite3?:\/\/\//, "")
-          .sub(/^sqlite3?:\/\//, "")
-          .sub(/^sqlite3?:/, "")
-        return ":memory:" if raw == ":memory:"
-
-        is_windows_abs = raw.match?(/^[A-Za-z]:[\/\\]/)
-        is_unix_abs    = raw.start_with?("/")
-
-        if is_windows_abs || is_unix_abs
-          raw
-        else
-          resolved = File.join(Dir.pwd, raw)
-          parent = File.dirname(resolved)
-          require "fileutils"
-          FileUtils.mkdir_p(parent) unless File.directory?(parent)
-          resolved
-        end
-      end
-
       def close
         @connection.close if @connection
         @connection = nil
@@ -163,34 +143,6 @@ module Tina4
       def apply_limit(sql, limit, offset = 0)
         "#{sql}\nLIMIT #{limit} OFFSET #{offset}"
       end
-
-      private
-
-      # Symbolize a whole result set's keys, computing the mapping ONCE per query
-      # rather than per cell. See the matching helper in drivers/sqlite_driver.rb
-      # for the rationale: the per-row form ran k.to_s.to_sym for every cell, so a
-      # 5,000-row x 6-column fetch did 30,000 conversions for 6 distinct keys. The
-      # is_a? guard still drops any positional Integer keys older gems emit.
-      def symbolize_rows(rows)
-        return rows if rows.empty?
-
-        str_keys = rows.first.keys.select { |k| k.is_a?(String) || k.is_a?(Symbol) }
-        sym_keys = str_keys.map(&:to_sym)
-        count = str_keys.length
-        rows.map do |row|
-          out = {}
-          i = 0
-          while i < count
-            out[sym_keys[i]] = row[str_keys[i]]
-            i += 1
-          end
-          out
-        end
-      end
-
-      def symbolize_keys(hash)
-        symbolize_rows([hash]).first
-      end
     end
   end
 end

data/lib/tina4/drivers/sqlite_driver.rb

@@ -8,11 +8,17 @@
 
 require_relative "schema_split"
 require_relative "../sqlite3_gem"
+require_relative "../sqlite_path_resolver"
+require_relative "../row_symbolizer"
 
 module Tina4
   module Drivers
     class SqliteDriver
+      # Shared SQLite path resolution — one home for both SQLite resolvers.
+      extend Tina4::SqlitePathResolver
+
       include Tina4::DatabaseAdapter
+      include Tina4::RowSymbolizer
       include SchemaSplit
       attr_reader :connection
 
@@ -51,50 +57,6 @@ module Tina4
         @connection.execute("PRAGMA foreign_keys=ON")
       end
 
-      # Resolve a SQLite URL / path against the project root (cwd).
-      #
-      # Convention (matches tina4-python, tina4-php, tina4-nodejs):
-      #   sqlite::memory:              → :memory:
-      #   sqlite:///:memory:           → :memory:
-      #   sqlite:///app.db             → {cwd}/app.db  (relative)
-      #   sqlite:///data/app.db        → {cwd}/data/app.db  (relative; auto-mkdir under cwd)
-      #   sqlite:////var/data/app.db   → /var/data/app.db  (absolute; no auto-mkdir)
-      #   sqlite:///C:/Users/app.db    → C:/Users/app.db  (Windows absolute)
-      #
-      # Never mkdir outside cwd — that was the root cause of the
-      # "Read-only file system: '/data'" crash on macOS.
-      def self.resolve_path(connection_string)
-        return ":memory:" if connection_string == "sqlite::memory:" || connection_string == "sqlite:///:memory:"
-
-        # Strip the scheme + up to three slashes, preserving a potential fourth
-        # slash (absolute) or drive letter.
-        # `sqlite3:` is a documented alias for `sqlite:`. Normalise it FIRST or
-        # none of the strips below match and `raw` keeps the whole connection
-        # string, so the database file is literally named "sqlite3:app.db".
-        # Not merely ugly: a colon is an illegal filename character on Windows,
-        # so the documented alias is unusable there. DatabaseUrl already
-        # normalises it; this method duplicates the strip instead of calling
-        # it, which is how the two drifted.
-        normalised = connection_string.sub(/^sqlite3:/, "sqlite:")
-        raw = normalised.sub(/^sqlite:\/\/\//, "").sub(/^sqlite:\/\//, "").sub(/^sqlite:/, "")
-        return ":memory:" if raw == ":memory:"
-
-        is_windows_abs = raw.match?(/^[A-Za-z]:[\/\\]/)
-        is_unix_abs    = raw.start_with?("/")
-
-        if is_windows_abs || is_unix_abs
-          # Absolute — trust the user; don't auto-mkdir outside cwd.
-          raw
-        else
-          # Relative — resolve under cwd; auto-mkdir parent dir.
-          resolved = File.join(Dir.pwd, raw)
-          parent = File.dirname(resolved)
-          require "fileutils"
-          FileUtils.mkdir_p(parent) unless File.directory?(parent)
-          resolved
-        end
-      end
-
       def close
         @connection&.close
       end
@@ -227,43 +189,6 @@ module Tina4
       def identifier?(str)
         str.to_s.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
       end
-
-      # Symbolize the keys of a whole result set, computing the key mapping ONCE.
-      #
-      # results_as_hash=true hands back string-keyed hashes; every row of a query
-      # has the same columns, so the string->symbol conversion is identical for
-      # every row. The old code called `symbolize_keys` per row, which ran
-      # `k.to_s.to_sym` and an `is_a?` guard PER CELL: a 5,000-row x 6-column
-      # fetch did 30,000 conversions for 6 distinct keys and made Tina4 the
-      # slowest of the four frameworks at bulk reads (Select ALL 5,000 rows:
-      # 10.16ms vs raw sqlite3 2.56ms). Hoisting the mapping out of the loop
-      # roughly halves the hydration cost with byte-identical output.
-      #
-      # The is_a?(String|Symbol) guard is preserved: older sqlite3 gems put
-      # positional Integer keys in the hash alongside the string names, and those
-      # must still be dropped.
-      def symbolize_rows(rows)
-        return rows if rows.empty?
-
-        str_keys = rows.first.keys.select { |k| k.is_a?(String) || k.is_a?(Symbol) }
-        sym_keys = str_keys.map(&:to_sym)
-        count = str_keys.length
-        rows.map do |row|
-          out = {}
-          i = 0
-          while i < count
-            out[sym_keys[i]] = row[str_keys[i]]
-            i += 1
-          end
-          out
-        end
-      end
-
-      # Single-hash convenience kept for any external caller; delegates to the
-      # batch path so there is one implementation of the mapping rule.
-      def symbolize_keys(hash)
-        symbolize_rows([hash]).first
-      end
     end
   end
 end

data/lib/tina4/row_symbolizer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+module Tina4
+  # Shared row/key symbolisation for the two SQLite classes.
+  #
+  # `symbolize_rows`/`symbolize_keys` used to be byte-identical copy-paste in
+  # Tina4::Drivers::SqliteDriver and Tina4::Adapters::Sqlite3Adapter (the
+  # adapter's own comment pointed at the driver's copy). This module is the
+  # single home for the logic; both classes `include` it as private instance
+  # methods, so both share ONE implementation and can never drift again.
+  #
+  # The mapping is computed ONCE per query rather than per cell: the per-row
+  # form ran `k.to_s.to_sym` and an `is_a?` guard PER CELL, so a 5,000-row x
+  # 6-column fetch did 30,000 conversions for 6 distinct keys and made Tina4 the
+  # slowest of the four frameworks at bulk reads (Select ALL 5,000 rows:
+  # 10.16ms vs raw sqlite3 2.56ms). Hoisting the mapping out of the loop roughly
+  # halves the hydration cost with byte-identical output.
+  #
+  # The is_a?(String|Symbol) guard is preserved: older sqlite3 gems put
+  # positional Integer keys in the hash alongside the string names, and those
+  # must still be dropped.
+  module RowSymbolizer
+    private
+
+    # Symbolize a whole result set's keys, computing the mapping once per query.
+    def symbolize_rows(rows)
+      return rows if rows.empty?
+
+      str_keys = rows.first.keys.select { |k| k.is_a?(String) || k.is_a?(Symbol) }
+      sym_keys = str_keys.map(&:to_sym)
+      count = str_keys.length
+      rows.map do |row|
+        out = {}
+        i = 0
+        while i < count
+          out[sym_keys[i]] = row[str_keys[i]]
+          i += 1
+        end
+        out
+      end
+    end
+
+    # Single-hash convenience; delegates to the batch path so there is one
+    # implementation of the mapping rule.
+    def symbolize_keys(hash)
+      symbolize_rows([hash]).first
+    end
+  end
+end

data/lib/tina4/sqlite_path_resolver.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+require "fileutils"
+
+module Tina4
+  # Shared SQLite database-path resolution for the two SQLite resolvers.
+  #
+  # `resolve_path` used to be copy-pasted into Tina4::Drivers::SqliteDriver and
+  # Tina4::Adapters::Sqlite3Adapter with drifted scheme-stripping. This module is
+  # the single home for the logic; both classes `extend` it, so both keep a
+  # `.resolve_path` class method backed by ONE implementation and can never
+  # drift again.
+  #
+  # Convention (matches tina4-python, tina4-php, tina4-nodejs):
+  #   sqlite::memory:              → :memory:
+  #   sqlite:///:memory:           → :memory:
+  #   sqlite:///app.db             → {cwd}/app.db          (relative)
+  #   sqlite:///data/app.db        → {cwd}/data/app.db     (relative; auto-mkdir under cwd)
+  #   sqlite:////var/data/app.db   → /var/data/app.db      (absolute; no auto-mkdir)
+  #   sqlite:///C:/Users/app.db    → C:/Users/app.db       (Windows absolute)
+  #
+  # `sqlite3:` is a documented alias for `sqlite:` and is normalised first.
+  # Never mkdir outside cwd — that was the root cause of the
+  # "Read-only file system: '/data'" crash on macOS.
+  module SqlitePathResolver
+    # Resolve a SQLite URL / path against the project root (cwd).
+    #
+    # @param connection_string [String] a sqlite: / sqlite3: URL or bare path
+    # @return [String] the resolved path to hand to the driver, or ":memory:"
+    def resolve_path(connection_string)
+      return ":memory:" if connection_string == "sqlite::memory:" || connection_string == "sqlite:///:memory:"
+
+      # `sqlite3:` is a documented alias for `sqlite:`; normalise it FIRST or the
+      # strips below miss and the file ends up literally named "sqlite3:app.db"
+      # (and a colon is an illegal filename character on Windows).
+      normalised = connection_string.to_s.sub(/^sqlite3:/, "sqlite:")
+      raw = normalised.sub(%r{^sqlite:///}, "").sub(%r{^sqlite://}, "").sub(/^sqlite:/, "")
+      return ":memory:" if raw == ":memory:"
+
+      is_windows_abs = raw.match?(%r{^[A-Za-z]:[/\\]})
+      is_unix_abs    = raw.start_with?("/")
+
+      if is_windows_abs || is_unix_abs
+        # Absolute — trust the user; don't auto-mkdir outside cwd.
+        raw
+      else
+        # Relative — resolve under cwd; create the parent (mode 0775) ONLY when
+        # it stays inside cwd (ADR-0086). A relative path whose parent escapes
+        # the project (e.g. "../../etc/foo.db") is REFUSED loudly here — never
+        # the silent mkdir outside the project that used to happen.
+        resolved = File.join(Dir.pwd, raw)
+        parent = File.dirname(resolved)
+        expanded_parent = File.expand_path(parent)
+        cwd = File.expand_path(Dir.pwd)
+        unless expanded_parent == cwd || expanded_parent.start_with?(cwd + File::SEPARATOR)
+          raise ArgumentError,
+                "SQLite path #{connection_string.inspect} resolves outside the project " \
+                "directory: #{expanded_parent.inspect} is not within #{cwd.inspect}. " \
+                "Tina4 refuses to create directories outside the project (ADR-0086). " \
+                "Use an absolute path for a database that lives outside the project."
+        end
+        FileUtils.mkdir_p(parent, mode: 0o775) unless File.directory?(parent)
+        resolved
+      end
+    end
+  end
+end

data/lib/tina4/version.rb

@@ -7,5 +7,5 @@
 
 
 module Tina4
-  VERSION = "3.13.139"
+  VERSION = "3.13.140"
 end

data/lib/tina4.rb

@@ -12,6 +12,8 @@ require_relative "tina4/constants"
 require_relative "tina4/log"
 require_relative "tina4/debug"  # backward compat alias
 require_relative "tina4/env"
+require_relative "tina4/sqlite_path_resolver"
+require_relative "tina4/row_symbolizer"
 require_relative "tina4/router"
 require_relative "tina4/request"
 require_relative "tina4/response"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.139
+  version: 3.13.140
 platform: ruby
 authors:
 - Tina4 Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-26 00:00:00.000000000 Z
+date: 2026-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3
@@ -327,6 +327,7 @@ files:
 - lib/tina4/response.rb
 - lib/tina4/response_cache.rb
 - lib/tina4/router.rb
+- lib/tina4/row_symbolizer.rb
 - lib/tina4/secret_file.rb
 - lib/tina4/seeder.rb
 - lib/tina4/service.rb
@@ -344,6 +345,7 @@ files:
 - lib/tina4/smtp_client.rb
 - lib/tina4/sql_translator.rb
 - lib/tina4/sqlite3_gem.rb
+- lib/tina4/sqlite_path_resolver.rb
 - lib/tina4/sso.rb
 - lib/tina4/ssrf.rb
 - lib/tina4/swagger.rb