tina4ruby 3.13.17 → 3.13.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 198d9905bf51e280f45f2bba90aac40fd64ea1bdf0c0f0b29e9a80d5e95020c9
-  data.tar.gz: 74c01ef1ac870c47aebf57e686a9b3bd7efa46f5c56c1d78df4c378102ee39f2
+  metadata.gz: 93597b3b5afd4c56593d4c2d107b573790b68fbae4b0dd28f07d4f636a462381
+  data.tar.gz: c384790499ba27f16fc95efec1053a34c201d5444f742a9581167f6450418526
 SHA512:
-  metadata.gz: 03a840227106a3e2c12a78bde6c5d62ff8e4eb3041bc443fe73cad5e5d6d1dbd366ffa5458d34faeffe8448ad8fb19ce9bd74c821a4d3ec436ab80aa984b58fc
-  data.tar.gz: deefa98487ff855b8ad66beaa13b2e70f2b9f71677c0e317b52fc9153f43782a40723dc5519e814a2d65a29685fae18647f0bc84c124763aa8e5e7dcbddd07ca
+  metadata.gz: fd30dce3ddb8de6ec35fa4416f105b52df238951d723df7887ad24787a9e657bd04c90e904427dae4365faf602ef273cfb1716dcd655b15b0ac0caf45ecfa4d0
+  data.tar.gz: 1febfd89b40487edc5c51314d6bd5878ecd22244720959e58f54e56d90f2751d0543be833f4f0ddb2da51bcdee5ba8aa5d3c06d6723fe28df644ae4f6f2ef3db

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,16 +16,57 @@ 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.
-        # Resolution: per-class @db → global Tina4.database → env-derived
-        # auto-discovery. Pre-v3.13.12 this fell through to nil — the
-        # helper auto_discover_db existed but was never called.
-        @db || Tina4.database || auto_discover_db
+        # Resolution order:
+        #   1. @db is a Symbol/String → named connection from Tina4.databases
+        #      (bound via Tina4.bind_database(db, name:)). Raises a clear
+        #      error if that named connection was never registered.
+        #   2. @db is a Database/driver instance → use it directly.
+        #   3. Otherwise → global Tina4.database, else env-derived
+        #      auto-discovery (TINA4_DATABASE_URL). v3.13.12 wired this
+        #      fallback; before that auto_discover_db was never called.
+        case @db
+        when Symbol, String
+          name = @db.to_sym
+          Tina4.databases[name] || raise(
+            "Tina4 named database connection '#{@db}' is not registered for #{name}. " \
+            "Call Tina4.bind_database(db, name: #{@db.inspect}) before using this model."
+          )
+        when nil
+          Tina4.database || auto_discover_db
+        else
+          @db
+        end
       end
 
-      # Per-model database binding
+      # Per-model database binding.
+      #   self.db = some_database_instance   → use that connection
+      #   self.db = :analytics               → resolve a named connection
+      #                                         from Tina4.databases at access time
       def db=(database)
         @db = database
       end
@@ -132,7 +173,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)
@@ -453,8 +494,7 @@ module Tina4
       def auto_discover_db
         url = ENV["TINA4_DATABASE_URL"]
         return nil unless url
-        Tina4.database = Tina4::Database.new(url, username: ENV.fetch("TINA4_DATABASE_USERNAME", ""), password: ENV.fetch("TINA4_DATABASE_PASSWORD", ""))
-        Tina4.database
+        Tina4.bind_database(Tina4::Database.new(url, username: ENV.fetch("TINA4_DATABASE_USERNAME", ""), password: ENV.fetch("TINA4_DATABASE_PASSWORD", "")))
       end
 
       def find_by_filter(filter)
@@ -494,6 +534,15 @@ module Tina4
       @persisted = false
       @errors = []
       @relationship_cache = {}
+      # 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)
+      # A single model is one record — reject an Array with a clear message.
+      if attributes.is_a?(Array)
+        raise ArgumentError,
+              "#{self.class}.new expects a Hash, keyword args, or a JSON object string " \
+              "for one record — got an Array. Map over the list to build many records."
+      end
       attributes.each do |key, value|
         setter = "#{key}="
         __send__(setter, value) if respond_to?(setter)

data/lib/tina4/response.rb

@@ -80,6 +80,7 @@ module Tina4
     # Matches Python __call__ / PHP __invoke / Node response() pattern.
     def call(data = nil, status_code = 200, content_type = nil)
       @status_code = status_code
+      data = jsonable(data)
       if content_type
         @headers["content-type"] = content_type
         @body = data.to_s
@@ -96,10 +97,29 @@ module Tina4
     def json(data, status_or_opts = nil, status: nil)
       @status_code = status || (status_or_opts.is_a?(Integer) ? status_or_opts : 200)
       @headers["content-type"] = JSON_CONTENT_TYPE
+      data = jsonable(data)
       @body = data.is_a?(String) ? data : JSON.generate(data)
       self
     end
 
+    # Normalise domain objects into JSON-serialisable structures so handlers can
+    # `response.(model)` / `response.json(model)` without calling .to_h by hand:
+    #
+    #   response.json(user)            # ORM model      -> Hash
+    #   response.json(User.all)        # Array<ORM>      -> Array<Hash>
+    #   response.json(db.fetch(sql))   # DatabaseResult  -> Array<Hash>
+    #
+    # Plain Hash / Array / String pass through unchanged (Array members that are
+    # models are still converted).
+    def jsonable(data)
+      return data.to_h if data.is_a?(Tina4::ORM)
+      return data.records if data.is_a?(Tina4::DatabaseResult)
+      return data.map { |item| item.is_a?(Tina4::ORM) ? item.to_h : item } if data.is_a?(Array)
+
+      data
+    end
+    private :jsonable
+
     def html(content, status_or_opts = nil, status: nil)
       @status_code = status || (status_or_opts.is_a?(Integer) ? status_or_opts : 200)
       @headers["content-type"] = HTML_CONTENT_TYPE

data/lib/tina4/seeder.rb

@@ -373,7 +373,7 @@ module Tina4
 
     db = Tina4.database
     unless db
-      Tina4::Log.error("Seeder: No database connection. Set Tina4.database first.")
+      Tina4::Log.error("Seeder: No database connection. Call Tina4.bind_database(db) first.")
       return 0
     end
 

data/lib/tina4/version.rb

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

data/lib/tina4.rb

@@ -120,7 +120,26 @@ module Tina4
   BANNER
 
   class << self
-    attr_accessor :root_dir, :database
+    attr_accessor :root_dir
+    attr_reader :database
+
+    # Bind a database connection.
+    #   bind_database(db)                  → sets the global default (Tina4.database)
+    #   bind_database(db, name: :analytics) → registers a named connection
+    # A model with `self.db = :analytics` resolves from this named registry;
+    # otherwise models fall back to the global default / TINA4_DATABASE_URL.
+    def bind_database(db, name: nil)
+      if name.nil?
+        @database = db
+      else
+        (@databases ||= {})[name.to_sym] = db
+      end
+      db
+    end
+
+    # Named connection registry. bind_database(db, name:) populates it;
+    # models with a Symbol/String `self.db` resolve against it.
+    def databases = (@databases ||= {})
 
     def print_banner(host: "0.0.0.0", port: 7147, server_name: nil)
       # TINA4_SUPPRESS — short-circuit ALL banner output for headless / CI runs.
@@ -450,7 +469,7 @@ module Tina4
       db_url = ENV["TINA4_DATABASE_URL"]
       if db_url && !db_url.empty?
         begin
-          @database = Tina4::Database.new(db_url)
+          bind_database(Tina4::Database.new(db_url))
           Tina4::Log.info("Database connected: #{db_url.sub(/:[^:@]+@/, ':***@')}")
         rescue => e
           Tina4::Log.error("Database connection failed: #{e.message}")

metadata

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