active_record_compose 0.6.1 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a87013307c9d2f0532ca4365765d94dc1423705c9d7df309af4f0c856d5803a6
-  data.tar.gz: fc650023b00d26306a222800f16949ffdf65c096028e07ccd855bed5b16258f9
+  metadata.gz: 6a3d2a1c6e4aac0bc387a6e0d9ba2917dafeacec4d46b2ad617d54e45ff9786f
+  data.tar.gz: d71b88c9b069eca62e49d2e5ff25c447a5e70e741d29b76f572c5a21b4994a4b
 SHA512:
-  metadata.gz: 95b6fdee6e5977ab27a7973aeb241a48f9dede2d05aa3685586b549db1f74dc5e4bf8df9e49e66fbe8e1bcf8be3f1dfaca4ff183dc67bd42771d10db64a371be
-  data.tar.gz: 410b89dd9af2e0878aa6646996d2ad48b33297b1b932c1dfb2caf21b284e7a2cb2a2fd7559d55a135984484719b44304086ae280692188a5001d1cd2759e3dcb
+  metadata.gz: 3579fdc36270eaaa2f9f253b247aabc5bc4aa6547df5511e81158ebbf3277b37dbbaa3e4d4376fff5c9ac0066cebbf0207db993cd20b4c8b159a6f3069ae24f1
+  data.tar.gz: 4f2e98a4158a5c19c13f5bc5d83276c7071ece19b2c969d73c24cce47231c9f272fb32620d5a31748e2bd060d72733bcd28be3d4d3eb6c1e9c8ded1bb9db0340

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## [Unreleased]
 
+## [0.6.2] - 2025-01-31
+
+- fix: type error in `ActiveRecordCompose::Model` subclass definitions.
+- fixed type errors in subclass callback definitions, etc.
+- doc: more detailed gem desciption.
+- rewrite readme.
+
+## [0.6.2] - 2025-01-04
+
+- fix: `delegate_attribute` defined in a subclass had an unintended side effect on the superclass.
+- support ruby 3.4.x
+- refactor: remove some `steep:ignore` by private rbs.
+- refactor: place definitions that you don't want to be used much in private rbs.
+- make `DelegateAttribute` dependent on `ActiveModel::Attributes` since it will not change in practice.
+
 ## [0.6.1] - 2024-12-23
 
 - refactor: reorganize the overall structure of the test. Change from rspec to minitest

data/README.md

@@ -1,9 +1,35 @@
 # ActiveRecordCompose
 
