active_record_compose 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9cdfb23b1af43681e6c4af3e9fed615bc3dc64873461bdee6f49c92f706f33e9
-  data.tar.gz: 4530c0987f038605cb6dc3da229df21e8cf16af29d6ca8cf3078b1dc933cc838
+  metadata.gz: 76bd8c66869f7b24c2938ecb72cf2c3b9f47cdcc34a8e1c87f57329f50880ecd
+  data.tar.gz: f6efc5ec40f5e870064dec9928e56a3ee8a3ca07ea00bd5dcbe86f0855d440ce
 SHA512:
-  metadata.gz: 10c37b41ff66acd993e2f5c412ed5f48213f29344a94e0ab27d40766e11f60197808d4d1b9e97118f729b4be1d272a4bdae100c8e06489c40008ac3c92f6fe61
-  data.tar.gz: 67c4086fce4661e89188161fd6d23610bca3dcb9ad8a6e781162909d07fbf750add3ad804d8e58bd92bf4fc1305bcebd2452a4a9d924af70e56e6a0217ecf70f
+  metadata.gz: c0361c3c95394e550e8571ea4880545dd8e566e9a6d4c829eb494db90226c009487361ca7eed8e3691d6dbf59674e7fc2fa782b2db006b79113c95c5b229f95c
+  data.tar.gz: 2a2ac6e1d86640c8d7df1448fc362e459790561a8223066351cadd7ea297e456bc093a015fb8a765e755deccbd5071e342fe035180a4c222ce81584305388085

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## [Unreleased]
 
