tina4ruby 3.13.52 → 3.13.54

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6a859f05cd2ac97b5e38ab9ee678cd8419f91be1aca0dedaed1e1d63b268968
-  data.tar.gz: 4454362a269ef77b5992a0ec4d2e30e6dd64134ed64265d1e8fd6f9432fcbc0f
+  metadata.gz: cd2180527148137de7bd985ed3951aefcae89d9fee30032de3c34434b3cc209e
+  data.tar.gz: 78e32b6e6021f24c455bb002339a59c54a8a134a1b219493c6dc994d66ebaff5
 SHA512:
-  metadata.gz: 595d84b72e3b75a263f54ff93859a9f92f52fc76434b7633d149d11a2fa8a172a72478a13b9aa649ea0189a1f975d0a98daf7afa7cbceeb5bec9636433c95dad
-  data.tar.gz: 66634157b45125bb796277f54a9b93d12ab721c237b0dec39450d78d69ba4f3162972a178ef742607d45e4cc33d572c3460d7d336e0133e7c29ea902e21b68ae
+  metadata.gz: 8f422139294a6d51b34507f116dd21621e5299829b02f7ec613083bd2bc9d051a4c832c01dab8120978708fa637302b35b6b05d2f463a188f91dfc9d89d2879b
+  data.tar.gz: 96ebc4a47de1674a828dc5913c4586fc82170f0c04159724d69a1cd6a99d15596bc5f217aa76ed4e119675559fc48d7b22cbd71eccd10e231de32d1ab2bc61da

data/lib/tina4/dev_admin.rb

@@ -1688,8 +1688,9 @@ module Tina4
 
       # Native MCP JSON-RPC endpoint (POST /__dev/mcp[/message]). Real MCP
       # clients POST a JSON-RPC 2.0 request; we hand the parsed body straight
-      # to the default server's handle_message and echo the response. A
-      # notification (no id) yields an empty 204, mirroring Python.
+      # to the default server's dispatch_http and echo the response. A
+      # notification (no id) yields an empty 202 Accepted (the MCP Streamable
+      # HTTP contract), mirroring the Python master, PHP and Node.
       # Streamable HTTP POST /__dev/mcp — the current MCP transport. initialize
       # issues an Mcp-Session-Id; an unknown session on a non-initialize request
       # is a 404; a notification is 202; anything else answers inline (200).

data/lib/tina4/migration.rb

@@ -229,19 +229,34 @@ module Tina4
       end
     end
 
+    # Return a result row keyed by lower-case symbols. Firebird returns rows keyed
+    # by UPPERCASE string column names while SQLite/others return lower-case symbol
+    # keys, so the tracking-table reads below are normalised to one shape. Without
+    # this, `row[:migration_name]` is nil on Firebird and every applied migration
+    # is treated as pending and re-run.
+    def normalize_row(row)
+      return {} if row.nil?
+
+      source = row.respond_to?(:to_h) ? row.to_h : row
+      source.each_with_object({}) { |(k, v), h| h[k.to_s.downcase.to_sym] = v }
+    end
+
     def completed_migrations
       result = @db.fetch("SELECT migration_name FROM #{TRACKING_TABLE} WHERE passed = 1 ORDER BY id")
-      result.map { |r| r[:migration_name] }
+      result.map { |r| normalize_row(r)[:migration_name] }
     end
 
     def completed_migrations_with_batch
       result = @db.fetch("SELECT id, migration_name, batch FROM #{TRACKING_TABLE} WHERE passed = 1 ORDER BY id")
-      result.map { |r| { id: r[:id], migration_name: r[:migration_name], batch: r[:batch] } }
+      result.map do |r|
+        row = normalize_row(r)
+        { id: row[:id], migration_name: row[:migration_name], batch: row[:batch] }
+      end
     end
 
     def next_batch_number