-activermodel (activerecord) form object pattern.
+activemodel (activerecord) form object pattern. it embraces multiple AR models and provides a transparent interface as if they were a single model.
 
 ![CI](https://github.com/hamajyotan/active_record_compose/workflows/CI/badge.svg)
 
+## Table of Contents
+
+- [Motivation](#motivation)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Basic usage](#basic-usage)
+    - [`delegate_attribute`](#delegate_attribute)
+    - [Promotion to model from AR-model errors](#promotion-to-model-from-ar-model-errors)
+  - [I18n](#i18n)
+- [Advanced Usage](#advanced-usage)
+  - [`destroy` option](#destroy-option)
+  - [Callback ordering by `#save`, `#create` and `#update`](#callback-ordering-by-save-create-and-update)
+- [Links](#links)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
+- [Code of Conduct](#code-of-conduct)
+
+## Motivation
+
+`ActiveRecord::Base` is responsible for persisting data to the database, and by defining validations and callbacks, it allows you to structure your use cases effectively. This is a crucial component of Rails. However, when a specific model starts being updated by multiple different use cases, validations and callbacks may require conditions such as `on: :context` or `save(validate: false)`. As a result, the model needs to account for multiple dependent use cases, leading to increased complexity.
+
+In such cases, `ActiveModel::Model` becomes useful. It provides the same interfaces as `ActiveRecord::Base`, such as `attribute` and `errors`, allowing it to be used similarly to an ActiveRecord model. Additionally, it enables you to define validations and callbacks within a limited context, preventing conditions related to multiple contexts from being embedded in `ActiveRecord::Base` validations and callbacks. This results in simpler, more maintainable code.
+
+This gem is built on `ActiveModel::Model` and acts as a first-class model within the Rails context. It provides methods for performing batch and safe updates on 0..N encapsulated models, enables transparent attribute access, and facilitates access to error information.
+
 ## Installation
 
 To install `active_record_compose`, just put this line in your Gemfile:
@@ -20,149 +46,186 @@ $ bundle
 
 ## Usage
 
-### ActiveRecordCompose::Model basic
+### Basic usage
 
-It wraps AR objects or equivalent models to provide unified operation.
-For example, the following cases are supported
+(Below, it is assumed that there are two AR model definitions, `Account` and `Profile`, for the sake of explanation.)
+
+```ruby
+class Account < ApplicationRecord
+  has_one :profile  # can work without `autosave:true`
+  validates :name, :email, presence: true
+end
 
-#### Context-specific callbacks.
+class Profile < ApplicationRecord
+  belongs_to :account
+  validates :firstname, :lastname, :age, presence: true
+end
+```
 
-A callback is useful to define some processing before or after a save in a particular model.
-However, if a callback is written directly in the AR model, it is necessary to consider the case where the model is updated in other contexts.
-In particular, if you frequently create with test data, previously unnecessary processing will be called at every point of creation.
-In addition to cost, the more complicated the callbacks you write, the more difficult it will be to create even a single test data.
-If the callbacks are written in a class that inherits from `ActiveRecordCompose::Model`, the AR model itself will not be polluted, and the context can be limited.
+Here is an example of designing a model that updates both Account and Profile at the same time, using `ActiveRecordCompose::Model`.
 
 ```ruby
-class AccountRegistration < ActiveRecordCompose::Model
-  def initialize(account = Account.new, attributes = {})
-    @account = account
-    super(attributes) # When overrides `#initialize`, be sure to call `super`.
+class UserRegistration < ActiveRecordCompose::Model
+  def initialize
+    @account = Account.new
+    @profile = @account.build_profile
 
-    # By including AR instance in models, AR instance itself is saved when this model is saved.
-    models.push(account)
+    super()  # Don't forget to call `super()`
+             # RuboCop's Lint/MissingSuper cop assists in addressing this.
+
+    models << account << profile
+    # Alternatively, it can also be written as follows:
+    #     models.push(account)
+    #     models.push(profile)
   end
 
-  # By delegating these to the AR instance,
-  # For example, this model itself can be given directly as an argument to form_with, and it will behave as if it were an instance of the model.
-  delegate :id, :persisted?, to: :account
+  # Attribute declarations using ActiveModel::Attributes are supported.
+  attribute :terms_of_service, :boolean
 
-  # Defines an attribute of the same name that delegates to account#name and account#email
-  delegate_attribute :name, :email, to: :account
+  # You can provide validation definitions limited to UserRegistration.
+  # Instead of directly defining validations for Account or Profile, such
+  # as `on: :create` in the context, the model itself explains the context.
+  validates :terms_of_service, presence: true
+  validates :email, confirmation: true
+
+  # You can provide callback definitions limited to UserRegistration.
+  # For example, if this is written directly in the AR model, you need to consider
+  # callback control for data generation during tests and other situations.
+  after_commit :send_email_message
 
-  # You can only define post-processing if you update through this model.
-  # If this is written directly into the AR model, for example, it would be necessary to consider a callback control for each test data generation.
-  after_commit :try_send_email_message
+  # UserRegistration behaves as if it has attributes like email, name, and age
+  # For example, `email` is delegated to `account.email`,
+  # and `email=` is delegated to `account.email=`.
+  delegate_attribute :name, :email, to: :account
+  delegate_attribute :firstname, :lastname, :age, to: :profile
 
   private
 
-  attr_reader :account
+  attr_reader :account, :profile
 
-  def try_send_email_message
+  def send_email_message
     SendEmailConfirmationJob.perform_later(account)
   end
 end
 ```
 
-#### Validation limited to a specific context.
-
-Validates are basically fired in all cases where the model is manipulated. To avoid this, use `on: :create`, etc. to make it work only in specific cases.
-and so on to work only in specific cases. This allows you to create context-sensitive validations for the same model operation.
-However, this is the first step in making the model more and more complex. You will have to go around with `update(context: :foo)`
-In some cases, you may have to go around with the context option, such as `update(context: :foo)` everywhere.
-By writing validates in a class that extends `ActiveRecordCompose::Model`, you can define context-specific validation without polluting the AR model itself.
+The above model is used as follows.
 
 ```ruby
-class AccountRegistration < ActiveRecordCompose::Model
-  def initialize(account = Account.new, attributes = {})
-    @account = account
-    super(attributes)
-    models.push(account)
-  end
+registration = UserRegistration.new
+
+# Atomically update Account and Profile.
+registration.update!(
+  name: "foo",
+  email: "bar@example.com",
+  firstname: "taro",
+  lastname: "yamada",
+  age: 18,
+  email_confirmation: "bar@example.com",
+  terms_of_service: true,
+)
+```
 
-  delegate :id, :persisted?, to: :account
-  delegate_attribute :name, :email, to: :account
+By executing `save`, you can simultaneously update multiple models added to `models`. Furthermore, the save operation is performed within a database transaction, ensuring atomic processing.
 
-  # Only if this model is used, also check the validity of the domain
-  before_validation :require_valid_domain
+```ruby
+user_registration.save  # Atomically update Account and Profile.
+                        # In case of failure, a false value is returned.
+user_registration.save! # With the bang method,
+                        # an exception is raised in case of failure.
+```
 
-  private
+### `delegate_attribute`
 
-  attr_reader :account
-
-  # Validity of the domain part of the e-mail address is also checked only when registering an account.
-  def require_valid_domain
-    e = ValidEmail2::Address.new(email.to_s)
-    unless e.valid?
-      errors.add(:email, :invalid_format)
-      return
-    end
-    unless e.valid_mx?
-      errors.add(:email, :invalid_domain)
-    end
-  end
-end
-```
+In many cases, the composed models have attributes that need to be assigned before saving. `ActiveRecordCompose::Model` provides `delegate_attribute`, allowing transparent access to those attributes."
 
 ```ruby
-account = Account.new(name: 'new account', email: 'foo@example.com')
-account.valid?  #=> true
+  # UserRegistration behaves as if it has attributes like email, name, and age
+  # For example, `email` is delegated to `account.email`,
+  # and `email=` is delegated to `account.email=`.
+  delegate_attribute :name, :email, to: :account
+  delegate_attribute :firstname, :lastname, :age, to: :profile
+```
+
+Attributes defined with `.delegate_attribute` can be accessed through `#attributes` in the same way as the original attributes defined with `.attribute`.
 
-account_registration = AccountRegistration.new(name: 'new account', email: 'foo@example.com')
-account_registration.valid?  #=> false
+```ruby
+registration = UserRegistration.new
+registration.name = "foo"
+registration.terms_of_service = true
+
+# Not only the email_confirmation defined with attribute,
+# but also the attributes defined with delegate_attribute are included.
+registration.attributes
+# => {
+#   "terms_of_service" => true,
+#   "email" => nil,
+#   "name" => "foo",
+#   "age" => nil,
+#   "firstname" => nil,
+#   "lastname" => nil
+# }
 ```
 
-#### updating multiple models at the same time.
+### Promotion to model from AR-model errors
 
-In an AR model, you can add, for example, `autosave: true` or `accepts_nested_attributes_for` to an association to update the related models at the same time.
-There are ways to update related models at the same time. The operation is safe because it is transactional.
-`ActiveRecordCompose::Model` has an internal array called models. By adding an AR object to this models array
-By adding an AR object to the models, the object stored in the models provides an atomic update operation via #save.
+When saving a composed model with `#save`, models that are not valid with `#valid?` will obviously not be saved. As a result, the #errors information can be accessed from `ActiveRecordCompose::Model`.
 
 ```ruby
-class AccountRegistration < ActiveRecordCompose::Model
-  def initialize(account = Account.new, profile = account.build_profile, attributes = {})
-    @account = account
-    @profile = profile
-    super(attributes)
-    models << account << profile
-  end
+user_registration = UserRegistration.new
+user_registration.email = "foo@example.com"
+user_registration.email_confirmation = "BAZ@example.com"
+user_registration.age = 18
+user_registration.terms_of_service = true
+
+user_registration.save
+#=> false
+
+user_registration.errors.to_a
+# => [
+#   "Name can't be blank",
+#   "Firstname can't be blank",
+#   "Lastname can't be blank",
+#   "Email confirmation doesn't match Email"
+# ]
+```
 
-  delegate :id, :persisted?, to: :account
-  delegate_attribute :name, :email, to: :account
-  delegate_attribute :firstname, :lastname, :age, to: :profile
+### I18n
 
-  private
+When the `#save!` operation raises an `ActiveRecord::RecordInvalid` exception, it is necessary to have pre-existing locale definitions in order to construct i18n information correctly.
+The specific keys required are `activemodel.errors.messages.record_invalid` or `errors.messages.record_invalid`.
 
-  attr_reader :account, :profile
-end
+(Replace `en` as appropriate in the context.)
+
+```yaml
+en:
+  activemodel:
+    errors:
+      messages:
+        record_invalid: 'Validation failed: %{errors}'
 ```
 
-```ruby
-Account.count  #=> 0
-Profile.count  #=> 0
-
-account_registration =
-  AccountRegistration.new(
-    name: 'foo',
-    email: 'foo@example.com',
-    firstname: 'bar',
-    lastname: 'baz',
-    age: 36,
-  )
-account_registration.save!
-
-Account.count  #=> 1
-Profile.count  #=> 1
+Alternatively, the following definition is also acceptable:
+
+```yaml
+en:
+  errors:
+    messages:
+      record_invalid: 'Validation failed: %{errors}'
 ```
 
-By adding to the `models` array while specifying `destroy: true`, you can perform a delete instead of a save on the model at `#save` time.
+## Advanced Usage
+
+### `destroy` option
+
+By adding to the models array while specifying destroy: true, you can perform a delete instead of a save on the model at #save time.
 
 ```ruby
 class AccountResignation < ActiveRecordCompose::Model
   def initialize(account)
     @account = account
-    @profile = account.profile  # Suppose that Account has_one Profile.
+    @profile = account.profile || account.build_profile
+    super()
     models.push(account)
     models.push(profile, destroy: true)
   end
@@ -178,7 +241,6 @@ class AccountResignation < ActiveRecordCompose::Model
   end
 end
 ```
-
 ```ruby
 account = Account.last
 
@@ -197,63 +259,31 @@ Conditional destroy (or save) can be written like this.
 
 ```ruby
 class AccountRegistration < ActiveRecordCompose::Model
-  def initialize(account, attributes = {})
+  def initialize(account)
     @account = account
     @profile = account.profile || account.build_profile
-    super(attributes)
+    super()
     models.push(account)
-    models.push(profile, destroy: :all_blank?) # destroy if all blank, otherwise save.
+
+    # destroy if all blank, otherwise save.
+    models.push(profile, destroy: :profile_field_is_blank?)
+    # Alternatively, it can also be written as follows:
+    #     models.push(profile, destroy: -> { profile_field_is_blank? })
   end
 
-  delegate_attribute :name, :email, to: :account
-  delegate_attribute :firstname, :lastname, :age, to: :profile
+  delegate_attribute :email, to: :account
+  delegate_attribute :name, :age, to: :profile
 
   private
 
   attr_reader :account, :profile
 
-  def all_blank? = firstname.blank && lastname.blank? && age.blank?
-end
-```
-
-### `delegate_attribute`
-
-It provides a macro description that expresses access to the attributes of the AR model through delegation.
-
-```ruby
-class AccountRegistration < ActiveRecordCompose::Model
-  def initialize(account, attributes = {})
-    @account = account
-    super(attributes)
-    models.push(account)
+  def profile_field_is_blank?
+    firstname.blank? && lastname.blank? && age.blank?
   end
-
-  attribute :original_attribute, :string, default: 'qux'
-  delegate_attribute :name, to: :account
-
-  private
-
-  attr_reader :account
 end
 ```
 
-```ruby
-account = Account.new
-account.name = 'foo'
-
-registration = AccountRegistration.new(account)
-registration.name  #=> 'foo'
-
-registration.name = 'bar'
-account.name  #=> 'bar'
-```
-
-Overrides `#attributes`, merging attributes defined with `delegate_attribute` in addition to the original attributes.
-
-```
-account.attributes  #=> {'original_attribute' => 'qux', 'name' => 'bar'}
-```
-
 ### Callback ordering by `#save`, `#create` and `#update`.
 
 Sometimes, multiple AR objects are passed to the models in the arguments.
@@ -294,29 +324,9 @@ model.update
 # after_save called!
 ```
 
-### I18n
-
-When the `#save!` operation raises an `ActiveRecord::RecordInvalid` exception, it is necessary to have pre-existing locale definitions in order to construct i18n information correctly.
-The specific keys required are `activemodel.errors.messages.record_invalid` or `errors.messages.record_invalid`.
-
-(Replace `en` as appropriate in the context.)
-
-```yaml
-en:
-  activemodel:
-    errors:
-      messages:
-        record_invalid: 'Validation failed: %{errors}'
-```
-
-Alternatively, the following definition is also acceptable:
+## Links
 
-```yaml
-en:
-  errors:
-    messages:
-      record_invalid: 'Validation failed: %{errors}'
-```
+- [Smart way to update multiple models simultaneously in Rails](https://dev.to/hamajyotan/smart-way-to-update-multiple-models-simultaneously-in-rails-51b6)
 
 ## Development
 
@@ -335,3 +345,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 ## Code of Conduct
 
 Everyone interacting in the ActiveRecord::Compose project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/hamajyotan/active_record_compose/blob/main/CODE_OF_CONDUCT.md).
+

data/lib/active_record_compose/delegate_attribute.rb

@@ -38,7 +38,8 @@ module ActiveRecordCompose
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :delegated_attributes, instance_writer: false # steep:ignore
+      # @type self: Class
+      class_attribute :delegated_attributes, instance_writer: false
     end
 
     module ClassMethods
@@ -52,9 +53,8 @@ module ActiveRecordCompose
           [reader, writer]
         end
 
-        delegate(*delegates, to:, allow_nil:, private:) # steep:ignore
-        delegated_attributes = (self.delegated_attributes ||= []) # steep:ignore
-        attributes.each { delegated_attributes.push(_1.to_s) }
+        delegate(*delegates, to:, allow_nil:, private:)
+        self.delegated_attributes = delegated_attributes.to_a + attributes.map { _1.to_s }
       end
     end
 
@@ -63,12 +63,7 @@ module ActiveRecordCompose
     #
     # @return [Hash] hash with the attribute name as key and the attribute value as value.
     def attributes
-      attrs = defined?(super) ? super : {} # steep:ignore
-      delegates = delegated_attributes # steep:ignore
-
-      # @type var attrs: Hash[String, untyped]
-      # @type var delegates: Array[String]
-      attrs.merge(delegates.to_h { [_1, public_send(_1)] })
+      super.merge(delegated_attributes.to_h { [_1, public_send(_1)] })
     end
   end
 end

data/lib/active_record_compose/inner_model.rb

@@ -60,12 +60,36 @@ module ActiveRecordCompose
     # Whether save or destroy is executed depends on the value of `#destroy_context?`.
     #
     # @return [Boolean] returns true on success, false on failure.
-    def save = destroy_context? ? model.destroy : model.save
+    def save
+      # While errors caused by the type check are avoided,
+      # it is important to note that an error can still occur
+      # if `#destroy_context?` returns true but ar_like does not implement `#destroy`.
+      m = model
+      if destroy_context?
+        # @type var m: ActiveRecordCompose::_ARLikeWithDestroy
+        m.destroy
+      else
+        # @type var m: ActiveRecordCompose::_ARLike
+        m.save
+      end
+    end
 
     # Execute save or destroy. Unlike #save, an exception is raises on failure.
     # Whether save or destroy is executed depends on the value of `#destroy_context?`.
     #
-    def save! = destroy_context? ? model.destroy! : model.save!
+    def save!
+      # While errors caused by the type check are avoided,
+      # it is important to note that an error can still occur
+      # if `#destroy_context?` returns true but ar_like does not implement `#destroy`.
+      m = model
+      if destroy_context?
+        # @type var m: ActiveRecordCompose::_ARLikeWithDestroy
+        m.destroy!
+      else
+        # @type var model: ActiveRecordCompose::_ARLike
+        m.save!
+      end
+    end
 
     # @return [Boolean]
     def invalid? = destroy_context? ? false : model.invalid?
@@ -93,7 +117,6 @@ module ActiveRecordCompose
     attr_reader :destroy_context_type, :if_option
 
     # @private
-    # steep:ignore:start
     module PackagePrivate
       refine InnerModel do
         # @private
@@ -104,6 +127,5 @@ module ActiveRecordCompose
         def __raw_model = model
       end
     end
-    # steep:ignore:end
   end
 end

data/lib/active_record_compose/inner_model_collection.rb

@@ -3,7 +3,7 @@
 require 'active_record_compose/inner_model'
 
 module ActiveRecordCompose
-  using InnerModel::PackagePrivate # steep:ignore
+  using InnerModel::PackagePrivate
 
   class InnerModelCollection
     include Enumerable
@@ -21,7 +21,7 @@ module ActiveRecordCompose
     def each
       return enum_for(:each) unless block_given?
 
-      models.each { yield _1.__raw_model } # steep:ignore
+      models.each { yield _1.__raw_model }
       self
     end
 
@@ -79,7 +79,7 @@ module ActiveRecordCompose
     attr_reader :owner, :models
 
     def wrap(model, destroy: false, if: nil)
-      if model.is_a?(ActiveRecordCompose::InnerModel) # steep:ignore
+      if model.is_a?(ActiveRecordCompose::InnerModel)
         # @type var model: ActiveRecordCompose::InnerModel
         model
       else
@@ -97,7 +97,6 @@ module ActiveRecordCompose
     end
 
     # @private
-    # steep:ignore:start
     module PackagePrivate
       refine InnerModelCollection do
         # Returns array of wrapped model instance.
@@ -107,6 +106,5 @@ module ActiveRecordCompose
         def __wrapped_models = models.reject { _1.ignore? }.select { _1.__raw_model }
       end
     end
-    # steep:ignore:end
   end
 end

data/lib/active_record_compose/model.rb

@@ -5,7 +5,7 @@ require 'active_record_compose/inner_model_collection'
 require 'active_record_compose/transaction_support'
 
 module ActiveRecordCompose
-  using InnerModelCollection::PackagePrivate # steep:ignore
+  using InnerModelCollection::PackagePrivate
 
   class Model
     include ActiveModel::Model
@@ -153,12 +153,12 @@ module ActiveRecordCompose
     def models = @__models ||= ActiveRecordCompose::InnerModelCollection.new(self)
 
     def validate_models
-      wms = models.__wrapped_models # steep:ignore
+      wms = models.__wrapped_models
       wms.select { _1.invalid? }.each { errors.merge!(_1) }
     end
 
     def save_models(bang:)
-      wms = models.__wrapped_models # steep:ignore
+      wms = models.__wrapped_models
       wms.all? { bang ? _1.save! : _1.save }
     end
 

data/lib/active_record_compose/version.rb

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

data/sig/_internal/package_private.rbs

@@ -0,0 +1,82 @@
+module ActiveRecordCompose
+  module DelegateAttribute : ActiveModel::Attributes
+    extend ActiveSupport::Concern
+
+    def attributes: -> Hash[String, untyped]
+    def delegated_attributes: () -> Array[String]
+
+    module ClassMethods : Module
+      def delegate_attribute: (*untyped methods, to: untyped, ?allow_nil: untyped?, ?private: untyped?) -> untyped
+      def delegated_attributes: () -> Array[String]
+      def delegated_attributes=: (Array[String]) -> untyped
+    end
+  end
+
+  class InnerModelCollection
+    def initialize: (Model) -> void
+
+    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
+
+    module PackagePrivate
+      def __wrapped_models: () -> Array[InnerModel]
+
+      private
+      def models: () -> Array[InnerModel]
+    end
+
+    include PackagePrivate
+  end
+
+  class InnerModel
+    def initialize: (ar_like, ?destroy: (bool | destroy_context_type), ?if: (nil | condition_type)) -> void
+    def destroy_context?: -> bool
+    def ignore?: -> bool
+    def save: -> bool
+    def save!: -> untyped
+    def invalid?: -> bool
+    def valid?: -> bool
+    def is_a?: (untyped) -> bool
+    def ==: (untyped) -> bool
+
+    private
+    attr_reader model: ar_like
+    attr_reader destroy_context_type: (bool | destroy_context_type)
+    attr_reader if_option: (nil | condition_type)
+
+    module PackagePrivate
+      def __raw_model: () -> ar_like
+
+      private
+      def model: () -> ar_like
+    end
+
+    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

@@ -5,6 +5,15 @@ module ActiveRecordCompose
   VERSION: String
 
   interface _ARLike
+    def save: -> bool
+    def save!: -> untyped
+    def invalid?: -> bool
+    def valid?: -> bool
+    def errors: -> untyped
+    def is_a?: (untyped) -> bool
+    def ==: (untyped) -> bool
+  end
+  interface _ARLikeWithDestroy
     def save: -> bool
     def save!: -> untyped
     def destroy: -> bool
@@ -12,68 +21,58 @@ module ActiveRecordCompose
     def invalid?: -> bool
     def valid?: -> bool
     def errors: -> untyped
+    def is_a?: (untyped) -> bool
     def ==: (untyped) -> bool
   end
+  type ar_like = (_ARLike | _ARLikeWithDestroy)
 
-  type attribute_name = (String | Symbol)
-  type destroy_context_type = (bool | Symbol | (^() -> boolish) | (^(_ARLike) -> boolish))
-  type condition_type = ((^() -> boolish) | (^(_ARLike) -> boolish))
-
-  module DelegateAttribute
-    extend ActiveSupport::Concern
-
-    def attributes: -> Hash[String, untyped]
+  type condition[T] = Symbol | ^(T) [self: T] -> boolish
+  type callback[T] = Symbol | ^(T) [self: T] -> void
+  type around_callback[T] = Symbol | ^(T, Proc) [self: T] -> void
 
-    module ClassMethods
-      def delegate_attribute: (*untyped methods, to: untyped?, ?allow_nil: untyped?, ?private: untyped?) -> untyped
-    end
-  end
+  type attribute_name = (String | Symbol)
+  type destroy_context_type = ((^() -> boolish) | (^(ar_like) -> boolish))
+  type condition_type = ((^() -> boolish) | (^(ar_like) -> boolish))
 
   class InnerModelCollection
-    include ::Enumerable[_ARLike]
+    include ::Enumerable[ar_like]
 
-    def initialize: (Model) -> void
-    def each: () { (_ARLike) -> void } -> InnerModelCollection | () -> Enumerator[_ARLike, self]
-    def <<: (_ARLike) -> self
-    def push: (_ARLike, ?destroy: destroy_context_type, ?if: (nil | Symbol | condition_type)) -> self
+    def each: () { (ar_like) -> void } -> InnerModelCollection | () -> 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: (_ARLike | InnerModel) -> InnerModelCollection?
-
-    private
-    attr_reader owner: Model
-    attr_reader models: Array[InnerModel]
-    def wrap: (_ARLike | InnerModel, ?destroy: destroy_context_type, ?if: (nil | Symbol | condition_type)) -> InnerModel
-  end
-
-  class InnerModel
-    def initialize: (_ARLike, ?destroy: destroy_context_type, ?if: (nil | condition_type)) -> void
-    def destroy_context?: -> bool
-    def ignore?: -> bool
-    def save: -> bool
-    def save!: -> untyped
-    def invalid?: -> bool
-    def valid?: -> bool
-    def ==: (untyped) -> bool
-
-    private
-    attr_reader model: _ARLike
-    attr_reader destroy_context_type: destroy_context_type
-    attr_reader if_option: (nil | condition_type)
+    def delete: (ar_like) -> InnerModelCollection?
   end
 
   class Model
-    extend ActiveModel::Callbacks
     include ActiveModel::Model
     include ActiveModel::Validations::Callbacks
-    extend ActiveModel::Validations::ClassMethods
     include ActiveModel::Attributes
-    include DelegateAttribute
-    extend DelegateAttribute::ClassMethods
-    include TransactionSupport
-    extend TransactionSupport::ClassMethods
+    extend ActiveModel::Callbacks
+    extend ActiveModel::Validations::ClassMethods
+    extend ActiveModel::Validations::Callbacks::ClassMethods
+    extend ActiveModel::Attributes::ClassMethods
+
+    def self.before_save: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void
+    def self.around_save: (*around_callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void
+    def self.after_save: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void
+
+    def self.before_create: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void
+    def self.around_create: (*around_callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void
+    def self.after_create: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void
 
-    @__models: InnerModelCollection
+    def self.before_update: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void
+    def self.around_update: (*around_callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void
+    def self.after_update: (*callback[instance], ?if: condition[instance], ?unless: condition[instance], **untyped) ?{ () [self: instance] -> void } -> void
+
+    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.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
+    def self.with_connection: [T] () { () -> T } -> T
 
     def initialize: (?Hash[attribute_name, untyped]) -> void
     def save: -> bool
@@ -82,6 +81,7 @@ module ActiveRecordCompose
     def create!: (?Hash[attribute_name, untyped]) -> untyped
     def update: (?Hash[attribute_name, untyped]) -> bool
     def update!: (?Hash[attribute_name, untyped]) -> untyped
+    def id: -> untyped
 
     private
     def models: -> InnerModelCollection
@@ -91,19 +91,4 @@ module ActiveRecordCompose
     def raise_on_save_error: -> bot
     def raise_on_save_error_message: -> String
   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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: active_record_compose
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.3
 platform: ruby
 authors:
 - hamajyotan
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-22 00:00:00.000000000 Z
+date: 2025-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -24,14 +23,14 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6.1'
-description: activemodel form object pattern
+description: activemodel form object pattern. it embraces multiple AR models and provides
+  a transparent interface as if they were a single model.
 email:
 - hamajyotan@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
 - ".rubocop.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
@@ -44,6 +43,7 @@ files:
 - lib/active_record_compose/model.rb
 - lib/active_record_compose/transaction_support.rb
 - lib/active_record_compose/version.rb
+- sig/_internal/package_private.rbs
 - sig/active_record_compose.rbs
 homepage: https://github.com/hamajyotan/active_record_compose
 licenses:
@@ -52,9 +52,8 @@ 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.1
+  documentation_uri: https://www.rubydoc.info/gems/active_record_compose/0.6.3
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -69,8 +68,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.21
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: activemodel form object pattern
 test_files: []

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper