tina4ruby 3.13.69 → 3.13.71

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e96ce1bc6835280fdee7d6acc8d22af2fd4d013fbd658501aa189cf01266dabc
-  data.tar.gz: 236dbc434352d4210956b45e2eedcfc5129b849d47b636edc915084695098c3f
+  metadata.gz: 9f7c750568ef4a0318f99b67d4d92a5a9ce7b8ba4acbb6ac44be312713f8bced
+  data.tar.gz: 0a206bb1d8e813073e5d2914d5f90f450ab5bb52f74fd60fe5cdc27f11ee1733
 SHA512:
-  metadata.gz: 39d2f2a93cbee0c2b8d95fb8f4da308e1809e8ffb30100320a39143f07f88fcaa020649c802f7cf753289884f4984940f666cc81c4e0e9ab274a1fcbf5aca3ec
-  data.tar.gz: 057a277a69d9768542103f8459d3765819e9c6f5d2418c676977dbb59d865126f21d490d8de7b6a36f55f0849b376a71fac45df3946448f62d33a94e1e5c1d12
+  metadata.gz: a188e4d9926366ddc6152711722f9bfaddba8740353abb1b616e931c4ebec67ef26a798b5cb54248f95ea9987510bae5b931627da5b7e9aa6ca58967528bb6df
+  data.tar.gz: a554393a76905b3bd88304c7d70e76b59e29c678d7248ff880d0754ec2261e23c7699536b8a29916c9855f21973de43e60fe044fa428c0f4107048a972f810b7

data/lib/tina4/dev_admin.rb

@@ -969,6 +969,11 @@ module Tina4
         return { error: "No database configured" } unless db
 
         begin
+          # Force-load the seeder: Tina4.seed_table is defined in
+          # lib/tina4/seeder.rb, reachable only via the Tina4::FakeData autoload,
+          # which a bare Tina4.seed_table call never trips (mirrors Python's
+          # explicit `from tina4_python.seeder import seed_table`).
+          require_relative "seeder"
           # Delegate to the shared resilient seed_table helper so the endpoint
           # gets the exact same per-row wrap (P1) — no unhandled row failure can
           # crash the endpoint — plus clear/seed/strict (P2/P3). _normalize_columns

data/lib/tina4/drivers/firebird_driver.rb

@@ -76,7 +76,42 @@ module Tina4
         decoded.start_with?("/") ? decoded : "/#{decoded}"
       end
 
-      def connect(connection_string, username: nil, password: nil)
+      # Resolve the Firebird connection charset (#160, mirrors php #160 /
+      # the Python master's _resolve_firebird_charset).
+      #
+      # The driver used to pass NO charset to the `fb` gem, leaving it to the
+      # gem's own (non-UTF8) default — which double-encodes UTF-8 bytes stored
+      # under a legacy NONE database and diverges from the other frameworks.
+      # The charset is now resolved from, in precedence order:
+      #
+      #   1. the connection URL query — firebird://host:port/path?charset=NONE
+      #   2. an explicit charset: kwarg passed to #connect
+      #   3. the TINA4_DATABASE_CHARSET environment variable
+      #   4. the UTF8 default (canonical across all four frameworks)
+      #
+      # Pure config resolution over its inputs (URL string, kwarg, env) — it
+      # opens NO connection, so it is unit-testable without a live server. A
+      # blank value at any level is treated as absent (matching the Python
+      # master's falsy-string semantics) so `?charset=` / an empty env var falls
+      # through rather than connecting with an empty charset.
+      def self.resolve_charset(connection_string, kwarg_charset = nil)
+        require "uri"
+        url_charset = nil
+        query = begin
+          URI.parse(connection_string.to_s).query
+        rescue URI::InvalidURIError
+          nil
+        end
+        if query && !query.empty?
+          pair = URI.decode_www_form(query).find { |k, _| k == "charset" }
+          url_charset = pair[1] if pair && !pair[1].to_s.empty?
+        end
+        kwarg = kwarg_charset.to_s.empty? ? nil : kwarg_charset
+        env = ENV["TINA4_DATABASE_CHARSET"].to_s.empty? ? nil : ENV["TINA4_DATABASE_CHARSET"]
+        url_charset || kwarg || env || "UTF8"
+      end
+
+      def connect(connection_string, username: nil, password: nil, charset: nil)
         require "fb"
         require "uri"
         uri = URI.parse(connection_string)
@@ -115,6 +150,10 @@ module Tina4
         @connect_opts = { database: database }
         @connect_opts[:username] = db_user if db_user
         @connect_opts[:password] = db_pass if db_pass
+        # #160: honour ?charset= in the URL, an explicit charset: kwarg, and
+        # TINA4_DATABASE_CHARSET so a legacy NONE database isn't force-connected
+        # with the gem's default charset (double-encoding). Defaults to UTF8.
+        @connect_opts[:charset] = self.class.resolve_charset(connection_string, charset)
 
         open_connection
       rescue LoadError

data/lib/tina4/field_types.rb

@@ -187,8 +187,24 @@ module Tina4
         field_definitions[name] = { type: type }.merge(options)
         @primary_key_field = name if options[:primary_key]
 
-        # Define getter/setter
-        attr_accessor name
+        # Getter (plain reader) + an assignment-tracking setter.
+        #
+        # #165: save() must tell a column the caller EXPLICITLY set to nil
+        # (write it — an explicit nil becomes SQL NULL) from one left UNSET
+        # (omit it from the INSERT so a NOT NULL DEFAULT column gets its DB
+        # default instead of an explicit NULL). The setter records the field
+        # name in @assigned_fields on every caller assignment — via the
+        # constructor's attribute application, a from_hash/load populate, or a
+        # direct `model.field = x`. Field DEFAULTS are seeded in #initialize
+        # with instance_variable_set (bypassing this setter), so a default is
+        # never counted as a caller assignment. Mirrors the Python master's
+        # __setattr__ + object.__setattr__ default-seeding.
+        attr_reader name
+        define_method("#{name}=") do |value|
+          fields = (@assigned_fields ||= [])
+          fields << name unless fields.include?(name)
+          instance_variable_set("@#{name}", value)
+        end
       end
     end
   end

data/lib/tina4/mcp.rb

@@ -906,7 +906,9 @@ module Tina4
       # ── Template Tools ────────────────────────────────
       server.register_tool("template_render", lambda { |template:, data: "{}"|
         ctx = data.is_a?(String) ? JSON.parse(data) : data
-        Tina4::Template.render_string(template, ctx)
+        # render_string is an INSTANCE method of Frond (Tina4::Template has none).
+        # Mirrors Python tools.py: Frond("src/templates").render_string(...).
+        Tina4::Frond.new(template_dir: "src/templates").render_string(template, ctx)
       }, "Render a template string with data")
 
       # ── File Tools ────────────────────────────────────
@@ -1023,9 +1025,9 @@ module Tina4
           q = Tina4::Queue.new(topic: topic)
           {
             "topic"     => topic,
-            "pending"   => q.size("pending"),
-            "completed" => q.size("completed"),
-            "failed"    => q.size("failed")
+            "pending"   => q.size(status: "pending"),
+            "completed" => q.size(status: "completed"),
+            "failed"    => q.size(status: "failed")
           }
         rescue => e
           { "error" => e.message }
@@ -1107,10 +1109,15 @@ module Tina4
       # ── Data Tools ────────────────────────────────────
       server.register_tool("seed_table", lambda { |table:, count: 10|
         begin
+          # Tina4.seed_table lives in lib/tina4/seeder.rb, reachable only via the
+          # autoload of Tina4::FakeData — a bare Tina4.seed_table call never trips
+          # it. Force-load the seeder first (mirrors Python's explicit
+          # `from tina4_python.seeder import seed_table`).
+          require_relative "seeder"
           db = Tina4.database
           return { "error" => "No database connection" } if db.nil?
           inserted = Tina4.seed_table(table, db.columns(table), count: count.to_i)
-          { "table" => table, "inserted" => inserted }
+          { "table" => table, "inserted" => inserted.seeded, "failed" => inserted.failed }
         rescue => e
           { "error" => e.message }
         end

data/lib/tina4/orm.rb

@@ -625,6 +625,13 @@ module Tina4
       # cause via #get_error / #last_error — the failure never vanishes silently.
       @last_error = nil
       @relationship_cache = {}
+      # #165: field names the caller EXPLICITLY assigned (via the attribute loop
+      # below, a from_hash/load populate, or a later `model.field = x`). save()
+      # reads this to OMIT an unset column from an INSERT (so a NOT NULL DEFAULT
+      # column gets its DB default) while still writing NULL for a field the
+      # caller set to nil. The defaults seeded below use instance_variable_set,
+      # bypassing the tracking setter so they are NOT counted as assignments.
+      @assigned_fields = []
       # Accept a JSON object string (parity with Python/PHP/Node):
       #   Widget.new('{"id":1,"name":"alpha"}')
       attributes = JSON.parse(attributes) if attributes.is_a?(String)
@@ -654,7 +661,10 @@ module Tina4
           # 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)
+          # #165: seed the default straight into the ivar, BYPASSING the
+          # tracking setter, so a default is not recorded as a caller
+          # assignment (mirrors the Python master's object.__setattr__).
+          instance_variable_set("@#{name}", d)
         end
       end
     end
@@ -737,12 +747,15 @@ 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)
+        # The column hashes are built INSIDE this begin (via the transaction
+        # block below) so a JSON column that can't be serialised (to_db_hash /
+        # insert_db_hash raises JSON::GeneratorError) fails loud through the
+        # same path as a driver error — rolled back, false, cause recorded.
         self.class.db.transaction do |db|
           if is_update
+            # UPDATE is unchanged (#165 targets INSERT only): keep excluding nil
+            # so a save never nulls a column the caller didn't touch.
+            data = to_db_hash(exclude_nil: true)
             filter = { pk => pk_value }
             data.delete(pk)
             # Remove mapped primary key too
@@ -750,13 +763,32 @@ module Tina4
             data.delete(mapped_pk.to_sym) if mapped_pk
             db.update(self.class.table_name, data, filter)
           else
-            result = db.insert(self.class.table_name, data)
-            # Only adopt the engine-assigned id for an auto-increment PK. A
-            # natural-key PK was set by the caller; don't overwrite it with the
-            # driver's last_insert_id (which may be a sequence value that
-            # doesn't apply here).
-            if auto_increment && result[:last_id] && respond_to?("#{pk}=")
-              __send__("#{pk}=", result[:last_id])
+            # #165: OMIT a column the caller left unset (value nil, never
+            # assigned) so a NOT NULL DEFAULT column gets its DB default rather
+            # than an explicit NULL; a column the caller set to nil is KEPT and
+            # written as NULL (see #insert_db_hash).
+            insert_data = insert_db_hash
+            if insert_data.empty?
+              # Every insertable column is unset — let the engine apply ALL its
+              # column defaults instead of emitting explicit NULLs. DEFAULT
+              # VALUES is valid on SQLite / PostgreSQL / MSSQL / Firebird; MySQL
+              # spells the all-defaults insert () VALUES ().
+              table = self.class.table_name
+              engine = (self.class.db.respond_to?(:get_database_type) ? self.class.db.get_database_type : "").to_s.downcase
+              db.execute(engine == "mysql" ? "INSERT INTO #{table} () VALUES ()" : "INSERT INTO #{table} DEFAULT VALUES")
+              if auto_increment && respond_to?("#{pk}=")
+                last = db.get_last_id
+                __send__("#{pk}=", last) if last
+              end
+            else
+              result = db.insert(self.class.table_name, insert_data)
+              # Only adopt the engine-assigned id for an auto-increment PK. A
+              # natural-key PK was set by the caller; don't overwrite it with the
+              # driver's last_insert_id (which may be a sequence value that
+              # doesn't apply here).
+              if auto_increment && result[:last_id] && respond_to?("#{pk}=")
+                __send__("#{pk}=", result[:last_id])
+              end
             end
           end
         end
@@ -1007,6 +1039,41 @@ module Tina4
 
     private
 
+    # Build the column=>value hash for an INSERT (#165).
+    #
+    # Distinguishes a column the caller left UNSET from one the caller
+    # explicitly set to nil (tracked in @assigned_fields, populated by the field
+    # setters):
+    #
+    #   * value nil AND field NOT assigned  -> OMITTED (a DB DEFAULT applies, so
+    #       a NOT NULL DEFAULT column succeeds instead of taking an explicit NULL)
+    #   * value nil AND field assigned       -> KEPT as nil (written as SQL NULL;
+    #       a NOT NULL column rightly rejects it, so an explicit nil fails loud)
+    #   * any non-nil value (incl. a resolved ORM default) -> KEPT
+    #
+    # An unset auto-increment PK is skipped so the engine assigns the id. JSON
+    # columns serialise their Hash/Array exactly as #to_db_hash does. An empty
+    # result signals save() to emit the engine's all-defaults INSERT. Mirrors
+    # the Python master's INSERT omission (tina4_python.orm.model.save).
+    def insert_db_hash
+      hash = {}
+      mapping = self.class.field_mapping
+      assigned = @assigned_fields || []
+      self.class.field_definitions.each do |name, opts|
+        value = __send__(name)
+        # Skip an unset auto-increment PK — let the engine assign it.
+        next if opts[:auto_increment] && value.nil?
+        # Omit an unset-nil column so the DB DEFAULT applies.
+        next if value.nil? && !assigned.include?(name)
+        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
+      hash
+    end
+
     # Convert to hash using DB column names (with field_mapping applied)
     def to_db_hash(exclude_nil: false)
       hash = {}

data/lib/tina4/test_client.rb

@@ -13,6 +13,8 @@
 #
 #   response = client.get("/api/users/1", headers: { "Authorization" => "Bearer token123" })
 #
+require "stringio" # rack.input is a StringIO; require it here so a clean `require "tina4"` boot never NameErrors
+
 module Tina4
   class TestResponse
     attr_reader :status, :body, :headers, :content_type

data/lib/tina4/version.rb

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

metadata

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