-      result = @db.fetch_one("SELECT MAX(batch) as max_batch FROM #{TRACKING_TABLE} WHERE passed = 1")
-      (result && result[:max_batch] ? result[:max_batch].to_i : 0) + 1
+      result = normalize_row(@db.fetch_one("SELECT MAX(batch) as max_batch FROM #{TRACKING_TABLE} WHERE passed = 1"))
+      (result[:max_batch] ? result[:max_batch].to_i : 0) + 1
     end
 
     def pending_migrations
@@ -479,12 +494,22 @@ module Tina4
           next
         end
 
-        # Statement delimiter — only reached outside blocks/comments/strings.
+        # Statement delimiter — only reached outside blocks/comments/strings. A
+        # SET TERM directive switches the active terminator and is consumed
+        # (never emitted); any other completed statement is collected.
         if !delimiter.empty? && sql[i, dlen] == delimiter
+          i += dlen
           stmt = current.strip
-          statements << stmt unless stmt.empty?
           current = +""
-          i += dlen
+          unless stmt.empty?
+            new_term = parse_set_term(stmt)
+            if new_term
+              delimiter = new_term
+              dlen = delimiter.length
+            else
+              statements << stmt
+            end
+          end
           next
         end
 
@@ -492,11 +517,30 @@ module Tina4
         i += 1
       end
 
+      # Trailing statement (may not end with a delimiter). A trailing SET TERM
+      # directive is a no-op — consume it, don't emit it.
       stmt = current.strip
-      statements << stmt unless stmt.empty?
+      statements << stmt unless stmt.empty? || parse_set_term(stmt)
       statements
     end
 
+    # Return the new terminator from a `SET TERM <new> <current>` directive, or
+    # nil when +statement+ is not a SET TERM directive.
+    #
+    # SET TERM is a script-level directive (recognised by isql and other
+    # InterBase/Firebird tooling, not run by the engine) that changes the
+    # terminator separating statements. Recognising it lets a statement whose own
+    # body contains the default ";" terminator — a trigger, stored procedure or
+    # EXECUTE BLOCK — be kept intact rather than split on those inner ";". The
+    # terminator may be more than one character (e.g. "!!").
+    #
+    # @param statement [String] a single, already-stripped statement
+    # @return [String, nil] the new terminator, or nil when not a SET TERM directive
+    def parse_set_term(statement)
+      m = statement.strip.match(/\ASET\s+TERM\s+(\S+)\z/i)
+      m && m[1]
+    end
+
     def execute_sql_file(file)
       sql = File.read(file)
       statements = split_sql_statements(sql)

data/lib/tina4/orm.rb

@@ -419,6 +419,20 @@ module Tina4
                        else "DATETIME"
                        end
 
+        # Engine-aware JSON column type (parity with the Python master's
+        # JSONField DDL). PostgreSQL gets native JSONB (indexable, canonical);
+        # MySQL native JSON; MSSQL stores JSON as NVARCHAR(MAX) (its JSON
+        # functions read that); Firebird has no TEXT type so it uses a text
+        # BLOB; SQLite and everything else store the JSON text in TEXT
+        # (queryable via json1).
+        json_sql = case engine
+                   when "postgres", "postgresql" then "JSONB"
+                   when "mysql" then "JSON"
+                   when "mssql", "sqlserver" then "NVARCHAR(MAX)"
+                   when "firebird" then "BLOB SUB_TYPE TEXT"
+                   else "TEXT"
+                   end
+
         type_map = {
           integer: "INTEGER",
           string: "VARCHAR(255)",
@@ -430,7 +444,7 @@ module Tina4
           datetime: datetime_sql,
           timestamp: "TIMESTAMP",
           blob: "BLOB",
-          json: "TEXT"
+          json: json_sql
         }
 
         col_defs = []
@@ -444,7 +458,11 @@ module Tina4
           parts << "PRIMARY KEY" if opts[:primary_key]
           parts << "AUTOINCREMENT" if opts[:auto_increment]
           parts << "NOT NULL" if !opts[:nullable] && !opts[:primary_key]
-          if opts[:default] && !opts[:auto_increment]
+          # A JSON column carries no DDL DEFAULT (parity with the Python master):
+          # a dict/list default is an application-level concern, applied per
+          # instance, not a portable SQL literal (PG needs a ::jsonb cast, MySQL
+          # an expression default). The instance still gets its default at new.
+          if opts[:default] && !opts[:auto_increment] && opts[:type] != :json
             parts << "DEFAULT #{default_literal(opts[:default], opts[:type], bool_sql)}"
           end
           col_defs << parts.join(" ")
@@ -486,6 +504,21 @@ module Tina4
         hash.each do |key, value|
           # Apply field mapping (db_col => ruby_attr)
           attr_name = mapping_reverse[key.to_s] || key
+          # A JSON column comes back from the driver as a JSON string (SQLite
+          # TEXT, MySQL JSON, PostgreSQL JSONB via the text protocol, MSSQL
+          # NVARCHAR). Decode it to the Hash/Array the attribute expects
+          # (parity with the Python master's JSONField parse-on-read). A value
+          # already a Hash/Array is left untouched; nil stays nil; a
+          # non-decodable string keeps its raw form rather than crashing a
+          # normal read.
+          fdef = field_definitions[attr_name.to_sym]
+          if fdef && fdef[:type] == :json && value.is_a?(String)
+            begin
+              value = JSON.parse(value)
+            rescue JSON::ParserError
+              # leave the raw string in place
+            end
+          end
           setter = "#{attr_name}="
           instance.__send__(setter, value) if instance.respond_to?(setter)
         end
@@ -610,6 +643,11 @@ module Tina4
         if __send__(name).nil? && opts[:default]
           d = opts[:default]
           d = d.call if d.respond_to?(:call) && !d.is_a?(Class)
+          # Deep-copy a mutable Hash/Array default so two instances never alias
+          # the same object (e.g. `json_field :meta, default: {}` — mutating
+          # a.meta must not leak into b.meta). Parity with the Python master,
+          # which deepcopies a JSONField's dict/list default per instance.
+          d = Marshal.load(Marshal.dump(d)) if d.is_a?(Hash) || d.is_a?(Array)
           __send__("#{name}=", d)
         end
       end
@@ -667,7 +705,6 @@ module Tina4
         return false
       end
 
-      data = to_db_hash(exclude_nil: true)
       pk = self.class.primary_key_field || :id
       pk_value = __send__(pk)
       pk_opts = self.class.field_definitions[pk] || {}
@@ -694,6 +731,10 @@ module Tina4
         end
 
       begin
+        # Built here (inside the rescue's reach) so a JSON column that can't be
+        # serialised (to_db_hash raises JSON::GeneratorError) fails loud through
+        # the same path as a driver error — rolled back, false, cause recorded.
+        data = to_db_hash(exclude_nil: true)
         self.class.db.transaction do |db|
           if is_update
             filter = { pk => pk_value }
@@ -941,9 +982,19 @@ module Tina4
     def to_db_hash(exclude_nil: false)
       hash = {}
       mapping = self.class.field_mapping
-      self.class.field_definitions.each_key do |name|
+      self.class.field_definitions.each do |name, opts|
         value = __send__(name)
         next if exclude_nil && value.nil?
+        # A JSON column serialises its Hash/Array to a JSON string for the
+        # driver (parity with the Python master's JSONField.to_db). A value
+        # that can't be encoded (e.g. Float::NAN) raises JSON::GeneratorError;
+        # save() computes this hash inside its rescue, so it fails loud —
+        # rolls back, returns false, records the cause. A value already a
+        # String is left as-is (a caller who pre-encoded stays in control);
+        # nil passes through untouched.
+        if opts[:type] == :json && !value.nil? && !value.is_a?(String)
+          value = JSON.generate(value)
+        end
         db_col = mapping[name.to_s] || name
         hash[db_col.to_sym] = value
       end

data/lib/tina4/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.52
+  version: 3.13.54
 platform: ruby
 authors:
 - Tina4 Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-04 00:00:00.000000000 Z
+date: 2026-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack