active_record_compose 0.6.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a3d2a1c6e4aac0bc387a6e0d9ba2917dafeacec4d46b2ad617d54e45ff9786f
-  data.tar.gz: d71b88c9b069eca62e49d2e5ff25c447a5e70e741d29b76f572c5a21b4994a4b
+  metadata.gz: 690ecf032eb0a4c59c97394702c838142a4d519145f72e58f9a381d956cad5ce
+  data.tar.gz: 7133a2f5defa0d1c97dac41b207936512f6d5375e8f534ea77dc6c13c3f61dde
 SHA512:
-  metadata.gz: 3579fdc36270eaaa2f9f253b247aabc5bc4aa6547df5511e81158ebbf3277b37dbbaa3e4d4376fff5c9ac0066cebbf0207db993cd20b4c8b159a6f3069ae24f1
-  data.tar.gz: 4f2e98a4158a5c19c13f5bc5d83276c7071ece19b2c969d73c24cce47231c9f272fb32620d5a31748e2bd060d72733bcd28be3d4d3eb6c1e9c8ded1bb9db0340
+  metadata.gz: 2680382210cf6eb2f8371cca7e656f8b00211361f00bf9aed7d2ee4f006a816eee6298a917e48c67d5b4f6149545f2ebb3e67bd5905946279c9e203e9e378d82
+  data.tar.gz: 63aa5b0a8abcbcd59eb81aadadf4c8207622988ad417b09d2e8f977615ed8726233ae8f257f8d8847e16e38f400955e0bda1d9340f9c7733f06ea8d76fa4854a

data/.rubocop.yml

@@ -21,6 +21,9 @@ Style/DoubleNegation:
 Style/NumericPredicate:
   Enabled: false
 
+Style/OptionalBooleanParameter:
+  Enabled: false
+
 Style/StringLiterals:
   Enabled: true
 
@@ -48,6 +51,9 @@ Layout/LeadingCommentSpace:
 Layout/LineLength:
   Max: 120
 
+Lint/UselessMethodDefinition:
+  Enabled: false
+
 Metrics/AbcSize:
   Enabled: false
 

data/CHANGELOG.md

@@ -1,6 +1,21 @@
 ## [Unreleased]
 
-## [0.6.2] - 2025-01-31
+## [0.8.0] - 2025-02-22
+
+- changed `persisted_flag_callback_control` default from `false` to `true`.
+- adjusted to save errors as soon as an invalid is found.
+- drop support rails 6.1.x.
+
+## [0.7.0] - 2025-02-12
+
+- rename ActiveRecordCompose::InnerModel to ActiveRecordCompose::WrappedModel
+- rename ActiveRecordCompose::InnerModelCollection to ActiveRecordCompose::ComposedCollection
+- A new callback control flag, `persisted_flag_callback_control`, has been defined.
+  Currently, the default value is false, which does not change the existing behavior, but it will be deprecated in the future.
+  When the flag is set to true, the behavior will be almost the same as the callback sequence in ActiveRecord.
+  (https://github.com/hamajyotan/active_record_compose/issues/11)
+
+## [0.6.3] - 2025-01-31
 
 - fix: type error in `ActiveRecordCompose::Model` subclass definitions.
 - fixed type errors in subclass callback definitions, etc.

data/README.md

@@ -15,7 +15,7 @@ activemodel (activerecord) form object pattern. it embraces multiple AR models a
   - [I18n](#i18n)
 - [Advanced Usage](#advanced-usage)
   - [`destroy` option](#destroy-option)
-  - [Callback ordering by `#save`, `#create` and `#update`](#callback-ordering-by-save-create-and-update)
+  - [Callback ordering by `#persisted?`](#callback-ordering-by-persisted)
 - [Links](#links)
 - [Development](#development)
 - [Contributing](#contributing)
@@ -284,15 +284,75 @@ class AccountRegistration < ActiveRecordCompose::Model
 end
 ```
 
-### Callback ordering by `#save`, `#create` and `#update`.
+### Callback ordering by `#persisted?`
 
-Sometimes, multiple AR objects are passed to the models in the arguments.
-It is not strictly possible to distinguish between create and update operations, regardless of the state of `#persisted?`.
-Therefore, control measures such as separating callbacks with `after_create` and `after_update` based on the `#persisted?` of AR objects are left to the discretion of the user,
-rather than being determined by the state of the AR objects themselves.
+The behavior of `(before|after|around)_create` and `(before|after|around)_update` hooks depends on
+the state of the `persisted_flag_callback_control` setting.
+default value is `true`, behavior when set to `false` will be removed in the next release.
+
+When `persisted_flag_callback_control` is set to `true`, it behaves almost like callback control in ActiveRecord.
+Depending on the evaluation result of `#persisted?`,
+either the create-related callbacks or the update-related callbacks will be triggered.
 
 ```ruby
 class ComposedModel < ActiveRecordCompose::Model
+  self.persisted_flag_callback_control = true # In the future, true will be the default and false will no longer be supported.
+
+  # ...
+
+  before_save { puts 'before_save called!' }
+  before_create { puts 'before_create called!' }
+  before_update { puts 'before_update called!' }
+  after_save { puts 'after_save called!' }
+  after_create { puts 'after_create called!' }
+  after_update { puts 'after_update called!' }
+
+  def persisted?
+    # Override and return a boolish value depending on the state of the inner model.
+    # For example, it could be transferred to the primary model to be manipulated.
+    #
+    #       # ex.)
+    #       def persisted? = the_model.persisted?
+    #
+    true
+  end
+end
+```
+
+```ruby
+# when `model.persisted?` returns `true`
+
+model = ComposedModel.new
+
+model.save # or `model.update` (the same callbacks will be triggered in all cases).
+
+# before_save called!
+# before_update called! # when persisted? is false, before_create hook is fired here instead.
+# after_update called! # when persisted? is false, after_create hook is fired here instead.
+# after_save called!
+```
+
+```ruby
+# when `model.persisted?` returns `false`
+
+model = ComposedModel.new
+
+model.save # or `model.update` (the same callbacks will be triggered in all cases).
+
+# before_save called!
+# before_create called!
+# after_create called!
+# after_save called!
+```
+
+When `persisted_flag_callback_control` is set to false,
+the execution of `#create`, `#update`, or `#save` determines which callbacks will be triggered.
+This behavior will no longer be supported in the next release.
+
+```ruby
+class ComposedModel < ActiveRecordCompose::Model
+  self.persisted_flag_callback_control = false # Currently defaults to false, but will no longer be supported in the future.
+
   # ...
 
   before_save { puts 'before_save called!' }

data/lib/active_record_compose/{inner_model_collection.rb → composed_collection.rb}

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'active_record_compose/inner_model'
+require 'active_record_compose/wrapped_model'
 
 module ActiveRecordCompose
-  using InnerModel::PackagePrivate
+  using WrappedModel::PackagePrivate
 
-  class InnerModelCollection
+  class ComposedCollection
     include Enumerable
 
     def initialize(owner)
@@ -79,30 +79,25 @@ module ActiveRecordCompose
     attr_reader :owner, :models
 
     def wrap(model, destroy: false, if: nil)
-      if model.is_a?(ActiveRecordCompose::InnerModel)
-        # @type var model: ActiveRecordCompose::InnerModel
-        model
-      else
-        if destroy.is_a?(Symbol)
-          method = destroy
-          destroy = -> { owner.__send__(method) }
-        end
-        if_option = binding.local_variable_get(:if)
-        if if_option.is_a?(Symbol)
-          method = if_option
-          if_option = -> { owner.__send__(method) }
-        end
-        ActiveRecordCompose::InnerModel.new(model, destroy:, if: if_option)
+      if destroy.is_a?(Symbol)
+        method = destroy
+        destroy = -> { owner.__send__(method) }
       end
+      if_option = binding.local_variable_get(:if)
+      if if_option.is_a?(Symbol)
+        method = if_option
+        if_option = -> { owner.__send__(method) }
+      end
+      ActiveRecordCompose::WrappedModel.new(model, destroy:, if: if_option)
     end
 
     # @private
     module PackagePrivate
-      refine InnerModelCollection do
+      refine ComposedCollection do
         # Returns array of wrapped model instance.
         #
         # @private
-        # @return [Array[InnerModel] array of wrapped model instance.
+        # @return [Array[WrappedModel]] array of wrapped model instance.
         def __wrapped_models = models.reject { _1.ignore? }.select { _1.__raw_model }
       end
     end

data/lib/active_record_compose/model.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
+require 'active_record_compose/composed_collection'
 require 'active_record_compose/delegate_attribute'
-require 'active_record_compose/inner_model_collection'
 require 'active_record_compose/transaction_support'
 
 module ActiveRecordCompose
-  using InnerModelCollection::PackagePrivate
+  using ComposedCollection::PackagePrivate
 
   class Model
     include ActiveModel::Model
@@ -15,6 +15,46 @@ module ActiveRecordCompose
     include ActiveRecordCompose::DelegateAttribute
     include ActiveRecordCompose::TransactionSupport
 
+    # This flag controls the callback sequence for models.
+    # The current default value is `true`, behavior when set to `false` will be removed in the next release.
+    #
+    # When `persisted_flag_callback_control` is set to `true`,
+    # the occurrence of callbacks depends on the evaluation result of `#persisted?`.
+    # Additionally, the definition of `#persisted?` itself can be appropriately overridden in subclasses.
+    #
+    # if `#persisted?` returns `false`:
+    # * before_save
+    # * before_create
+    # * after_create
+    # * after_save
+    #
+    # if `#persisted?` returns `true`:
+    # * before_save
+    # * before_update
+    # * after_update
+    # * after_save
+    #
+    # On the other hand, when `persisted_flag_callback_control` is set to `false`,
+    # the invoked methods during saving operations vary depending on the method used.
+    #
+    # when performing `#save` or `#save!`:
+    # * before_save
+    # * after_save
+    #
+    # when performing `#update` or `#update!`:
+    # * before_save
+    # * before_update
+    # * after_update
+    # * after_save
+    #
+    # when performing `#create` or `#create!`:
+    # * before_save
+    # * before_create
+    # * after_create
+    # * after_save
+    #
+    class_attribute :persisted_flag_callback_control, instance_accessor: false, default: true
+
     define_model_callbacks :save
     define_model_callbacks :create
     define_model_callbacks :update
@@ -35,7 +75,18 @@ module ActiveRecordCompose
       return false if invalid?
 
       with_transaction_returning_status do
-        run_callbacks(:save) { save_models(bang: false) }
+        if self.class.persisted_flag_callback_control
+          with_callbacks { save_models(bang: false) }
+        else
+          # steep:ignore:start
+          deprecator.warn(
+            'The behavior with `persisted_flag_callback_control` set to `false` will be removed in 0.9.0. ' \
+            'Use `self.persisted_flag_callback_control = true` set to `true`. ' \
+            '(Alternatively, exclude statements that set `false`)',
+          )
+          # steep:ignore:end
+          run_callbacks(:save) { save_models(bang: false) }
+        end
       rescue ActiveRecord::RecordInvalid
         false
       end
@@ -50,7 +101,18 @@ module ActiveRecordCompose
       valid? || raise_validation_error
 
       with_transaction_returning_status do
-        run_callbacks(:save) { save_models(bang: true) }
+        if self.class.persisted_flag_callback_control
+          with_callbacks { save_models(bang: true) }
+        else
+          # steep:ignore:start
+          deprecator.warn(
+            'The behavior with `persisted_flag_callback_control` set to `false` will be removed in 0.9.0. ' \
+            'Use `self.persisted_flag_callback_control = true` set to `true`. ' \
+            '(Alternatively, exclude statements that set `false`)',
+          )
+          # steep:ignore:end
+          run_callbacks(:save) { save_models(bang: true) }
+        end
       end || raise_on_save_error
     end
 
@@ -79,12 +141,25 @@ module ActiveRecordCompose
     #   # after_create called!
     #   # after_save called!
     #
+    # @deprecated
     def create(attributes = {})
+      if self.class.persisted_flag_callback_control
+        raise '`#create` cannot be called. The context for creation or update is determined by the `#persisted` flag.'
+      end
+
+      # steep:ignore:start
+      deprecator.warn(
+        'The behavior with `persisted_flag_callback_control` set to `false` will be removed in 0.9.0. ' \
+        'Use `self.persisted_flag_callback_control = true` set to `true`. ' \
+        '(Alternatively, exclude statements that set `false`)',
+      )
+      # steep:ignore:end
+
       assign_attributes(attributes)
       return false if invalid?
 
       with_transaction_returning_status do
-        run_callbacks(:save) { run_callbacks(:create) { save_models(bang: false) } }
+        with_callbacks(context: :create) { save_models(bang: false) }
       rescue ActiveRecord::RecordInvalid
         false
       end
@@ -92,12 +167,25 @@ module ActiveRecordCompose
 
     # Behavior is same to `#create`, but raises an exception prematurely on failure.
     #
+    # @deprecated
     def create!(attributes = {})
+      if self.class.persisted_flag_callback_control
+        raise '`#create` cannot be called. The context for creation or update is determined by the `#persisted` flag.'
+      end
+
+      # steep:ignore:start
+      deprecator.warn(
+        'The behavior with `persisted_flag_callback_control` set to `false` will be removed in 0.9.0. ' \
+        'Use `self.persisted_flag_callback_control = true` set to `true`. ' \
+        '(Alternatively, exclude statements that set `false`)',
+      )
+      # steep:ignore:end
+
       assign_attributes(attributes)
       valid? || raise_validation_error
 
       with_transaction_returning_status do
-        run_callbacks(:save) { run_callbacks(:create) { save_models(bang: true) } }
+        with_callbacks(context: :create) { save_models(bang: true) }
       end || raise_on_save_error
     end
 
@@ -131,7 +219,18 @@ module ActiveRecordCompose
       return false if invalid?
 
       with_transaction_returning_status do
-        run_callbacks(:save) { run_callbacks(:update) { save_models(bang: false) } }
+        if self.class.persisted_flag_callback_control
+          with_callbacks { save_models(bang: false) }
+        else
+          # steep:ignore:start
+          deprecator.warn(
+            'The behavior with `persisted_flag_callback_control` set to `false` will be removed in 0.9.0. ' \
+            'Use `self.persisted_flag_callback_control = true` set to `true`. ' \
+            '(Alternatively, exclude statements that set `false`)',
+          )
+          # steep:ignore:end
+          with_callbacks(context: :update) { save_models(bang: false) }
+        end
       rescue ActiveRecord::RecordInvalid
         false
       end
@@ -144,22 +243,48 @@ module ActiveRecordCompose
       valid? || raise_validation_error
 
       with_transaction_returning_status do
-        run_callbacks(:save) { run_callbacks(:update) { save_models(bang: true) } }
+        if self.class.persisted_flag_callback_control
+          with_callbacks { save_models(bang: true) }
+        else
+          # steep:ignore:start
+          deprecator.warn(
+            'The behavior with `persisted_flag_callback_control` set to `false` will be removed in 0.9.0. ' \
+            'Use `self.persisted_flag_callback_control = true` set to `true`. ' \
+            '(Alternatively, exclude statements that set `false`)',
+          )
+          # steep:ignore:end
+          with_callbacks(context: :update) { save_models(bang: true) }
+        end
       end || raise_on_save_error
     end
 
+    # 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.
+    def persisted? = super
+
     private
 
-    def models = @__models ||= ActiveRecordCompose::InnerModelCollection.new(self)
+    def models = @__models ||= ActiveRecordCompose::ComposedCollection.new(self)
 
     def validate_models
-      wms = models.__wrapped_models
-      wms.select { _1.invalid? }.each { errors.merge!(_1) }
+      models.__wrapped_models.lazy.select { _1.invalid? }.each { errors.merge!(_1) }
+    end
+
+    def with_callbacks(context: nil, &block)
+      run_callbacks(:save) { run_callbacks(callback_context(context:), &block) }
+    end
+
+    def callback_context(context: nil)
+      context || (persisted? ? :update : :create)
     end
 
     def save_models(bang:)
-      wms = models.__wrapped_models
-      wms.all? { bang ? _1.save! : _1.save }
+      models.__wrapped_models.all? { bang ? _1.save! : _1.save }
     end
 
     def raise_validation_error = raise ActiveRecord::RecordInvalid, self
@@ -167,5 +292,13 @@ module ActiveRecordCompose
     def raise_on_save_error = raise ActiveRecord::RecordNotSaved.new(raise_on_save_error_message, self)
 
     def raise_on_save_error_message = 'Failed to save the model.'
+
+    def deprecator
+      if ActiveRecord.respond_to?(:deprecator)
+        ActiveRecord.deprecator # steep:ignore
+      else # for rails 7.0.x or lower
+        ActiveSupport::Deprecation
+      end
+    end
   end
 end

data/lib/active_record_compose/transaction_support.rb

@@ -28,6 +28,6 @@ module ActiveRecordCompose
     def id = nil
 
     def trigger_transactional_callbacks? = true
-    def restore_transaction_record_state(_force_restore_state = false) = nil # rubocop:disable Style/OptionalBooleanParameter
+    def restore_transaction_record_state(_force_restore_state = false) = nil
   end
 end

data/lib/active_record_compose/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordCompose
-  VERSION = '0.6.3'
+  VERSION = '0.8.0'
 end

data/lib/active_record_compose/{inner_model.rb → wrapped_model.rb}

@@ -3,7 +3,7 @@
 require 'active_support/core_ext/object'
 
 module ActiveRecordCompose
-  class InnerModel
+  class WrappedModel
     # @param model [Object] the model instance.
     # @param destroy [Boolean] given true, destroy model.
     # @param destroy [Proc] when proc returning true, destroy model.
@@ -17,7 +17,7 @@ module ActiveRecordCompose
     delegate :errors, to: :model
 
     # Determines whether to save or delete the target object.
-    # Depends on the `destroy` value of the InnerModel object initialization option.
+    # Depends on the `destroy` value of the WrappedModel object initialization option.
     #
     # On the other hand, there are values `mark_for_destruction` and `marked_for_destruction?` in ActiveRecord.
     # However, these values are not substituted here.
@@ -118,7 +118,7 @@ module ActiveRecordCompose
 
     # @private
     module PackagePrivate
-      refine InnerModel do
+      refine WrappedModel do
         # @private
         # Returns a model instance of raw, but it should
         # be noted that application developers are not expected to use this interface.

data/sig/_internal/package_private.rbs

@@ -1,4 +1,22 @@
 module ActiveRecordCompose
+  class ComposedCollection
+    def initialize: (Model) -> void
+
+    private
+    attr_reader owner: Model
+    attr_reader models: Array[WrappedModel]
+    def wrap: (ar_like, ?destroy: (bool | Symbol | destroy_context_type), ?if: (nil | Symbol | condition_type)) -> WrappedModel
+
+    module PackagePrivate
+      def __wrapped_models: () -> Array[WrappedModel]
+
+      private
+      def models: () -> Array[WrappedModel]
+    end
+
+    include PackagePrivate
+  end
+
   module DelegateAttribute : ActiveModel::Attributes
     extend ActiveSupport::Concern
 
@@ -12,25 +30,31 @@ module ActiveRecordCompose
     end
   end
 
-  class InnerModelCollection
-    def initialize: (Model) -> void
+  class Model
+    include DelegateAttribute
+    extend DelegateAttribute::ClassMethods
+    include TransactionSupport
+    extend TransactionSupport::ClassMethods
 
-    private
-    attr_reader owner: Model
-    attr_reader models: Array[InnerModel]
-    def wrap: (ar_like | InnerModel, ?destroy: (bool | Symbol | destroy_context_type), ?if: (nil | Symbol | condition_type)) -> InnerModel
+    @__models: ComposedCollection
+  end
 
-    module PackagePrivate
-      def __wrapped_models: () -> Array[InnerModel]
+  module TransactionSupport
+    include ActiveRecord::Transactions
+
+    def id: -> untyped
+
+    module ClassMethods
+      def connection: -> ActiveRecord::ConnectionAdapters::AbstractAdapter
+      def lease_connection: -> ActiveRecord::ConnectionAdapters::AbstractAdapter
+      def with_connection: [T] () { () -> T } -> T
 
       private
-      def models: () -> Array[InnerModel]
+      def ar_class: -> singleton(ActiveRecord::Base)
     end
-
-    include PackagePrivate
   end
 
-  class InnerModel
+  class WrappedModel
     def initialize: (ar_like, ?destroy: (bool | destroy_context_type), ?if: (nil | condition_type)) -> void
     def destroy_context?: -> bool
     def ignore?: -> bool
@@ -55,28 +79,4 @@ module ActiveRecordCompose
 
     include PackagePrivate
   end
-
-  class Model
-    include DelegateAttribute
-    extend DelegateAttribute::ClassMethods
-    include TransactionSupport
-    extend TransactionSupport::ClassMethods
-
-    @__models: InnerModelCollection
-  end
-
-  module TransactionSupport
-    include ActiveRecord::Transactions
-
-    def id: -> untyped
-
-    module ClassMethods
-      def connection: -> ActiveRecord::ConnectionAdapters::AbstractAdapter
-      def lease_connection: -> ActiveRecord::ConnectionAdapters::AbstractAdapter
-      def with_connection: [T] () { () -> T } -> T
-
-      private
-      def ar_class: -> singleton(ActiveRecord::Base)
-    end
-  end
 end

data/sig/active_record_compose.rbs

@@ -34,15 +34,15 @@ module ActiveRecordCompose
   type destroy_context_type = ((^() -> boolish) | (^(ar_like) -> boolish))
   type condition_type = ((^() -> boolish) | (^(ar_like) -> boolish))
 
-  class InnerModelCollection
+  class ComposedCollection
     include ::Enumerable[ar_like]
 
-    def each: () { (ar_like) -> void } -> InnerModelCollection | () -> Enumerator[ar_like, self]
+    def each: () { (ar_like) -> void } -> ComposedCollection | () -> Enumerator[ar_like, self]
     def <<: (ar_like) -> self
     def push: (ar_like, ?destroy: (bool | Symbol | destroy_context_type), ?if: (nil | Symbol | condition_type)) -> self
     def empty?: -> bool
     def clear: -> self
-    def delete: (ar_like) -> InnerModelCollection?
+    def delete: (ar_like) -> ComposedCollection?
   end
 
   class Model
@@ -69,6 +69,9 @@ module ActiveRecordCompose
     def self.after_commit: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void
     def self.after_rollback: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void
 
+    def self.persisted_flag_callback_control: () -> boolish
+    def self.persisted_flag_callback_control=: (boolish) -> untyped
+
     def self.delegate_attribute: (*untyped methods, to: untyped, ?allow_nil: untyped?, ?private: untyped?) -> untyped
     def self.connection: -> ActiveRecord::ConnectionAdapters::AbstractAdapter
     def self.lease_connection: -> ActiveRecord::ConnectionAdapters::AbstractAdapter
@@ -84,7 +87,9 @@ module ActiveRecordCompose
     def id: -> untyped
 
     private
-    def models: -> InnerModelCollection
+    def models: -> ComposedCollection
+    def with_callbacks: (?context: (nil | :create | :update)) { () -> bool } -> bool
+    def callback_context: (?context: (nil | :create | :update)) -> (:create | :update)
     def validate_models: -> void
     def save_models: (bang: bool) -> bool
     def raise_validation_error: -> bot

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: active_record_compose
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.8.0
 platform: ruby
 authors:
 - hamajyotan
 bindir: bin
 cert_chain: []
-date: 2025-01-31 00:00:00.000000000 Z
+date: 2025-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.0'
 description: activemodel form object pattern. it embraces multiple AR models and provides
   a transparent interface as if they were a single model.
 email:
@@ -37,12 +37,12 @@ files:
 - LICENSE.txt
 - README.md
 - lib/active_record_compose.rb
+- lib/active_record_compose/composed_collection.rb
 - lib/active_record_compose/delegate_attribute.rb
-- lib/active_record_compose/inner_model.rb
-- lib/active_record_compose/inner_model_collection.rb
 - lib/active_record_compose/model.rb
 - lib/active_record_compose/transaction_support.rb
 - lib/active_record_compose/version.rb
+- lib/active_record_compose/wrapped_model.rb
 - sig/_internal/package_private.rbs
 - sig/active_record_compose.rbs
 homepage: https://github.com/hamajyotan/active_record_compose
@@ -52,7 +52,7 @@ metadata:
   homepage_uri: https://github.com/hamajyotan/active_record_compose
   source_code_uri: https://github.com/hamajyotan/active_record_compose
   changelog_uri: https://github.com/hamajyotan/active_record_compose/blob/main/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/active_record_compose/0.6.3
+  documentation_uri: https://www.rubydoc.info/gems/active_record_compose/0.8.0
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: