active_record_compose 1.0.1 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8fa5fa4117b180d20233c6dc06ca8797c2c9931cca2708e5a01bd2b560c42d2
-  data.tar.gz: cdb73d45e04a3195f9834390f9e9b6e8242e4a9b325a6ec684d3c7c2f97076ef
+  metadata.gz: 491f46737a3744c5c5d3e0319de3ee9f64ae21a9adfab39f36cedc478bfa0e7c
+  data.tar.gz: 406f4c471e0d7c40ec7b3a0d492f8e7e6c96d93fd4b43204a128bf52c1f7ed4c
 SHA512:
-  metadata.gz: 2317d9e39b054c728b0847c6cde3f556edfcfa57de9b1c6023f10cf264f5c498bcf654e252d7a29c0a071d349ade5f00943e512938a427b6d253bd43592ebace
-  data.tar.gz: 71ad4690a7af527a1d323e3ccc84b25c0b7f875fcc3655883d0b8c2e35fe165b3b1f17a6201152e6d0281b21716976c77eec26db6c5712c0630d2741e6b72886
+  metadata.gz: 9ff0e91cfb0ca22322d1b9ca47c32f09372afa206e9fa6690c1dfe5ca30d221269ccc55fe17556627234ea8a7019118ddec8a46ad24a52c47239e694dbcac323
+  data.tar.gz: 925001a566ee81600ce91862c0c95f241dba2cd735f6ecbc3e987e83e6cd6f59d217e67afa4bed0a981f35c16645661ef7eeb00adb18df92999f9127e22116e0

data/.yardopts

@@ -1,4 +1,6 @@
 --private
+--no-private
 --markup markdown
 --markup-provider redcarpet
+--plugin activesupport-concern
 --default-return void

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## [Unreleased]
 
+## [1.1.1] - 2025-12-04
+
+* fix: the save method would return nil instead of false.
+* doc: We've simplified the documentation comment yard.
+
+## [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?`

data/lib/active_record_compose/attributes.rb

@@ -5,8 +5,6 @@ require_relative "attributes/delegation"
 require_relative "attributes/querying"
 
 module ActiveRecordCompose
-  # @private
-  #
   # Provides attribute-related functionality for use within ActiveRecordCompose::Model.
   #
   # This module allows you to define attributes on your composed model, including support
@@ -56,45 +54,32 @@ module ActiveRecordCompose
     include ActiveModel::Attributes
 
     included do
+      # @type self: Class
+
       include Querying
 
-      # @type self: Class
       class_attribute :delegated_attributes, instance_writer: false
     end
 
-    module ClassMethods
-      # Defines the reader and writer for the specified attribute.
-      #
-      # @example
-      #   class AccountRegistration < ActiveRecordCompose::Model
-      #     def initialize(account, attributes = {})
-      #       @account = account
-      #       super(attributes)
-      #       models.push(account)
-      #     end
-      #
-      #     attribute :original_attribute, :string, default: "qux"
-      #     delegate_attribute :name, to: :account
-      #
-      #     private
-      #
-      #     attr_reader :account
-      #   end
-      #
-      #   account = Account.new
-      #   account.name = "foo"
-      #
-      #   registration = AccountRegistration.new(account)
-      #   registration.name         # => "foo" (delegated)
-      #   registration.name?        # => true  (delegated attribute method + `?`)
-      #
-      #   registration.name = "bar" # => updates account.name
-      #   account.name              # => "bar"
-      #   account.name?             # => true
+    # steep:ignore:start
+
+    class_methods do
+      # Provides a method of attribute access to the encapsulated model.
       #
-      #   registration.attributes
-      #   # => { "original_attribute" => "qux", "name" => "bar" }
+      # It provides a way to access the attributes of the model it encompasses,
+      # allowing transparent access as if it had those attributes itself.
       #
+      # @param [Array<Symbol, String>] attributes
+      #   attributes A variable-length list of attribute names to delegate.
+      # @param [Symbol, String] to
+      #   The target object to which attributes are delegated (keyword argument).
+      # @param [Boolean] allow_nil
+      #   allow_nil Whether to allow nil values. Defaults to false.
+      # @example Basic usage
+      #   delegate_attribute :name, :email, to: :profile
+      # @example Allowing nil
+      #   delegate_attribute :bio, to: :profile, allow_nil: true
+      # @see Module#delegate for similar behavior in ActiveSupport
       def delegate_attribute(*attributes, to:, allow_nil: false)
         if to.start_with?("@")
           raise ArgumentError, "Instance variables cannot be specified in delegate to. (#{to})"
@@ -107,45 +92,68 @@ module ActiveRecordCompose
       end
 
       # Returns a array of attribute name.
-      # Attributes declared with `delegate_attribute` are also merged.
+      # Attributes declared with {.delegate_attribute} are also merged.
       #
+      # @see #attribute_names
       # @return [Array<String>] array of attribute name.
       def attribute_names = super + delegated_attributes.to_a.map { _1.attribute_name }
     end
 
+    # steep:ignore:end
+
     # Returns a array of attribute name.
-    # Attributes declared with `delegate_attribute` are also merged.
+    # Attributes declared with {.delegate_attribute} are also merged.
+    #
+    #     class Foo < ActiveRecordCompose::Base
+    #       def initialize(attributes = {})
+    #         @account = Account.new
+    #         super
+    #       end
+    #
+    #       attribute :confirmation, :boolean, default: false   # plain attribute
+    #       delegate_attribute :name, to: :account              # delegated attribute
+    #
+    #       private
+    #
+    #       attr_reader :account
+    #     end
     #
+    #     Foo.attribute_names                                   # Returns the merged state of plain and delegated attributes
+    #     # => ["confirmation" ,"name"]
+    #
+    #     foo = Foo.new
+    #     foo.attribute_names                                   # Similar behavior for instance method version
+    #     # => ["confirmation", "name"]
+    #
+    # @see #attributes
     # @return [Array<String>] array of attribute name.
     def attribute_names = super + delegated_attributes.to_a.map { _1.attribute_name }
 
     # Returns a hash with the attribute name as key and the attribute value as value.
-    # Attributes declared with `delegate_attribute` are also merged.
+    # Attributes declared with {.delegate_attribute} are also merged.
     #
-    # @return [Hash] hash with the attribute name as key and the attribute value as value.
-    # @example
-    #   class AccountRegistration < ActiveRecordCompose::Model
-    #     def initialize(account, attributes = {})
-    #       @account = account
-    #       super(attributes)
-    #       models.push(account)
-    #     end
+    #     class Foo < ActiveRecordCompose::Base
+    #       def initialize(attributes = {})
+    #         @account = Account.new
+    #         super
+    #       end
     #
-    #     attribute :original_attribute, :string, default: "qux"
-    #     delegate_attribute :name, to: :account
+    #       attribute :confirmation, :boolean, default: false   # plain attribute
+    #       delegate_attribute :name, to: :account              # delegated attribute
     #
-    #     private
+    #       private
     #
-    #     attr_reader :account
-    #   end
-    #
-    #   account = Account.new
-    #   account.name = "foo"
+    #       attr_reader :account
+    #     end
     #
-    #   registration = AccountRegistration.new(account)
+    #     foo = Foo.new
+    #     foo.name = "Alice"
+    #     foo.confirmation = true
     #
-    #   registration.attributes # => { "original_attribute" => "qux", "name" => "bar" }
+    #     foo.attributes                                        # Returns the merged state of plain and delegated attributes
+    #     # => { "confirmation" => true, "name" => "Alice" }
     #
+    # @return [Hash<String, Object>] hash with the attribute name as key and the attribute value as value.
     def attributes
       super.merge(*delegated_attributes.to_a.map { _1.attribute_hash(self) })
     end

data/lib/active_record_compose/callbacks.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 module ActiveRecordCompose
-  # @private
-  #
   # Provides hooks into the life cycle of an ActiveRecordCompose model,
   # allowing you to insert custom logic before or after changes to the object's state.
   #
@@ -21,18 +19,48 @@ module ActiveRecordCompose
     include ActiveModel::Validations::Callbacks
 
     included do
+      # @!method self.before_save(*args, &block)
+      #   Registers a callback to be called before a model is saved.
+
+      # @!method self.around_save(*args, &block)
+      #   Registers a callback to be called around the save of a model.
+
+      # @!method self.after_save(*args, &block)
+      #   Registers a callback to be called after a model is saved.
+
       define_model_callbacks :save
+
+      # @!method self.before_create(*args, &block)
+      #   Registers a callback to be called before a model is created.
+
+      # @!method self.around_create(*args, &block)
+      #   Registers a callback to be called around the creation of a model.
+
+      # @!method self.after_create(*args, &block)
+      #   Registers a callback to be called after a model is created.
+
       define_model_callbacks :create
+
+      # @!method self.before_update(*args, &block)
+      #   Registers a callback to be called before a model is updated.
+
+      # @!method self.around_update(*args, &block)
+      #   Registers a callback to be called around the update of a model.
+
+      # @!method self.after_update(*args, &block)
+      #   Registers a callback to be called after a update is updated.
       define_model_callbacks :update
     end
 
     private
 
+    # @private
     # Evaluate while firing callbacks such as `before_save` `after_save`
     # before and after block evaluation.
     #
     def with_callbacks(&block) = run_callbacks(:save) { run_callbacks(callback_context, &block) }
 
+    # @private
     # Returns the symbol representing the callback context, which is `:create` if the record
     # is new, or `:update` if it has been persisted.
     #

data/lib/active_record_compose/inspectable.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "active_support/parameter_filter"
+require_relative "attributes"
+
+module ActiveRecordCompose
+  # 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
+
+    # steep:ignore:start
+
+    # @private
+    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
+
+    included do
+      self.filter_attributes = []
+    end
+
+    # steep:ignore:start
+
+    class_methods do
+      # Returns columns not to expose when invoking {#inspect}.
+      #
+      # @return [Array<Symbol>]
+      # @see #inspect
+      def filter_attributes
+        if @filter_attributes.nil?
+          superclass.filter_attributes
+        else
+          @filter_attributes
+        end
+      end
+
+      # Specify columns not to expose when invoking {#inspect}.
+      #
+      # @param [Array<Symbol>] value
+      # @see #inspect
+      def filter_attributes=(value)
+        @inspection_filter = nil
+        @filter_attributes = value
+      end
+
+      # @private
+      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
+    end
+
+    # steep:ignore:end
+
+    # 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
+    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
+
+    # @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,274 +87,7 @@ module ActiveRecordCompose
     include ActiveRecordCompose::Persistence
     include ActiveRecordCompose::Validations
     include ActiveRecordCompose::TransactionSupport
-
-    begin
-      # @group Model Core
-
-      # @!method self.delegate_attribute(*attributes, to:, allow_nil: false)
-      #   Provides a method of attribute access to the encapsulated model.
-      #
-      #   It provides a way to access the attributes of the model it encompasses,
-      #   allowing transparent access as if it had those attributes itself.
-      #
-      #   @param [Array<Symbol, String>] attributes
-      #     attributes A variable-length list of attribute names to delegate.
-      #   @param [Symbol, String] to
-      #     The target object to which attributes are delegated (keyword argument).
-      #   @param [Boolean] allow_nil
-      #     allow_nil Whether to allow nil values. Defaults to false.
-      #   @example Basic usage
-      #     delegate_attribute :name, :email, to: :profile
-      #   @example Allowing nil
-      #     delegate_attribute :bio, to: :profile, allow_nil: true
-      #   @see Module#delegate for similar behavior in ActiveSupport
-
-      # @!method self.attribute_names
-      #   Returns a array of attribute name.
-      #   Attributes declared with {.delegate_attribute} are also merged.
-      #
-      #   @see #attribute_names
-      #   @return [Array<String>] array of attribute name.
-
-      # @!method attribute_names
-      #   Returns a array of attribute name.
-      #   Attributes declared with {.delegate_attribute} are also merged.
-      #
-      #       class Foo < ActiveRecordCompose::Base
-      #         def initialize(attributes = {})
-      #           @account = Account.new
-      #           super
-      #         end
-      #
-      #         attribute :confirmation, :boolean, default: false   # plain attribute
-      #         delegate_attribute :name, to: :account              # delegated attribute
-      #
-      #         private
-      #
-      #         attr_reader :account
-      #       end
-      #
-      #       Foo.attribute_names                                   # Returns the merged state of plain and delegated attributes
-      #       # => ["confirmation" ,"name"]
-      #
-      #       foo = Foo.new
-      #       foo.attribute_names                                   # Similar behavior for instance method version
-      #       # => ["confirmation", "name"]
-      #
-      #   @see #attributes
-      #   @return [Array<String>] array of attribute name.
-
-      # @!method attributes
-      #   Returns a hash with the attribute name as key and the attribute value as value.
-      #   Attributes declared with {.delegate_attribute} are also merged.
-      #
-      #       class Foo < ActiveRecordCompose::Base
-      #         def initialize(attributes = {})
-      #           @account = Account.new
-      #           super
-      #         end
-      #
-      #         attribute :confirmation, :boolean, default: false   # plain attribute
-      #         delegate_attribute :name, to: :account              # delegated attribute
-      #
-      #         private
-      #
-      #         attr_reader :account
-      #       end
-      #
-      #       foo = Foo.new
-      #       foo.name = "Alice"
-      #       foo.confirmation = true
-      #
-      #       foo.attributes                                        # Returns the merged state of plain and delegated attributes
-      #       # => { "confirmation" => true, "name" => "Alice" }
-      #
-      #   @return [Hash<String, Object>] hash with the attribute name as key and the attribute value as value.
-
-      # @!method persisted?
-      #   Returns true if model is persisted.
-      #
-      #   By overriding this definition, you can control the callbacks that are triggered when a save is made.
-      #   For example, returning false will trigger before_create, around_create and after_create,
-      #   and returning true will trigger {.before_update}, {.around_update} and {.after_update}.
-      #
-      #   @return [Boolean] returns true if model is persisted.
-      #   @example
-      #       # A model where persistence is always false
-      #       class Foo < ActiveRecordCompose::Model
-      #         before_save { puts "before_save called" }
-      #         before_create { puts "before_create called" }
-      #         before_update { puts "before_update called" }
-      #         after_update { puts "after_update called" }
-      #         after_create { puts "after_create called" }
-      #         after_save { puts "after_save called" }
-      #
-      #         def persisted? = false
-      #       end
-      #
-      #       # A model where persistence is always true
-      #       class Bar < Foo
-      #         def persisted? = true
-      #       end
-      #
-      #       Foo.new.save!
-      #       # before_save called
-      #       # before_create called
-      #       # after_create called
-      #       # after_save called
-      #
-      #       Bar.new.save!
-      #       # before_save called
-      #       # before_update called
-      #       # after_update called
-      #       # after_save called
-
-      # @endgroup
-
-      # @group Validations
-
-      # @!method valid?(context = nil)
-      #   Runs all the validations and returns the result as true or false.
-      #   @param context Validation context.
-      #   @return [Boolean] true on success, false on failure.
-
-      # @!method validate(context = nil)
-      #   Alias for {#valid?}
-      #   @see #valid? Validation context.
-      #   @param context
-      #   @return [Boolean] true on success, false on failure.
-
-      # @!method validate!(context = nil)
-      #   @see #valid?
-      #   Runs all the validations within the specified context.
-      #   no errors are found, raises `ActiveRecord::RecordInvalid` otherwise.
-      #   @param context Validation context.
-      #   @raise ActiveRecord::RecordInvalid
-
-      # @!method errors
-      #   Returns the `ActiveModel::Errors` object that holds all information about attribute error messages.
-      #
-      #   The `ActiveModel::Base` implementation itself,
-      #   but also aggregates error information for objects stored in {#models} when validation is performed.
-      #
-      #       class Account < ActiveRecord::Base
-      #         validates :name, :email, presence: true
-      #       end
-      #
-      #       class AccountRegistration < ActiveRecordCompose::Model
-      #         def initialize(attributes = {})
-      #           @account = Account.new
-      #           super(attributes)
-      #           models << account
-      #         end
-      #
-      #         attribute :confirmation, :boolean, default: false
-      #         validates :confirmation, presence: true
-      #
-      #         private
-      #
-      #         attr_reader :account
-      #       end
-      #
-      #       registration = AccountRegistration
-      #       registration.valid?
-      #       #=> false
-      #
-      #       # In addition to the model's own validation error information (`confirmation`), also aggregates
-      #       # error information for objects stored in `account` (`name`, `email`) when validation is performed.
-      #
-      #       registration.errors.map { _1.attribute }  #=> [:name, :email, :confirmation]
-      #
-      #   @return [ActiveModel::Errors]
-
-      # @endgroup
-
-      # @group Persistences
-
-      # @!method save(**options)
-      #   Save the models that exist in models.
-      #   Returns false if any of the targets fail, true if all succeed.
-      #
-      #   The save is performed within a single transaction.
-      #
-      #   Only the `:validate` option takes effect as it is required internally.
-      #   However, we do not recommend explicitly specifying `validate: false` to skip validation.
-      #   Additionally, the `:context` option is not accepted.
-      #   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.
-      #   @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>,
-      #     as skipping validations can lead to unexpected behavior.
-      #   @return [Boolean] returns true on success, false on failure.
-
-      # @!method save!(**options)
-      #   Behavior is same to {#save}, but raises an exception prematurely on failure.
-      #   @see #save
-      #   @raise ActiveRecord::RecordInvalid
-      #   @raise ActiveRecord::RecordNotSaved
-
-      # @!method update(attributes)
-      #   Assign attributes and {#save}.
-      #
-      #   @param [Hash<String, Object>] attributes
-      #     new attributes.
-      #   @see #save
-      #   @return [Boolean] returns true on success, false on failure.
-
-      # @!method update!(attributes)
-      #   Behavior is same to {#update}, but raises an exception prematurely on failure.
-      #
-      #   @param [Hash<String, Object>] attributes
-      #     new attributes.
-      #   @see #save
-      #   @see #update
-      #   @raise ActiveRecord::RecordInvalid
-      #   @raise ActiveRecord::RecordNotSaved
-
-      # @endgroup
-
-      # @group Callbacks
-
-      # @!method self.before_save(*args, &block)
-      #   Registers a callback to be called before a model is saved.
-
-      # @!method self.around_save(*args, &block)
-      #   Registers a callback to be called around the save of a model.
-
-      # @!method self.after_save(*args, &block)
-      #   Registers a callback to be called after a model is saved.
-
-      # @!method self.before_create(*args, &block)
-      #   Registers a callback to be called before a model is created.
-
-      # @!method self.around_create(*args, &block)
-      #   Registers a callback to be called around the creation of a model.
-
-      # @!method self.after_create(*args, &block)
-      #   Registers a callback to be called after a model is created.
-
-      # @!method self.before_update(*args, &block)
-      #   Registers a callback to be called before a model is updated.
-
-      # @!method self.around_update(*args, &block)
-      #   Registers a callback to be called around the update of a model.
-
-      # @!method self.after_update(*args, &block)
-      #   Registers a callback to be called after a update is updated.
-
-      # @!method self.after_commit(*args, &block)
-      #   Registers a block to be called after the transaction is fully committed.
-
-      # @!method self.after_rollback(*args, &block)
-      #   Registers a block to be called after the transaction is rolled back.
-
-      # @endgroup
-    end
-
-    # @group Model Core
+    include ActiveRecordCompose::Inspectable
 
     def initialize(attributes = {})
       super
@@ -394,7 +128,5 @@ module ActiveRecordCompose
     # @return [ActiveRecordCompose::ComposedCollection]
     #
     def models = @__models ||= ActiveRecordCompose::ComposedCollection.new(self)
-
-    # @endgroup
   end
 end

data/lib/active_record_compose/persistence.rb

@@ -6,7 +6,6 @@ require_relative "composed_collection"
 module ActiveRecordCompose
   using ComposedCollection::PackagePrivate
 
-  # @private
   module Persistence
     extend ActiveSupport::Concern
     include ActiveRecordCompose::Callbacks
@@ -22,6 +21,11 @@ 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.
     #
+    # @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>,
+    #   as skipping validations can lead to unexpected behavior.
     # @return [Boolean] returns true on success, false on failure.
     def save(**options)
       with_callbacks { save_models(**options, bang: false) }
@@ -29,38 +33,80 @@ module ActiveRecordCompose
       false
     end
 
-    # Save the models that exist in models.
-    # Unlike #save, an exception is raises on failure.
-    #
-    # Saving, like `#save`, is performed within a single transaction.
-    #
-    # Only the `:validate` option takes effect as it is required internally.
-    # However, we do not recommend explicitly specifying `validate: false` to skip validation.
-    # Additionally, the `:context` option is not accepted.
-    # 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.
+    # Behavior is same to {#save}, but raises an exception prematurely on failure.
     #
+    # @see #save
+    # @raise ActiveRecord::RecordInvalid
+    # @raise ActiveRecord::RecordNotSaved
     def save!(**options)
       with_callbacks { save_models(**options, bang: true) } || raise_on_save_error
     end
 
-    # Assign attributes and save.
+    # Assign attributes and {#save}.
     #
+    # @param [Hash<String, Object>] attributes
+    #   new attributes.
+    # @see #save
     # @return [Boolean] returns true on success, false on failure.
     def update(attributes)
       assign_attributes(attributes)
       save
     end
 
-    # Behavior is same to `#update`, but raises an exception prematurely on failure.
+    # Behavior is same to {#update}, but raises an exception prematurely on failure.
     #
+    # @param [Hash<String, Object>] attributes
+    #   new attributes.
+    # @see #save
+    # @see #update
+    # @raise ActiveRecord::RecordInvalid
+    # @raise ActiveRecord::RecordNotSaved
     def update!(attributes)
       assign_attributes(attributes)
       save!
     end
 
+    # @!method persisted?
+    #   Returns true if model is persisted.
+    #
+    #   By overriding this definition, you can control the callbacks that are triggered when a save is made.
+    #   For example, returning false will trigger before_create, around_create and after_create,
+    #   and returning true will trigger {.before_update}, {.around_update} and {.after_update}.
+    #
+    #   @return [Boolean] returns true if model is persisted.
+    #   @example
+    #       # A model where persistence is always false
+    #       class Foo < ActiveRecordCompose::Model
+    #         before_save { puts "before_save called" }
+    #         before_create { puts "before_create called" }
+    #         before_update { puts "before_update called" }
+    #         after_update { puts "after_update called" }
+    #         after_create { puts "after_create called" }
+    #         after_save { puts "after_save called" }
+    #
+    #         def persisted? = false
+    #       end
+    #
+    #       # A model where persistence is always true
+    #       class Bar < Foo
+    #         def persisted? = true
+    #       end
+    #
+    #       Foo.new.save!
+    #       # before_save called
+    #       # before_create called
+    #       # after_create called
+    #       # after_save called
+    #
+    #       Bar.new.save!
+    #       # before_save called
+    #       # before_update called
+    #       # after_update called
+    #       # after_save called
+
     private
 
+    # @private
     def save_models(bang:, **options)
       models.__wrapped_models.all? do |model|
         if bang
@@ -71,8 +117,10 @@ module ActiveRecordCompose
       end
     end
 
+    # @private
     def raise_on_save_error = raise ActiveRecord::RecordNotSaved.new(raise_on_save_error_message, self)
 
+    # @private
     def raise_on_save_error_message = "Failed to save the model."
   end
 end

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,31 +1,154 @@
 # 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
+
+    # steep:ignore:start
+
+    class_methods do
+      # @private
+      # @deprecated
+      def with_connection(...)
+        ActiveRecord.deprecator.warn("`with_connection` is deprecated. Use `ActiveRecord::Base.with_connection` instead.")
+        ActiveRecord::Base.with_connection(...)
+      end
+
+      # @private
+      # @deprecated
+      def lease_connection(...)
+        ActiveRecord.deprecator.warn("`lease_connection` is deprecated. Use `ActiveRecord::Base.lease_connection` instead.")
+        ActiveRecord::Base.lease_connection(...)
+      end
+
+      # @private
+      # @deprecated
+      def connection(...)
+        ActiveRecord.deprecator.warn("`connection` is deprecated. Use `ActiveRecord::Base.connection` instead.")
+        ActiveRecord::Base.connection(...)
+      end
     end
 
-    module ClassMethods
-      delegate :with_connection, :lease_connection, to: :ar_class
+    # steep:ignore:end
+
+    # steep:ignore:start
+
+    class_methods do
+      # @private
+      def before_commit(*args, &block)
+        set_options_for_callbacks!(args)
+        set_callback(:before_commit, :before, *args, &block)
+      end
 
-      # In ActiveRecord, it is soft deprecated.
-      delegate :connection, to: :ar_class
+      # Registers a block to be called after the transaction is fully committed.
+      #
+      def after_commit(*args, &block)
+        set_options_for_callbacks!(args, prepend_option)
+        set_callback(:commit, :after, *args, &block)
+      end
+
+      # Registers a block to be called after the transaction is rolled back.
+      #
+      def after_rollback(*args, &block)
+        set_options_for_callbacks!(args, prepend_option)
+        set_callback(:rollback, :after, *args, &block)
+      end
 
       private
 
-      def ar_class = ActiveRecord::Base
+      # @private
+      def prepend_option
+        if ActiveRecord.run_after_transaction_callbacks_in_order_defined
+          { prepend: true }
+        else
+          {}
+        end
+      end
+
+      # @private
+      def set_options_for_callbacks!(args, enforced_options = {})
+        options = args.extract_options!.merge!(enforced_options)
+        args << options
+      end
+    end
+
+    # steep:ignore:end
+
+    concerning :SupportForActiveRecordConnectionAdaptersTransaction do
+      # @private
+      def trigger_transactional_callbacks? = true
+
+      # @private
+      def before_committed!
+        _run_before_commit_callbacks
+      end
+
+      # @private
+      def committed!(should_run_callbacks: true)
+        _run_commit_callbacks if should_run_callbacks
+      end
+
+      # @private
+      def rolledback!(force_restore_state: false, should_run_callbacks: true)
+        _run_rollback_callbacks if should_run_callbacks
+      end
+    end
+
+    def save(**options) = with_transaction_returning_status { super }
+
+    def save!(**options) = with_transaction_returning_status { super }
+
+    private
+
+    # @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 || false
+        end
+      end
     end
 
-    def trigger_transactional_callbacks? = true
-    def restore_transaction_record_state(_force_restore_state = false) = nil
+    # @private
+    def default_ar_class = ActiveRecord::Base
+
+    # @private
+    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
+
+    # @private
+    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
+
+    # @private
+    def has_transactional_callbacks?
+      _rollback_callbacks.present? || _commit_callbacks.present? || _before_commit_callbacks.present? # steep:ignore
+    end
   end
 end

data/lib/active_record_compose/validations.rb

@@ -5,7 +5,6 @@ require_relative "composed_collection"
 module ActiveRecordCompose
   using ComposedCollection::PackagePrivate
 
-  # @private
   module Validations
     extend ActiveSupport::Concern
     include ActiveModel::Validations::Callbacks
@@ -22,27 +21,86 @@ module ActiveRecordCompose
       perform_validations(options) ? super : raise_validation_error
     end
 
+    # Runs all the validations and returns the result as true or false.
+    #
+    # @param context Validation context.
+    # @return [Boolean] true on success, false on failure.
     def valid?(context = nil) = context_for_override_validation.with_override(context) { super }
 
+    # @!method validate(context = nil)
+    #   Alias for {#valid?}
+    #   @see #valid? Validation context.
+    #   @param context
+    #   @return [Boolean] true on success, false on failure.
+
+    # @!method validate!(context = nil)
+    #   @see #valid?
+    #   Runs all the validations within the specified context.
+    #   no errors are found, raises `ActiveRecord::RecordInvalid` otherwise.
+    #   @param context Validation context.
+    #   @raise ActiveRecord::RecordInvalid
+
+    # @!method errors
+    #   Returns the `ActiveModel::Errors` object that holds all information about attribute error messages.
+    #
+    #   The `ActiveModel::Base` implementation itself,
+    #   but also aggregates error information for objects stored in {#models} when validation is performed.
+    #
+    #       class Account < ActiveRecord::Base
+    #         validates :name, :email, presence: true
+    #       end
+    #
+    #       class AccountRegistration < ActiveRecordCompose::Model
+    #         def initialize(attributes = {})
+    #           @account = Account.new
+    #           super(attributes)
+    #           models << account
+    #         end
+    #
+    #         attribute :confirmation, :boolean, default: false
+    #         validates :confirmation, presence: true
+    #
+    #         private
+    #
+    #         attr_reader :account
+    #       end
+    #
+    #       registration = AccountRegistration
+    #       registration.valid?
+    #       #=> false
+    #
+    #       # In addition to the model's own validation error information (`confirmation`), also aggregates
+    #       # error information for objects stored in `account` (`name`, `email`) when validation is performed.
+    #
+    #       registration.errors.map { _1.attribute }  #=> [:name, :email, :confirmation]
+    #
+    #   @return [ActiveModel::Errors]
+
     private
 
+    # @private
     def validate_models
       context = override_validation_context
       models.__wrapped_models.lazy.select { _1.invalid?(context) }.each { errors.merge!(_1) }
     end
 
+    # @private
     def perform_validations(options)
       options[:validate] == false || valid?(options[:context])
     end
 
+    # @private
     def raise_validation_error = raise ActiveRecord::RecordInvalid, self
 
+    # @private
     def context_for_override_validation
       @context_for_override_validation ||= OverrideValidationContext.new
     end
 
+    # @private
     def override_validation_context = context_for_override_validation.context
 
+    # @private
     class OverrideValidationContext
       attr_reader :context
 

data/lib/active_record_compose/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordCompose
-  VERSION = "1.0.1"
+  VERSION = "1.1.1"
 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

@@ -4,16 +4,12 @@ module ActiveRecordCompose
     include ActiveModel::Attributes
     include Querying
 
+    def self.delegate_attribute: (*untyped methods, to: untyped, ?allow_nil: bool) -> untyped
+    def self.delegated_attributes: () -> Array[Delegation]
+    def self.delegated_attributes=: (Array[Delegation]) -> untyped
     def delegated_attributes: () -> Array[Delegation]
 
-    module ClassMethods : Module
-      include ActiveModel::Attributes::ClassMethods
-      include ActiveModel::AttributeMethods::ClassMethods
-
-      def delegate_attribute: (*untyped methods, to: untyped, ?allow_nil: bool) -> untyped
-      def delegated_attributes: () -> Array[Delegation]
-      def delegated_attributes=: (Array[Delegation]) -> untyped
-    end
+    @attributes: untyped
 
     class AttributePredicate
       def initialize: (untyped value) -> void
@@ -83,11 +79,23 @@ module ActiveRecordCompose
     include PackagePrivate
   end
 
+  module Inspectable
+    extend ActiveSupport::Concern
+    include Attributes
+
+    def self.inspection_filter: () -> ActiveSupport::ParameterFilter
+    def self.filter_attributes: () -> Array[untyped]
+    def self.filter_attributes=: (Array[untyped]) -> void
+    def inspect: () -> String
+    def pretty_print: (untyped q) -> void
+
+    private
+    def format_for_inspect: (String name, untyped value) -> String
+  end
+
   class Model
     include Attributes
-    extend Attributes::ClassMethods
     include TransactionSupport
-    extend TransactionSupport::ClassMethods
     include Callbacks
 
     @__models: ComposedCollection
@@ -100,21 +108,28 @@ module ActiveRecordCompose
   module TransactionSupport
     extend ActiveSupport::Concern
     include ActiveRecord::Transactions
+    include ActiveSupport::Callbacks
+    extend ActiveSupport::Callbacks::ClassMethods
 
-    module ClassMethods
-      def connection: -> ActiveRecord::ConnectionAdapters::AbstractAdapter
-      def lease_connection: -> ActiveRecord::ConnectionAdapters::AbstractAdapter
-      def with_connection: [T] () { () -> T } -> T
+    def self.before_commit: (*untyped) -> untyped
+    def self.after_commit: (*untyped) -> untyped
+    def self.after_rollback: (*untyped) -> untyped
 
-      private
-      def ar_class: -> singleton(ActiveRecord::Base)
-    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
     include Callbacks
     include TransactionSupport
-    extend TransactionSupport::ClassMethods
 
     def save: (**untyped options) -> bool
     def save!: (**untyped options) -> untyped
@@ -128,6 +143,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
@@ -84,6 +84,9 @@ module ActiveRecordCompose
 
     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.1
+  version: 1.1.1
 platform: ruby
 authors:
 - hamajyotan
@@ -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