tina4ruby 3.11.32 → 3.11.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1d2fabb4883ebcdd387f24cfc0c3e858304d7498b1439798b448c89623fa56e
-  data.tar.gz: 592c8eac568eba0950bde87ac4fd9b7d9bfed365aa23539b2f50409ff6a1f1d9
+  metadata.gz: 9615f251d5bed0d97024c8e061bdf34d26afb2677e5c6ec989005d45d3edc6c9
+  data.tar.gz: 7ef7b684a87906e932f3c929cfe57596f67bf81bf63cf35e79b8d343f2ab297a
 SHA512:
-  metadata.gz: '0917b8cbeaaa155cbf223bcb009662bed7f48e03e1b9b4d96c338a17fdf2cbac4333d88c549980d650a70eb515532b83783090cb4f3896ca8f7f53fba8307347'
-  data.tar.gz: c9b3da407eb7823e9e7b19af1d3928329d061b5a8d77bd904d96870ea89e90d9dbd0979b3909bff66011c584e556bb2c3dfcf219a078e6ffd28d2ac75cea9a7e
+  metadata.gz: ecf726e25d06e8ecbed12874fa4f36edf20286ea10c2c9b6c973a2d9d430dd38933a95240b8d50dd4237b82e076b634527e0c28016aa6e94f6f71a7747d126f8
+  data.tar.gz: bc0603a6370d2dc27f26ad5cee86c00f233213d57dc904075f70c5befdf28ff81b78d0c25ffa25a42f34ae9cf48d0a33a322e1147d12bc05db1f125db245538f

data/lib/tina4/drivers/firebird_driver.rb

@@ -5,6 +5,20 @@ module Tina4
     class FirebirdDriver
       attr_reader :connection
 
+      # Substring markers (lowercased) that identify a dead-socket Firebird
+      # error worth reconnecting for. Idle Firebird connections die silently
+      # behind NAT timeouts, server-side ConnectionIdleTimeout, or Docker
+      # network rotation; without this the next prepare crashes the request.
+      DEAD_CONN_MARKERS = [
+        "error writing data to the connection",
+        "error reading data from the connection",
+        "connection shutdown",
+        "connection lost",
+        "network error",
+        "connection is not active",
+        "broken pipe"
+      ].freeze
+
       def connect(connection_string, username: nil, password: nil)
         require "fb"
         require "uri"
@@ -21,10 +35,13 @@ module Tina4
                      db_path || connection_string.sub(/^firebird:\/\//, "")
                    end
 
-        opts = { database: database }
-        opts[:username] = db_user if db_user
-        opts[:password] = db_pass if db_pass
-        @connection = Fb::Database.new(**opts).connect
+        # Cache for transparent reconnect — never logged, lives only in
+        # driver memory alongside the connection it owns.
+        @connect_opts = { database: database }
+        @connect_opts[:username] = db_user if db_user
+        @connect_opts[:password] = db_pass if db_pass
+
+        open_connection
       rescue LoadError
         raise "Firebird driver requires the 'fb' gem. Install it with: gem install fb"
       end
@@ -34,22 +51,35 @@ module Tina4
       end
 
       def execute_query(sql, params = [])
-        rows = if params.empty?
-                 @connection.query(:hash, sql)
-               else
-                 @connection.query(:hash, sql, *params)
-               end
+        rows = with_reconnect do
+          if params.empty?
+            @connection.query(:hash, sql)
+          else
+            @connection.query(:hash, sql, *params)
+          end
+        end
         rows.map { |row| decode_blobs(stringify_keys(row)) }
       end
 
       def execute(sql, params = [])
-        if params.empty?
-          @connection.execute(sql)
-        else
-          @connection.execute(sql, *params)
+        with_reconnect do
+          if params.empty?
+            @connection.execute(sql)
+          else
+            @connection.execute(sql, *params)
+          end
         end
       end
 
+      # Public so specs (and curious operators) can verify the matcher
+      # behaviour without poking private methods.
+      def self.dead_connection?(error_or_message)
+        msg = error_or_message.respond_to?(:message) ? error_or_message.message : error_or_message.to_s
+        return false if msg.nil? || msg.empty?
+        lower = msg.downcase
+        DEAD_CONN_MARKERS.any? { |m| lower.include?(m) }
+      end
+
       def last_insert_id
         nil
       end
@@ -103,6 +133,34 @@ module Tina4
 
       private
 
+      def open_connection
+        @connection = Fb::Database.new(**@connect_opts).connect
+      end
+
+      # Force-close a stale handle and reopen using cached opts. Idempotent —
+      # safe to call when the connection is already gone.
+      def reconnect!
+        begin
+          @connection&.close
+        rescue StandardError
+          # connection already gone — nothing to clean up
+        end
+        @connection = nil
+        @transaction = nil
+        open_connection
+      end
+
+      # Run a block; if it raises with a dead-connection signature, reconnect
+      # once and retry. Skipped inside an explicit transaction — atomicity
+      # beats resilience there; the caller handles rollback.
+      def with_reconnect
+        yield
+      rescue StandardError => e
+        raise unless self.class.dead_connection?(e) && @transaction.nil?
+        reconnect!
+        yield
+      end
+
       def stringify_keys(hash)
         hash.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
       end

data/lib/tina4/orm.rb

@@ -4,7 +4,7 @@ require "json"
 module Tina4
   # Convert a snake_case name to camelCase.
   def self.snake_to_camel(name)
-    parts = name.to_s.downcase.split("_")
+    parts = name.to_s.split("_")
     parts[0] + parts[1..].map(&:capitalize).join
   end
 
@@ -18,7 +18,7 @@ module Tina4
 
     class << self
       def db
-        @db || Tina4.database || auto_discover_db
+        @db || Tina4.database
       end
 
       # Per-model database binding
@@ -52,24 +52,28 @@ module Tina4
         @field_mapping = map
       end
 
-      # Auto-map flag (no-op in Ruby since snake_case is native)
+      # Auto-map flag — defaults to TRUE for cross-framework parity (Python's
+      # ORM has auto_map=True by default). The instance variable is treated
+      # as "unset" when nil; only an explicit `false` disables it.
       def auto_map
-        @auto_map.nil? ? true : @auto_map
+        defined?(@auto_map) && !@auto_map.nil? ? @auto_map : true
       end
 
       def auto_map=(val)
         @auto_map = val
       end
 
-      # Auto-CRUD flag: when set to true, registers this model for CRUD route generation
+      # auto_crud flag — when set to true, the class registers itself with
+      # Tina4::AutoCrud which auto-generates REST endpoints from the model.
+      # Defaults to false. Cross-framework parity with Python's autoCrud.
       def auto_crud
-        @auto_crud || false
+        defined?(@auto_crud) && !@auto_crud.nil? ? @auto_crud : false
       end
 
       def auto_crud=(val)
         @auto_crud = val
-        if val
-          Tina4::AutoCrud.register(self) if defined?(Tina4::AutoCrud)
+        if val && defined?(::Tina4::AutoCrud)
+          ::Tina4::AutoCrud.models << self unless ::Tina4::AutoCrud.models.include?(self)
         end
       end
 
@@ -79,7 +83,7 @@ module Tina4
       end
 
       # has_one :profile, class_name: "Profile", foreign_key: "user_id"
-      def has_one(name, class_name: nil, foreign_key: nil) # -> nil
+      def has_one(name, class_name: nil, foreign_key: nil)
         relationship_definitions[name] = {
           type: :has_one,
           class_name: class_name || name.to_s.split("_").map(&:capitalize).join,
@@ -92,7 +96,7 @@ module Tina4
       end
 
       # has_many :posts, class_name: "Post", foreign_key: "user_id"
-      def has_many(name, class_name: nil, foreign_key: nil) # -> nil
+      def has_many(name, class_name: nil, foreign_key: nil)
         relationship_definitions[name] = {
           type: :has_many,
           class_name: class_name || name.to_s.sub(/s$/, "").split("_").map(&:capitalize).join,
@@ -105,7 +109,7 @@ module Tina4
       end
 
       # belongs_to :user, class_name: "User", foreign_key: "user_id"
-      def belongs_to(name, class_name: nil, foreign_key: nil) # -> nil
+      def belongs_to(name, class_name: nil, foreign_key: nil)
         relationship_definitions[name] = {
           type: :belongs_to,
           class_name: class_name || name.to_s.split("_").map(&:capitalize).join,
@@ -123,46 +127,31 @@ module Tina4
       #   results = User.query.where("active = ?", [1]).order_by("name").get
       #
       # @return [Tina4::QueryBuilder]
-      def query # -> QueryBuilder
-        QueryBuilder.from_table(table_name, db: db)
-      end
-
-      # Find records by filter dict. Always returns an array.
-      #
-      # Usage:
-      #   User.find(name: "Alice")                  → [User, ...]
-      #   User.find({age: 18}, limit: 10)           → [User, ...]
-      #   User.find(order_by: "name ASC")            → [User, ...]
-      #   User.find                                  → all records
-      #
-      # Use find_by_id(id) for single-record primary key lookup.
-      def find(filter = {}, limit: 100, offset: 0, order_by: nil, include: nil, **extra_filter) # -> list[Self]
-        # Integer or string-digit argument → primary key lookup (returns single record or nil)
-        return find_by_id(filter) if filter.is_a?(Integer)
-
-        # Merge keyword-style filters: find(name: "Alice") and find({name: "Alice"}) both work
-        filter = filter.merge(extra_filter) unless extra_filter.empty?
-        conditions = []
-        params = []
-
-        filter.each do |key, value|
-          col = field_mapping[key.to_s] || key
-          conditions << "#{col} = ?"
-          params << value
+      def query
+        QueryBuilder.from(table_name, db: db)
+      end
+
+      def find(id_or_filter = nil, filter = nil, **kwargs)
+        include_list = kwargs.delete(:include)
+
+        # find(id) — find by primary key
+        # find(filter_hash) — find by criteria
+        # find(name: "Alice") — keyword args as filter hash
+        result = if id_or_filter.is_a?(Hash)
+          find_by_filter(id_or_filter)
+        elsif filter.is_a?(Hash)
+          find_by_filter(filter)
+        elsif !kwargs.empty?
+          find_by_filter(kwargs)
+        else
+          find_by_id(id_or_filter)
         end
 
-        if soft_delete
-          conditions << "(#{soft_delete_field} IS NULL OR #{soft_delete_field} = 0)"
+        if include_list && result
+          instances = result.is_a?(Array) ? result : [result]
+          eager_load(instances, include_list)
         end
-
-        sql = "SELECT * FROM #{table_name}"
-        sql += " WHERE #{conditions.join(' AND ')}" unless conditions.empty?
-        sql += " ORDER BY #{order_by}" if order_by
-
-        results = db.fetch(sql, params, limit: limit, offset: offset)
-        instances = results.map { |row| from_hash(row) }
-        eager_load(instances, include) if include
-        instances
+        result
       end
 
       # Eager load relationships for a collection of instances (prevents N+1).
@@ -243,20 +232,20 @@ module Tina4
         end
       end
 
-      def where(conditions, params = [], limit: 20, offset: 0, include: nil) # -> list[Self]
+      def where(conditions, params = [], include: nil)
         sql = "SELECT * FROM #{table_name}"
         if soft_delete
           sql += " WHERE (#{soft_delete_field} IS NULL OR #{soft_delete_field} = 0) AND (#{conditions})"
         else
           sql += " WHERE #{conditions}"
         end
-        results = db.fetch(sql, params, limit: limit, offset: offset)
+        results = db.fetch(sql, params)
         instances = results.map { |row| from_hash(row) }
         eager_load(instances, include) if include
         instances
       end
 
-      def all(limit: nil, offset: nil, order_by: nil, include: nil) # -> list[Self]
+      def all(limit: nil, offset: nil, order_by: nil, include: nil)
         sql = "SELECT * FROM #{table_name}"
         if soft_delete
           sql += " WHERE #{soft_delete_field} IS NULL OR #{soft_delete_field} = 0"
@@ -268,19 +257,19 @@ module Tina4
         instances
       end
 
-      def select(sql, params = [], limit: nil, offset: nil, include: nil) # -> list[Self]
+      def select(sql, params = [], limit: nil, offset: nil, include: nil)
         results = db.fetch(sql, params, limit: limit, offset: offset)
         instances = results.map { |row| from_hash(row) }
         eager_load(instances, include) if include
         instances
       end
 
-      def select_one(sql, params = [], include: nil) # -> Self | nil
+      def select_one(sql, params = [], include: nil)
         results = select(sql, params, limit: 1, include: include)
         results.first
       end
 
-      def count(conditions = nil, params = []) # -> int
+      def count(conditions = nil, params = [])
         sql = "SELECT COUNT(*) as cnt FROM #{table_name}"
         where_parts = []
         if soft_delete
@@ -292,48 +281,25 @@ module Tina4
         result[:cnt].to_i
       end
 
-      def create(attributes = {}) # -> Self
+      def create(attributes = {})
         instance = new(attributes)
         instance.save
         instance
       end
 
-      def find_or_fail(id) # -> Self
+      def find_or_fail(id)
         result = find(id)
         raise "#{name} with #{primary_key_field || :id}=#{id} not found" if result.nil?
         result
       end
 
-      # Return true if a record with the given primary key exists.
-      def exists(pk_value) # -> bool
-        find(pk_value) != nil
-      end
-
-      # SQL query with in-memory result caching.
-      # Results are cached by (class, sql, params, limit, offset) for +ttl+ seconds.
-      def cached(sql, params = [], ttl: 60, limit: 20, offset: 0, include: nil) # -> list[Self]
-        @_query_cache ||= Tina4::QueryCache.new(default_ttl: ttl, max_size: 500)
-        cache_key = Tina4::QueryCache.query_key("#{name}:#{sql}", params + [limit, offset])
-        hit = @_query_cache.get(cache_key)
-        return hit unless hit.nil?
-
-        results = select(sql, params, limit: limit, offset: offset, include: include)
-        @_query_cache.set(cache_key, results, ttl: ttl, tags: [name])
-        results
-      end
-
-      # Clear all cached query results for this model.
-      def clear_cache # -> nil
-        @_query_cache&.clear_tag(name)
-      end
-
-      def with_trashed(conditions = "1=1", params = [], limit: 20, offset: 0) # -> list[Self]
+      def with_trashed(conditions = "1=1", params = [], limit: 20, offset: 0)
         sql = "SELECT * FROM #{table_name} WHERE #{conditions}"
         results = db.fetch(sql, params, limit: limit, offset: offset)
         results.map { |row| from_hash(row) }
       end
 
-      def create_table # -> bool
+      def create_table
         return true if db.table_exists?(table_name)
 
         type_map = {
@@ -374,7 +340,7 @@ module Tina4
         true
       end
 
-      def scope(name, filter_sql, params = []) # -> nil
+      def scope(name, filter_sql, params = [])
         define_singleton_method(name) do |limit: 20, offset: 0|
           where(filter_sql, params)
         end
@@ -393,42 +359,17 @@ module Tina4
         instance
       end
 
-      # Find a single record by primary key. Returns instance or nil.
-      def find_by_id(id, include: nil) # -> Self | nil
+      # find_by_id is PUBLIC — cross-framework parity with Python's
+      # MyModel.find_by_id(pk_value) and PHP's User::find($id). Spec at
+      # spec/orm_spec.rb:78 verifies public access. find_by_filter stays
+      # public for the same reason; both are part of the documented API.
+      def find_by_id(id)
         pk = primary_key_field || :id
         sql = "SELECT * FROM #{table_name} WHERE #{pk} = ?"
         if soft_delete
           sql += " AND (#{soft_delete_field} IS NULL OR #{soft_delete_field} = 0)"
         end
-        select_one(sql, [id], include: include)
-      end
-
-      # Clear the relationship cache on all loaded instances (class-level helper).
-      # Useful after bulk operations when you want to force relationship re-loads.
-      def clear_rel_cache # -> nil
-        @_rel_cache = {}
-        nil
-      end
-
-      # Return the database connection used by this model.
-      def get_db # -> Database
-        db
-      end
-
-      # Map a Ruby property name to its database column name using field_mapping.
-      # Returns the column name as a symbol.
-      def get_db_column(property) # -> Symbol
-        col = field_mapping[property.to_s] || property
-        col.to_sym
-      end
-
-      private
-
-      def auto_discover_db
-        url = ENV["DATABASE_URL"]
-        return nil unless url
-        Tina4.database = Tina4::Database.new(url, username: ENV.fetch("DATABASE_USERNAME", ""), password: ENV.fetch("DATABASE_PASSWORD", ""))
-        Tina4.database
+        select_one(sql, [id])
       end
 
       def find_by_filter(filter)
@@ -458,7 +399,7 @@ module Tina4
       end
     end
 
-    def save # -> Self | bool
+    def save
       @errors = []
       @relationship_cache = {} # Clear relationship cache on save
       validate_fields
@@ -490,7 +431,7 @@ module Tina4
       false
     end
 
-    def delete # -> bool
+    def delete
       pk = self.class.primary_key_field || :id
       pk_value = __send__(pk)
       return false unless pk_value
@@ -510,7 +451,7 @@ module Tina4
       true
     end
 
-    def force_delete # -> bool
+    def force_delete
       pk = self.class.primary_key_field || :id
       pk_value = __send__(pk)
       raise "Cannot delete: no primary key value" unless pk_value
@@ -522,7 +463,7 @@ module Tina4
       true
     end
 
-    def restore # -> bool
+    def restore
       raise "Model does not support soft delete" unless self.class.soft_delete
 
       pk = self.class.primary_key_field || :id
@@ -540,7 +481,7 @@ module Tina4
       true
     end
 
-    def validate # -> list[str]
+    def validate
       errors = []
       self.class.field_definitions.each do |name, opts|
         value = __send__(name)
@@ -551,36 +492,34 @@ module Tina4
       errors
     end
 
-    # Load a record into this instance via select_one.
-    # Returns true if found and loaded, false otherwise.
-    # Load a record into this instance.
+    # load — populate this instance from the database.
     #
-    # Usage:
-    #   orm.id = 1; orm.load          — uses PK already set
-    #   orm.load("id = ?", [1])       — filter with params
-    #   orm.load("id = 1")            — filter string
+    # Three forms (parity with Python's model.load(sql, params, include)):
+    #   user.load                                   # reload by primary key from instance
+    #   user.load(123)                              # load by primary key value
+    #   user.load("email = ?", ["a@b.c"])           # load by filter SQL + params (selectOne)
     #
-    # Returns true if a record was found, false otherwise.
-    def load(filter = nil, params = [], include: nil) # -> bool
-      @relationship_cache = {}
-      table = self.class.table_name
-
-      if filter.nil?
-        pk = self.class.primary_key
-        pk_col = self.class.field_mapping[pk.to_s] || pk
-        pk_value = __send__(pk)
-        return false if pk_value.nil?
-        sql = "SELECT * FROM #{table} WHERE #{pk_col} = ?"
-        params = [pk_value]
+    # Returns true on hit, false on miss. Always clears the relationship cache.
+    def load(arg = nil, params = nil)
+      @relationship_cache = {} # Clear relationship cache on reload
+      pk = self.class.primary_key_field || :id
+
+      if arg.is_a?(String)
+        # Filter-SQL form: user.load("email = ?", ["a@b.c"])
+        sql = "SELECT * FROM #{self.class.table_name} WHERE #{arg} LIMIT 1"
+        result = self.class.db.fetch_one(sql, params || [])
       else
-        sql = "SELECT * FROM #{table} WHERE #{filter}"
+        # Primary-key form: user.load OR user.load(123)
+        id = arg || __send__(pk)
+        return false unless id
+        result = self.class.db.fetch_one(
+          "SELECT * FROM #{self.class.table_name} WHERE #{pk} = ?", [id]
+        )
       end
-
-      result = self.class.select_one(sql, params, include: include)
       return false unless result
 
       mapping_reverse = self.class.field_mapping.invert
-      result.to_h.each do |key, value|
+      result.each do |key, value|
         attr_name = mapping_reverse[key.to_s] || key
         setter = "#{attr_name}="
         __send__(setter, value) if respond_to?(setter)
@@ -599,8 +538,10 @@ module Tina4
 
     # Convert to hash using Ruby attribute names.
     # Optionally include relationships via the include keyword.
-    # case: 'snake' (default) returns snake_case keys, 'camel' returns camelCase keys.
-    def to_h(include: nil, case: 'snake') # -> dict
+    # case: "camel" converts snake_case keys to camelCase (parity with
+    # Python's to_dict(case='camel')). Default keeps native snake_case.
+    def to_h(include: nil, case: nil)
+      key_case = binding.local_variable_get(:case)  # :case is a reserved word
       hash = {}
       self.class.field_definitions.each_key do |name|
         hash[name] = __send__(name)
@@ -622,49 +563,36 @@ module Tina4
           if related.nil?
             hash[rel_name] = nil
           elsif related.is_a?(Array)
-            hash[rel_name] = related.map { |r| r.to_h(include: nested.empty? ? nil : nested, case: binding.local_variable_get(:case)) }
+            hash[rel_name] = related.map { |r| r.to_h(include: nested.empty? ? nil : nested) }
           else
-            hash[rel_name] = related.to_h(include: nested.empty? ? nil : nested, case: binding.local_variable_get(:case))
+            hash[rel_name] = related.to_h(include: nested.empty? ? nil : nested)
           end
         end
       end
 
-      case_mode = binding.local_variable_get(:case)
-      if case_mode == 'camel'
-        camel_hash = {}
-        hash.each do |key, value|
-          camel_key = Tina4.snake_to_camel(key.to_s).to_sym
-          camel_hash[camel_key] = value
+      if key_case == "camel" || key_case == :camel
+        # snake_case → camelCase: split on _, capitalize all but the first
+        hash = hash.each_with_object({}) do |(k, v), out|
+          parts = k.to_s.split("_")
+          camel = parts[0] + parts[1..].map(&:capitalize).join
+          out[camel.to_sym] = v
         end
-        return camel_hash
       end
 
       hash
     end
 
-    def to_hash(include: nil, case: 'snake')
-      to_h(include: include, case: binding.local_variable_get(:case))
-    end
-
-    def to_dict(include: nil, case: 'snake')
-      to_h(include: include, case: binding.local_variable_get(:case))
-    end
+    alias to_hash to_h
+    alias to_dict to_h
+    alias to_object to_h
 
-    def to_assoc(include: nil, case: 'snake')
-      to_h(include: include, case: binding.local_variable_get(:case))
-    end
-
-    def to_object(include: nil, case: 'snake')
-      to_h(include: include, case: binding.local_variable_get(:case))
-    end
-
-    def to_array # -> list
+    def to_array
       to_h.values
     end
 
     alias to_list to_array
 
-    def to_json(include: nil, **_args) # -> str
+    def to_json(include: nil, **_args)
       JSON.generate(to_h(include: include))
     end
 
@@ -747,44 +675,7 @@ module Tina4
       fk_value = __send__(fk.to_sym) if respond_to?(fk.to_sym)
       return nil unless fk_value
 
-      @relationship_cache[name] = klass.find_by_id(fk_value)
-    end
-
-    public
-
-    # ── Imperative relationship methods (ad-hoc, like Python/PHP/Node) ──
-
-    def has_one(related_class, foreign_key: nil)
-      pk = self.class.primary_key_field || :id
-      pk_value = __send__(pk)
-      return nil unless pk_value
-
-      fk = foreign_key || "#{self.class.name.split('::').last.downcase}_id"
-      result = related_class.db.fetch_one(
-        "SELECT * FROM #{related_class.table_name} WHERE #{fk} = ?", [pk_value]
-      )
-      result ? related_class.from_hash(result) : nil
-    end
-
-    def has_many(related_class, foreign_key: nil, limit: 100, offset: 0)
-      pk = self.class.primary_key_field || :id
-      pk_value = __send__(pk)
-      return [] unless pk_value
-
-      fk = foreign_key || "#{self.class.name.split('::').last.downcase}_id"
-      results = related_class.db.fetch(
-        "SELECT * FROM #{related_class.table_name} WHERE #{fk} = ?",
-        [pk_value], limit: limit, offset: offset
-      )
-      results.map { |row| related_class.from_hash(row) }
-    end
-
-    def belongs_to(related_class, foreign_key: nil)
-      fk = foreign_key || "#{related_class.name.split('::').last.downcase}_id"
-      fk_value = respond_to?(fk.to_sym) ? __send__(fk.to_sym) : nil
-      return nil unless fk_value
-
-      related_class.find_by_id(fk_value)
+      @relationship_cache[name] = klass.find(fk_value)
     end
   end
 end

data/lib/tina4/version.rb

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

metadata

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