declare_schema 3.1.0.colin.3 → 4.0.1.colin.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ddb4bb46a974562b49103da5ead57c6ece3d2e7ef76acee4e5b8415df3da761
-  data.tar.gz: 652addeb7c6a6a3c4e1e81dbcdf91250d7c5e8884a1f9084e5dcad61b13abab6
+  metadata.gz: '09079a0e965a85eba22eade7bc713fcacf35d4fd6f874e9d8b41eb36f8e6901e'
+  data.tar.gz: b7f0fa06ec76c298d2b9248ef10b6a1010d36bf2edb3c3a667f57790d98bb6b5
 SHA512:
-  metadata.gz: ac38c743e5e469e23a0aee102e8dd6222f6f40004d74dfd8f5503b14e93ee9ce1a2c314f4468f4c110d0821a4b6717f97de32492636c9925252db4a49d278931
-  data.tar.gz: c6758a1c6a3f389cb59a0a0e4b5aace6a02f83d91e943eb1fb9d9d8639ab6bd499b383ced560bf9e58f1934a90460d25607c2b25b62cf2cd024cb0067e3681c6
+  metadata.gz: 5cb66b34c4d70e0673106ee94fec485e7e5eec25e34b75a64a94e0d3fea9f6f822157dadc8b662ba57af9878c3686807be1ab97b01ce89b8de3b3354c2dfd3a9
+  data.tar.gz: 6359500ff616315a48dd3921a9fac1b9d51e3a24c1dfb1b761160b048da1ef8222d036f60b6e5d2d5e5b74de5f12e44c2db70717a985257be420d78fcbe7f64d

data/.github/workflows/pipeline.yml

@@ -48,7 +48,7 @@ jobs:
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{matrix.ruby}}
-          bundler: latest
+          bundler: 2.5
           bundler-cache: true
       - name: Setup
         run: |

data/CHANGELOG.md

@@ -4,9 +4,20 @@ Inspired by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 Note: this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [3.1.0] - Unreleased
+## [4.0.1] - 2026-05-06
+### Fixed
+- `DeferredFieldSpec` (the lazy stand-in introduced in 4.0.0 for `belongs_to`
+  foreign-key field specs) now transparently delegates the `FieldSpec` read
+  API (`.options`, `.type`, `.limit`, `.null`, etc.) to its memoized resolved
+  spec. Application code that reads `Model.field_specs[name].options` at
+  runtime would raise `NoMethodError: undefined method 'options' for an
+  instance of DeclareSchema::Model::DeferredFieldSpec`.
+
+## [4.0.0] - 2026-05-05
 ### Added
-- Add HABTM support for arbitrary primary key in the referenced table (rather than just :bigint). 
+- Generalized `belongs_to` foreign keys to always match the primary key they point at, including
+  in HABTM intersection tables. (Previously this was just a special case that matched up
+  :integer vs :bigint.)
 
 ### Removed
 - Drop support for Rails 6.x. Minimum supported Rails is now 7.0.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    declare_schema (3.1.0.colin.3)
+    declare_schema (4.0.1.colin.1)
       rails (>= 7.0)
 
 GEM

data/lib/declare_schema/model/deferred_field_spec.rb

@@ -12,7 +12,7 @@ module DeclareSchema
     # The migrator calls {#resolve} on every value in `field_specs` at the start
     # of migration generation (see `Migrator#generate`); for plain {FieldSpec}s
     # `#resolve` is a no-op returning self, while for instances of this class it
-    # invokes the block (memoized) with the default spec and returns the produced
+    # invokes the resolver block with the default spec and returns the produced
     # {FieldSpec}.
     class DeferredFieldSpec
       # @param default_spec [FieldSpec] the eager placeholder spec
@@ -24,14 +24,26 @@ module DeclareSchema
         @resolver = resolver
       end
 
-      # Invoke the resolver block with the default spec and return its result.
-      # The migrator's `transform_values!(&:resolve)` swaps this DeferredFieldSpec
-      # out of `field_specs` for the produced FieldSpec, so resolve is called
-      # exactly once per instance in production -- no memoization needed.
+      # Resolve and memoize the produced FieldSpec. Memoization matters because
+      # application code can hit several FieldSpec accessors per request (e.g.
+      # ModelReport reads `.options`, ApplicationModel reads `.limit`); without
+      # it each one would re-run the resolver and re-touch `reflection.klass`.
       #
       # @return [FieldSpec]
       def resolve
-        @resolver.call(@default_spec)
+        @resolved ||= @resolver.call(@default_spec)
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        resolve.respond_to?(name, include_private) || super
+      end
+
+      def method_missing(name, *args, **kwargs, &)
+        if resolve.respond_to?(name)
+          resolve.public_send(name, *args, **kwargs, &)
+        else
+          super
+        end
       end
     end
   end

data/lib/declare_schema/model.rb

@@ -371,13 +371,15 @@ module DeclareSchema
 
       # @param klass [Class] any ActiveRecord class
       # @return [ActiveRecord::ConnectionAdapters::Column, nil] the live PK column, or
-      #   nil when the table doesn't exist yet or can't otherwise be inspected. Reads
-      #   via `columns_hash` directly (not `_column`, whose `@table_exists` memoization
-      #   can pin a stale answer) so a parent table being created in this same
-      #   migration run is honored.
+      #   nil when the table doesn't exist yet or can't otherwise be inspected, or
+      #   when the model has a compound primary key (Array PK name misses
+      #   `columns_hash`). Reads via `columns_hash` directly (not `_column`, whose
+      #   `@table_exists` memoization can pin a stale answer) so a parent table
+      #   being created in this same migration run is honored.
       def _pk_column_for(klass)
-        pk_name = klass.respond_to?(:_declared_primary_key) ? klass._declared_primary_key : klass.primary_key
-        klass.columns_hash[pk_name.to_s] if pk_name
+        if (pk_name = klass.try(:_declared_primary_key) || klass.primary_key)
+          klass.columns_hash[pk_name]
+        end
       rescue ActiveRecord::StatementInvalid, ActiveRecord::NoDatabaseError
         nil
       end
@@ -391,13 +393,25 @@ module DeclareSchema
       #   the column type doesn't round-trip cleanly
       def _field_spec_options_from_pk_column(column)
         if column&.type == :integer
-          column.limit == 8 ? [:bigint, {}] : [:integer, { limit: column.limit || 4 }]
+          if column.limit == 8
+            [:bigint, {}]
+          else
+            [:integer, { limit: column.limit || 4 }]
+          end
         end
       end
 
       # `declare_schema id: ...` accepts either a Hash (`id: { type: :integer, limit: 4 }`)
-      # or a bare type Symbol (`id: :integer`). Returns [type, options_hash], with type == nil
-      # when value is neither (caller falls back to a default).
+      # or a bare type Symbol (`id: :integer`). Normalizes both shapes -- plus the
+      # absent / unrecognized case -- into a uniform `[type, options]` pair so the
+      # caller (`_primary_key_field_spec_from_table_options`) can dispatch on
+      # `type.nil?` to decide whether to fall back to live-PK inspection or the
+      # gem default.
+      #
+      # @param value [Hash, Symbol, nil] the per-PK entry from `_table_options`
+      # @return [Array(Symbol, Hash), Array(nil, Hash)] `[type, options]` where
+      #   `type` is nil when `value` is neither a Hash nor a Symbol (signal to
+      #   caller to fall back). `options` always excludes `:type`.
       def _parse_pk_table_options(value)
         case value
         when Hash   then [value[:type], value.except(:type)]

data/lib/declare_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeclareSchema
-  VERSION = "3.1.0.colin.3"
+  VERSION = "4.0.1.colin.1"
 end

data/lib/generators/declare_schema/migration/migrator.rb

@@ -80,7 +80,16 @@ module Generators
           self.class.native_types
         end
 
-        # return habtm reflections keyed by join table name (so that habtm from each side has just one entry)
+        # Collect every HABTM reflection across the application, keyed by its join
+        # table name. Each join table is shared by both sides of a HABTM
+        # association, so iterating all descendants would yield two reflections
+        # per join table (one from each parent model). Keying by `join_table` and
+        # using `||=` keeps the first occurrence and silently drops the duplicate
+        # from the other side, so the migrator emits exactly one shim per join
+        # table.
+        #
+        # @return [Hash{String => ActiveRecord::Reflection::HasAndBelongsToManyReflection}]
+        #   join table name -> the (first-seen) HABTM reflection that owns it
         def habtm_tables
           ActiveRecord::Base.send(:descendants).each_with_object({}) do |c, result|
             c.reflect_on_all_associations(:has_and_belongs_to_many).each do |a|

data/spec/lib/declare_schema/deferred_field_spec_spec.rb

@@ -24,5 +24,61 @@ RSpec.describe DeclareSchema::Model::DeferredFieldSpec do
       expect(deferred.resolve).to equal(mirrored_spec)
       expect(captured).to equal(default_spec)
     end
+
+    it 'memoizes the resolver result so repeated calls invoke it only once' do
+      call_count = 0
+      deferred = described_class.new(default_spec) do |_|
+        call_count += 1
+        mirrored_spec
+      end
+
+      3.times { deferred.resolve }
+
+      expect(call_count).to eq(1)
+    end
+  end
+
+  # Application code (e.g. ModelReport reading `field_specs[name].options[:rr_report_options]`)
+  # reads from `field_specs` without first calling `.resolve`. The deferred spec must
+  # therefore quack like the resolved FieldSpec; otherwise we get NoMethodError at runtime
+  # in apps that read FieldSpec attributes, AND we'd return a wrong default-typed answer
+  # (e.g. :bigint when the parent's PK is actually :integer or :binary).
+  describe 'FieldSpec API delegation' do
+    let(:deferred) { described_class.new(default_spec) { mirrored_spec } }
+
+    it 'delegates #options to the resolved spec (parent-mirrored, not default)' do
+      expect(deferred.options).to eq(mirrored_spec.options)
+    end
+
+    it 'delegates #type to the resolved spec' do
+      expect(deferred.type).to eq(:string)
+    end
+
+    it 'delegates #limit to the resolved spec' do
+      expect(deferred.limit).to eq(36)
+    end
+
+    it 'delegates #null to the resolved spec' do
+      expect(deferred.null).to eq(false)
+    end
+
+    it 'reports respond_to? for delegated methods' do
+      expect(deferred).to respond_to(:options, :type, :limit, :null, :name, :position)
+    end
+
+    it 'invokes the resolver only once across many delegated reads' do
+      call_count = 0
+      deferred = described_class.new(default_spec) do |_|
+        call_count += 1
+        mirrored_spec
+      end
+
+      deferred.options
+      deferred.type
+      deferred.limit
+      deferred.null
+
+      expect(call_count).to eq(1)
+    end
   end
 end

data/spec/lib/generators/declare_schema/migration/migrator_default_pk_type_spec.rb

@@ -12,11 +12,11 @@ RSpec.describe 'DeclareSchema.default_generated_primary_key_type integration wit
   include_context 'prepare test app'
 
   before do
-    if current_adapter == 'mysql2'
-      ActiveRecord::Base.connection.execute("CREATE TABLE foos (id int PRIMARY KEY, name varchar(250))")
-    else
-      ActiveRecord::Base.connection.execute("CREATE TABLE foos (id integer PRIMARY KEY AUTOINCREMENT NOT NULL, name varchar(250))")
-    end
+    # Cross-adapter DDL: `integer PRIMARY KEY NOT NULL` works on sqlite, mysql, and
+    # postgres. AUTOINCREMENT (sqlite) / AUTO_INCREMENT (mysql) / SERIAL (postgres)
+    # would all be valid, but the migrator inspects type/null, not auto-increment
+    # metadata, so we can skip the auto-increment dance entirely.
+    ActiveRecord::Base.connection.execute("CREATE TABLE foos (id integer PRIMARY KEY NOT NULL, name varchar(250))")
     ActiveRecord::Base.connection.schema_cache.clear!
 
     allow_any_instance_of(DeclareSchema::Support::ThorShell)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: declare_schema
 version: !ruby/object:Gem::Version
-  version: 3.1.0.colin.3
+  version: 4.0.1.colin.1
 platform: ruby
 authors:
 - Invoca Development adapted from hobo_fields by Tom Locke
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-04 00:00:00.000000000 Z
+date: 2026-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails