tina4ruby 3.13.16 → 3.13.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1cf076eb39a57f9c1cbdff22ff957b6abf2bc24ab245d603a88f4fdc780ab1f
-  data.tar.gz: 87a49969a5de07822dfeee8f4d6792dd0260409344519396e108ee45d8c68245
+  metadata.gz: 0073552dcac0e437fa36de2038f6958cbdbcde9077ec2427d9fd1bf77242da0e
+  data.tar.gz: c5c667382a67031bef1d7f3646020984942079edb5de9c5084c135ce4be68e9d
 SHA512:
-  metadata.gz: a46003bec7bcaf5c5a4df7731a80b6d4e77b4eca9a9f467dcd061e94db7372192ba8751cf29d333518c49988224172adfab0a05bd16a14bc65fa2d2a5a209d98
-  data.tar.gz: ff0760e9a50bfe4f07dafc1c842060693a710de0ff5c3c9c5adfe606e858aee4219ea4e5bbdda600cd0252f89f83f749b619e426a884f0a6260e0c5552ce04bf
+  metadata.gz: d7e9036bfe01826691e30382e35b8c4f70dfe2043602f41abae7a0e573993992a99f89e733b2b7dd74e4c2c2d6fe1c6be7faeb4d57d132d0be6c1d471f538afb
+  data.tar.gz: 7a4ec3bdd62b40c973e2fadbd52f205d92bc6fd2f0e18c1407a164a6cb27fcb03bffb50ec789851ac567105c1da81c6fbdcd00ece6fdbefef2411d1067f55610

data/lib/tina4/drivers/postgres_driver.rb

@@ -25,6 +25,8 @@ module Tina4
           url = uri.to_s
         end
         @connection = PG.connect(url)
+        apply_result_type_map(@connection)
+        @connection
       end
 
       def close
@@ -151,6 +153,55 @@ module Tina4
 
       private
 
+      # Decode result columns to native Ruby types (parity with SQLite, and
+      # with Python psycopg2 / Node node-postgres which both return native
+      # types). Without this the pg gem hands back EVERY column as a String —
+      # ``id: "1"``, ``active: "t"``, timestamps as strings — so an app
+      # written on SQLite silently changes behaviour on PostgreSQL.
+      #
+      # PG::BasicTypeMapForResults decodes by column OID:
+      #   int2/int4/int8/serial -> Integer
+      #   bool                  -> true / false
+      #   float4/float8         -> Float
+      #   numeric               -> BigDecimal
+      #   timestamp/timestamptz -> Time
+      #   date                  -> Date
+      #   text/varchar          -> String (unchanged)
+      #
+      # The map is set on the *connection*, so it applies uniformly to both
+      # ``exec`` and ``exec_params`` and therefore to every fetch / fetch_one /
+      # columns path that flows through execute_query.
+      #
+      # uuid / json / jsonb / regclass have no built-in coder; left alone the
+      # map prints a noisy "no type cast defined" warning to stderr and falls
+      # back to a raw string anyway. We register explicit text decoders for them
+      # so they stay plain strings (the documented behaviour) without the
+      # warning — regclass matters because table_exists? selects to_regclass().
+      # bytea is already handled by the map as an ASCII-8BIT binary string,
+      # which is what decode_blobs expects.
+      def apply_result_type_map(conn)
+        type_map = PG::BasicTypeMapForResults.new(conn)
+        register_text_decoders(conn, type_map, %w[uuid json jsonb regclass])
+        conn.type_map_for_results = type_map
+      rescue PG::Error, NameError
+        # If the type map can't be built (e.g. a minimal pg build without
+        # BasicTypeMapForResults, or a connection that can't resolve OIDs),
+        # leave results as strings rather than breaking the connection.
+        nil
+      end
+
+      # Register a plain-text decoder for each named PostgreSQL type so the
+      # result map returns it unchanged as a String instead of warning that no
+      # cast is defined. Unknown type names are skipped silently.
+      def register_text_decoders(conn, type_map, type_names)
+        type_names.each do |name|
+          oid = conn.exec_params("SELECT $1::regtype::oid", [name]).getvalue(0, 0).to_i
+          type_map.add_coder(PG::TextDecoder::String.new(oid: oid, name: name, format: 0))
+        rescue PG::Error
+          next
+        end
+      end
+
       def convert_placeholders(sql)
         counter = 0
         sql.gsub("?") { counter += 1; "$#{counter}" }

data/lib/tina4/field_types.rb

@@ -84,7 +84,12 @@ module Tina4
       # Automatically:
       #   - Registers an integer field for the column
       #   - Calls belongs_to on this class (strip _id suffix for association name)
-      #   - Calls has_many on the referenced class (if already loaded)
+      #   - Calls has_many on the referenced class. The accessor name is the
+      #     declaring class name lowercased + "s" (e.g. Post → posts), matching
+      #     Python; override with related_name:. Works whether the referenced
+      #     class loaded before OR after this one, including the string form
+      #     (references: "Author") for forward references — resolution is
+      #     deferred via Tina4::ORM.inherited until the target class exists.
       #
       # @param name [Symbol]  Column name (e.g. :user_id)
       # @param references [Class, String]  Referenced model class or its name
@@ -122,12 +127,45 @@ module Tina4
           has_many_name: hm_key.to_sym,
           foreign_key: name.to_s
         }
+
+        # If the referenced model is ALREADY loaded (string form whose target
+        # is defined, or any forward reference that has since resolved), wire
+        # the deferred entry right now. The inherited hook on Tina4::ORM only
+        # fires when a NEW class is defined, so a string reference to a class
+        # that loaded BEFORE this one would otherwise never wire its has_many
+        # side. resolve_referenced_class returns the live class for either the
+        # Class or the string form.
+        resolved = resolve_referenced_class(references)
+        resolved.apply_fk_registry! if resolved && resolved.respond_to?(:apply_fk_registry!, true)
+      end
+
+      # Resolve a ForeignKeyField `references:` argument to a live Tina4::ORM
+      # subclass, or nil if it is not (yet) loaded. Accepts either a Class or a
+      # class-name String (with or without a namespace). The string form is the
+      # documented deferred-safe path: a bare constant used before its class is
+      # defined raises NameError (plain Ruby), so forward references must be
+      # written as strings.
+      def resolve_referenced_class(references)
+        return references if references.is_a?(Class)
+        return nil unless defined?(Tina4::ORM) && Tina4::ORM.respond_to?(:model_subclasses)
+
+        simple = references.to_s.split("::").last
+        Tina4::ORM.model_subclasses.find do |klass|
+          klass.name && klass.name.split("::").last == simple
+        end
+      rescue StandardError
+        nil
       end
 
       # Apply any deferred FK-registry has_many wiring for this class.
       # Called automatically when a class that is referenced by a ForeignKeyField is defined.
       def apply_fk_registry!
-        class_simple_name = self.name.split("::").last
+        # Anonymous classes (Class.new(Tina4::ORM), common in specs) have a nil
+        # name and can never be a string-form ForeignKeyField target, so there
+        # is nothing to wire — bail out instead of raising on nil.split.
+        return if name.nil?
+
+        class_simple_name = name.split("::").last
         return unless defined?(@@_fk_registry) && @@_fk_registry.key?(class_simple_name)
 
         @@_fk_registry[class_simple_name].each do |entry|

data/lib/tina4/orm.rb

@@ -16,6 +16,29 @@ module Tina4
   class ORM
     include Tina4::FieldTypes
 
+    # When a new model class is defined, resolve any deferred ForeignKeyField
+    # wiring that targets it. The string / forward-reference form of
+    # `foreign_key_field` (e.g. `references: "Author"`) records the has_many
+    # side in @@_fk_registry but cannot wire it until the referenced class
+    # actually loads — which is now. Without this hook apply_fk_registry! was
+    # never called, so the has_many side silently never wired. The class body
+    # (where the model's own foreign_key_field declarations run, populating the
+    # registry) executes AFTER inherited returns, so entries keyed on THIS
+    # class were already recorded by earlier-loaded models. Chain through super
+    # so we never clobber a future inherited hook.
+    def self.inherited(subclass)
+      super
+      (@_model_subclasses ||= []) << subclass
+      subclass.apply_fk_registry! if subclass.respond_to?(:apply_fk_registry!, true)
+    end
+
+    # Every Tina4::ORM subclass that has been loaded, in definition order.
+    # Mirrors Python's ORM.__subclasses__() — used to resolve string-form
+    # ForeignKeyField references to a live class.
+    def self.model_subclasses
+      @_model_subclasses ||= []
+    end
+
     class << self
       def db
         # v3.13.12: implicit binding from TINA4_DATABASE_URL.
@@ -132,7 +155,7 @@ module Tina4
       #
       # @return [Tina4::QueryBuilder]
       def query
-        QueryBuilder.from(table_name, db: db)
+        QueryBuilder.from_table(table_name, db: db)
       end
 
       def find(id_or_filter = nil, filter = nil, **kwargs)

data/lib/tina4/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.16
+  version: 3.13.18
 platform: ruby
 authors:
 - Tina4 Team