+## [1.1.0] - 2025-11-19
+
+* Implemented ActiveRecord-like #inspect
+  In activerecord's `#inspect`, the string is a list of attributes, and we have reproduced a similar format.
+  (https://github.com/hamajyotan/active_record_compose/pull/45)
+* `.with_connection` `.lease_connection` and `.connection` are deprecated. Use `ActiveRecord::Base.with_connection` etc. instead.
+  (https://github.com/hamajyotan/active_record_compose/pull/46)
+* refactor: Remove `ActiveRecord::Transactions` module dependency
+  (https://github.com/hamajyotan/active_record_compose/pull/44)
+
+## [1.0.1] - 2025-10-17
+
+* Removed the private interface `composite_primary_key?`
+  This was previously an internal ActiveRecord dependency, but was not exposed in the release version.
+  (https://github.com/hamajyotan/active_record_compose/pull/39)
+* Relaxed ActiveRecord dependency upper bound to < 8.2
+  (https://github.com/hamajyotan/active_record_compose/pull/42)
+
 ## [1.0.0] - 2025-09-23
 
 - drop support rails 7.0.x

data/README.md

@@ -120,6 +120,12 @@ registration.update!(
   email_confirmation: "bar@example.com",
   terms_of_service: true,
 )
+# `#update!` SQL log
+#   BEGIN immediate TRANSACTION
+#   INSERT INTO "accounts" ("created_at", "email", "name", "updated_at") VALUES (...
+#   INSERT INTO "profiles" ("account_id", "age", "created_at", "firstname", "lastname", ...
+#   COMMIT TRANSACTION
+
 
 # === Or, in a Rails controller with strong parameters ===
 class UserRegistrationsController < ApplicationController

data/lib/active_record_compose/inspectable.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "active_support/parameter_filter"
+require_relative "attributes"
+
+module ActiveRecordCompose
+  # @private
+  #
+  # It provides #inspect behavior.
+  # It tries to replicate the inspect format provided by ActiveRecord as closely as possible.
+  #
+  # @example
+  #   class Model < ActiveRecordCompose::Model
+  #     def initialize(ar_model)
+  #       @ar_model = ar_model
+  #       super
+  #     end
+  #
+  #     attribute :foo, :date, default: -> { Date.today }
+  #     delegate_attribute :bar, to: :ar_model
+  #
+  #     private attr_reader :ar_model
+  #   end
+  #
+  #   m = Model.new(ar_model)
+  #   m.inspect  #=> #<Model:0x00007ff0fe75fe58 foo: "2025-11-14", bar: "bar">
+  #
+  # @example
+  #   class Model < ActiveRecordCompose::Model
+  #     self.filter_attributes += %i[foo]
+  #
+  #     # ...
+  #   end
+  #
+  #   m = Model.new(ar_model)
+  #   m.inspect  #=> #<Model:0x00007ff0fe75fe58 foo: [FILTERED], bar: "bar">
+  #
+  module Inspectable
+    extend ActiveSupport::Concern
+    include ActiveRecordCompose::Attributes
+
+    included do
+      self.filter_attributes = []
+    end
+
+    module ClassMethods
+      def filter_attributes
+        if @filter_attributes.nil?
+          superclass.filter_attributes # steep:ignore
+        else
+          @filter_attributes
+        end
+      end
+
+      def filter_attributes=(value)
+        @inspection_filter = nil
+        @filter_attributes = value
+      end
+
+      # steep:ignore:start
+
+      def inspection_filter
+        if @filter_attributes.nil?
+          superclass.inspection_filter
+        else
+          @inspection_filter ||= ActiveSupport::ParameterFilter.new(filter_attributes, mask: FILTERED_MASK)
+        end
+      end
+
+      private
+
+      def inherited(subclass)
+        super
+
+        subclass.class_eval do
+          @inspection_filter = nil
+          @filter_attributes ||= nil
+        end
+      end
+
+      FILTERED_MASK =
+        Class.new(DelegateClass(::String)) do
+          def pretty_print(pp)
+            pp.text __getobj__
+          end
+        end.new(ActiveSupport::ParameterFilter::FILTERED).freeze
+      private_constant :FILTERED_MASK
+
+      # steep:ignore:end
+    end
+
+    # Returns a formatted string representation of the record's attributes.
+    #
+    def inspect
+      inspection =
+        if @attributes
+          attributes.map { |k, v| "#{k}: #{format_for_inspect(k, v)}" }.join(", ")
+        else
+          "not initialized"
+        end
+
+      "#<#{self.class} #{inspection}>"
+    end
+
+    # It takes a PP and pretty prints that record.
+    #
+    def pretty_print(pp)
+      pp.object_address_group(self) do
+        if @attributes
+          attrs = attributes
+          pp.seplist(attrs.keys, proc { pp.text "," }) do |attr|
+            pp.breakable " "
+            pp.group(1) do
+              pp.text attr
+              pp.text ":"
+              pp.breakable
+              pp.text format_for_inspect(attr, attrs[attr])
+            end
+          end
+        else
+          pp.breakable " "
+          pp.text "not initialized"
+        end
+      end
+    end
+
+    private
+
+    def format_for_inspect(name, value)
+      return value.inspect if value.nil?
+
+      inspected_value =
+        if value.is_a?(String) && value.length > 50
+          "#{value[0, 50]}...".inspect
+        elsif value.is_a?(Date) || value.is_a?(Time)
+          %("#{value.to_fs(:inspect)}")
+        else
+          value.inspect
+        end
+
+      self.class.inspection_filter.filter_param(name, inspected_value)
+    end
+  end
+end

data/lib/active_record_compose/model.rb

@@ -2,6 +2,7 @@
 
 require_relative "attributes"
 require_relative "composed_collection"
+require_relative "inspectable"
 require_relative "persistence"
 require_relative "transaction_support"
 require_relative "validations"
@@ -86,6 +87,7 @@ module ActiveRecordCompose
     include ActiveRecordCompose::Persistence
     include ActiveRecordCompose::Validations
     include ActiveRecordCompose::TransactionSupport
+    include ActiveRecordCompose::Inspectable
 
     begin
       # @group Model Core
@@ -282,7 +284,7 @@ module ActiveRecordCompose
       #   The need for such a value indicates that operations from multiple contexts are being processed.
       #   If the contexts differ, we recommend separating them into different model definitions.
       #
-      #   @params [Hash] Optional parameters.
+      #   @param options [Hash] parameters.
       #   @option options [Boolean] :validate Whether to run validations.
       #     This option is intended for internal use only.
       #     Users should avoid explicitly passing <tt>validate: false</tt>,
@@ -351,14 +353,80 @@ module ActiveRecordCompose
       #   Registers a block to be called after the transaction is rolled back.
 
       # @endgroup
-    end
 
-    # @group Model Core
+      # @!method inspect
+      #   Returns a formatted string representation of the record's attributes.
+      #   It tries to replicate the inspect format provided by ActiveRecord as closely as possible.
+      #
+      #   @example
+      #     class Model < ActiveRecordCompose::Model
+      #       def initialize(ar_model)
+      #         @ar_model = ar_model
+      #         super
+      #       end
+      #
+      #       attribute :foo, :date, default: -> { Date.today }
+      #       delegate_attribute :bar, to: :ar_model
+      #
+      #       private attr_reader :ar_model
+      #     end
+      #
+      #     m = Model.new(ar_model)
+      #     m.inspect  #=> #<Model:0x00007ff0fe75fe58 foo: "2025-11-14", bar: "bar">
+      #
+      #   @example use {.filter_attributes}
+      #     class Model < ActiveRecordCompose::Model
+      #       self.filter_attributes += %i[foo]
+      #
+      #       # ...
+      #     end
+      #
+      #     m = Model.new(ar_model)
+      #     m.inspect  #=> #<Model:0x00007ff0fe75fe58 foo: [FILTERED], bar: "bar">
+      #
+      #   @return [String] formatted string representation of the record's attributes.
+      #   @see .filter_attributes
+
+      # @!method self.filter_attributes
+      #   Returns columns not to expose when invoking {#inspect}.
+      #   @return [Array<Symbol>]
+      #   @see #inspect
+
+      # @!method self.filter_attributes=(value)
+      #   Specify columns not to expose when invoking {#inspect}.
+      #   @param [Array<Symbol>] value
+      #   @see #inspect
+    end
 
     def initialize(attributes = {})
       super
     end
 
+    # Returns the ID value. This value is used when passing it to the `:model` option of `form_with`, etc.
+    # Normally it returns nil, but it can be overridden to delegate to the containing model.
+    #
+    # @example Redefine the id method by delegating to the containing model
+    #     class Foo < ActiveRecordCompose::Model
+    #       def initialize(primary_model)
+    #         @primary_model = primary_model
+    #         # ...
+    #       end
+    #
+    #       def id
+    #         primary_model.id
+    #       end
+    #
+    #       private
+    #
+    #       attr_reader :primary_model
+    #     end
+    #
+    # @return [Object] ID value
+    #
+    def id = nil
+
+    # @group Model Core
+
     private
 
     # Returns a collection of model elements to encapsulate.

data/lib/active_record_compose/railtie.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rails"
+require "active_record_compose"
+require "active_record/railtie"
+
+module ActiveRecordCompose
+  class Railtie < Rails::Railtie
+    initializer "active_record_compose.set_filter_attributes", after: "active_record.set_filter_attributes" do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecordCompose::Model.filter_attributes += ActiveRecord::Base.filter_attributes
+      end
+    end
+  end
+end

data/lib/active_record_compose/transaction_support.rb

@@ -1,35 +1,130 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/module"
+
 module ActiveRecordCompose
   # @private
   module TransactionSupport
     extend ActiveSupport::Concern
-    include ActiveRecord::Transactions
 
     included do
-      # ActiveRecord::Transactions is defined so that methods such as save,
-      # destroy and touch are wrapped with_transaction_returning_status.
-      # However, ActiveRecordCompose::Model does not support destroy and touch, and
-      # we want to keep these operations as undefined behavior, so we remove the definition here.
-      undef_method :destroy, :touch
+      define_callbacks :commit, :rollback, :before_commit, scope: [ :kind, :name ]
     end
 
     module ClassMethods
-      delegate :with_connection, :lease_connection, to: :ar_class
+      # steep:ignore:start
+
+      # @deprecated
+      def with_connection(...)
+        ActiveRecord.deprecator.warn("`with_connection` is deprecated. Use `ActiveRecord::Base.with_connection` instead.")
+        ActiveRecord::Base.with_connection(...)
+      end
+
+      # @deprecated
+      def lease_connection(...)
+        ActiveRecord.deprecator.warn("`lease_connection` is deprecated. Use `ActiveRecord::Base.lease_connection` instead.")
+        ActiveRecord::Base.lease_connection(...)
+      end
+
+      # @deprecated
+      def connection(...)
+        ActiveRecord.deprecator.warn("`connection` is deprecated. Use `ActiveRecord::Base.connection` instead.")
+        ActiveRecord::Base.connection(...)
+      end
 
-      # In ActiveRecord, it is soft deprecated.
-      delegate :connection, to: :ar_class
+      # steep:ignore:end
 
-      def composite_primary_key? = false # steep:ignore
+      def before_commit(*args, &block)
+        set_options_for_callbacks!(args)
+        set_callback(:before_commit, :before, *args, &block) # steep:ignore
+      end
+
+      def after_commit(*args, &block)
+        set_options_for_callbacks!(args, prepend_option)
+        set_callback(:commit, :after, *args, &block) # steep:ignore
+      end
+
+      def after_rollback(*args, &block)
+        set_options_for_callbacks!(args, prepend_option)
+        set_callback(:rollback, :after, *args, &block) # steep:ignore
+      end
 
       private
 
-      def ar_class = ActiveRecord::Base
+      def prepend_option
+        if ActiveRecord.run_after_transaction_callbacks_in_order_defined # steep:ignore
+          { prepend: true }
+        else
+          {}
+        end
+      end
+
+      def set_options_for_callbacks!(args, enforced_options = {})
+        options = args.extract_options!.merge!(enforced_options)
+        args << options
+      end
     end
 
-    def id = nil
+    def save(**options) = with_transaction_returning_status { super }
+
+    def save!(**options) = with_transaction_returning_status { super }
+
+    concerning :SupportForActiveRecordConnectionAdaptersTransaction do
+      def trigger_transactional_callbacks? = true
+
+      def before_committed!
+        _run_before_commit_callbacks
+      end
+
+      def committed!(should_run_callbacks: true)
+        _run_commit_callbacks if should_run_callbacks
+      end
+
+      def rolledback!(force_restore_state: false, should_run_callbacks: true)
+        _run_rollback_callbacks if should_run_callbacks
+      end
+    end
 
-    def trigger_transactional_callbacks? = true
-    def restore_transaction_record_state(_force_restore_state = false) = nil
+    private
+
+    def with_transaction_returning_status
+      connection_pool.with_connection do |connection|
+        with_pool_transaction_isolation_level(connection) do
+          ensure_finalize = !connection.transaction_open?
+
+          connection.transaction do
+            connection.add_transaction_record(self, ensure_finalize || has_transactional_callbacks?) # steep:ignore
+
+            yield.tap { raise ActiveRecord::Rollback unless _1 }
+          end
+        end
+      end
+    end
+
+    def default_ar_class = ActiveRecord::Base
+
+    def connection_pool(ar_class: default_ar_class)
+      connection_specification_name = ar_class.connection_specification_name
+      role = ar_class.current_role
+      shard = ar_class.current_shard # steep:ignore
+      connection_handler = ar_class.connection_handler # steep:ignore
+      retrieve_options = { role:, shard: }
+      retrieve_options[:strict] = true if ActiveRecord.gem_version.release >= Gem::Version.new("7.2.0")
+
+      connection_handler.retrieve_connection_pool(connection_specification_name, **retrieve_options)
+    end
+
+    def with_pool_transaction_isolation_level(connection, &block)
+      if ActiveRecord.gem_version.release >= Gem::Version.new("8.1.0")
+        isolation_level = ActiveRecord.default_transaction_isolation_level # steep:ignore
+        connection.pool.with_pool_transaction_isolation_level(isolation_level, connection.transaction_open?, &block)
+      else
+        block.call
+      end
+    end
+
+    def has_transactional_callbacks?
+      _rollback_callbacks.present? || _commit_callbacks.present? || _before_commit_callbacks.present? # steep:ignore
+    end
   end
 end

data/lib/active_record_compose/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordCompose
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/active_record_compose.rb

@@ -11,3 +11,5 @@ require_relative "active_record_compose/model"
 #
 module ActiveRecordCompose
 end
+
+require "active_record_compose/railtie" if defined?(::Rails::Railtie)

data/sig/_internal/package_private.rbs

@@ -6,6 +6,8 @@ module ActiveRecordCompose
 
     def delegated_attributes: () -> Array[Delegation]
 
+    @attributes: untyped
+
     module ClassMethods : Module
       include ActiveModel::Attributes::ClassMethods
       include ActiveModel::AttributeMethods::ClassMethods
@@ -83,6 +85,29 @@ module ActiveRecordCompose
     include PackagePrivate
   end
 
+  module Inspectable
+    extend ActiveSupport::Concern
+    include Attributes
+    extend Inspectable::ClassMethods
+
+    def inspect: () -> String
+    def pretty_print: (untyped q) -> void
+
+    private
+    def format_for_inspect: (String name, untyped value) -> String
+
+    module ClassMethods
+      FILTERED_MASK: String
+
+      def inspection_filter: () -> ActiveSupport::ParameterFilter
+      def filter_attributes: () -> Array[untyped]
+      def filter_attributes=: (Array[untyped]) -> void
+
+      @inspection_filter: ActiveSupport::ParameterFilter?
+      @filter_attributes: untyped
+    end
+  end
+
   class Model
     include Attributes
     extend Attributes::ClassMethods
@@ -100,17 +125,30 @@ module ActiveRecordCompose
   module TransactionSupport
     extend ActiveSupport::Concern
     include ActiveRecord::Transactions
-
-    def id: -> untyped
+    extend TransactionSupport::ClassMethods
 
     module ClassMethods
-      def connection: -> ActiveRecord::ConnectionAdapters::AbstractAdapter
-      def lease_connection: -> ActiveRecord::ConnectionAdapters::AbstractAdapter
-      def with_connection: [T] () { () -> T } -> T
+      include ActiveSupport::Callbacks::ClassMethods
+
+      def before_commit: (*untyped) -> untyped
+      def after_commit: (*untyped) -> untyped
+      def after_rollback: (*untyped) -> untyped
 
       private
-      def ar_class: -> singleton(ActiveRecord::Base)
+      def prepend_option: -> ({ prepend: true } | {})
+      def set_options_for_callbacks!: (untyped, ?({ prepend: true } | {})) -> untyped
     end
+
+    def save: (**untyped options) -> bool
+    def save!: (**untyped options) -> untyped
+    def _run_before_commit_callbacks: () -> untyped
+    def _run_commit_callbacks: () -> untyped
+    def _run_rollback_callbacks: () -> untyped
+
+    private
+    def default_ar_class: -> singleton(ActiveRecord::Base)
+    def connection_pool: (?ar_class: singleton(ActiveRecord::Base)) -> ActiveRecord::ConnectionAdapters::ConnectionPool
+    def with_pool_transaction_isolation_level: [T] (ActiveRecord::ConnectionAdapters::AbstractAdapter) { () -> T } -> T
   end
 
   module Persistence
@@ -130,6 +168,10 @@ module ActiveRecordCompose
     def raise_on_save_error_message: -> String
   end
 
+  class Railtie < Rails::Railtie
+    extend Rails::Initializable::ClassMethods
+  end
+
   module Validations : Model
     extend ActiveSupport::Concern
     extend ActiveModel::Validations::ClassMethods

data/sig/active_record_compose.rbs

@@ -72,9 +72,9 @@ module ActiveRecordCompose
     def self.after_rollback: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void
 
     def self.delegate_attribute: (*untyped methods, to: untyped, ?allow_nil: bool) -> untyped
-    def self.connection: -> ActiveRecord::ConnectionAdapters::AbstractAdapter
-    def self.lease_connection: -> ActiveRecord::ConnectionAdapters::AbstractAdapter
-    def self.with_connection: [T] () { () -> T } -> T
+
+    def self.filter_attributes: () -> Array[untyped]
+    def self.filter_attributes=: (Array[untyped]) -> untyped
 
     def initialize: (?Hash[attribute_name, untyped]) -> void
     def save: (**untyped options) -> bool
@@ -82,6 +82,11 @@ module ActiveRecordCompose
     def update: (Hash[attribute_name, untyped]) -> bool
     def update!: (Hash[attribute_name, untyped]) -> untyped
 
+    def id: -> untyped
+
+    def inspect: () -> String
+    def pretty_print: (untyped q) -> void
+
     private
     def models: -> ComposedCollection
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_compose
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - hamajyotan
@@ -18,7 +18,7 @@ dependencies:
         version: '7.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.1'
+        version: '8.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -28,7 +28,7 @@ dependencies:
         version: '7.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.1'
+        version: '8.2'
 description: activemodel form object pattern. it embraces multiple AR models and provides
   a transparent interface as if they were a single model.
 email:
@@ -50,8 +50,10 @@ files:
 - lib/active_record_compose/attributes/querying.rb
 - lib/active_record_compose/callbacks.rb
 - lib/active_record_compose/composed_collection.rb
+- lib/active_record_compose/inspectable.rb
 - lib/active_record_compose/model.rb
 - lib/active_record_compose/persistence.rb
+- lib/active_record_compose/railtie.rb
 - lib/active_record_compose/transaction_support.rb
 - lib/active_record_compose/validations.rb
 - lib/active_record_compose/version.rb