active_record_compose 0.11.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 154ee35310ede836e5d89ecd703efadbbc2b7fba0a6229797e9b38b5288eba47
-  data.tar.gz: 42c565c5093680ae089bac356541561dc83ff73759941f268af22365338126db
+  metadata.gz: 9cdfb23b1af43681e6c4af3e9fed615bc3dc64873461bdee6f49c92f706f33e9
+  data.tar.gz: 4530c0987f038605cb6dc3da229df21e8cf16af29d6ca8cf3078b1dc933cc838
 SHA512:
-  metadata.gz: a5a9f0a46534ea0dbb3423275a68b521543c67074d8fcd7c637d46f86fcc42f93ac6792b2d80f83b6a0aae367f6dd461e6fb4d0e06730f40da3aefd0751393e9
-  data.tar.gz: c5bb3aaae6e84b23bc264ce5a1ad7b369f248c1fb1f1494b2753a1a82681ecc3df8c5f10a6b68854cda319c65da59e69435dd1c4381f44ff585d81a2400b5bac
+  metadata.gz: 10c37b41ff66acd993e2f5c412ed5f48213f29344a94e0ab27d40766e11f60197808d4d1b9e97118f729b4be1d272a4bdae100c8e06489c40008ac3c92f6fe61
+  data.tar.gz: 67c4086fce4661e89188161fd6d23610bca3dcb9ad8a6e781162909d07fbf750add3ad804d8e58bd92bf4fc1305bcebd2452a4a9d924af70e56e6a0217ecf70f

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## [Unreleased]
 
+## [1.0.0] - 2025-09-23
+
+- drop support rails 7.0.x
+
+## [0.12.0] - 2025-08-21
+
+- Omits default arguments for `#update` and `#update!`. It's to align I/F with ActiveRecord.
+  (https://github.com/hamajyotan/active_record_compose/pull/25)
+  - `#update(attributes = {})` to `#update(attributes)`
+  - `#update!(attributes = {})` to `#update!(attributes)`
+- Omitted Specify instance variables in the `:to` option of `delegate_attribute`.
+  (https://github.com/hamajyotan/active_record_compose/pull/29)
+- Omitted `#destroy` and `#touch` from `ActiveRecordCompose::Model`.
+  These were unintentionally provided by the `ActiveRecord::Transactions` module. The but in fact did not work correctly.
+  (https://github.com/hamajyotan/active_record_compose/pull/27)
+
 ## [0.11.3] - 2025-07-13
 
 - refactor: Aggregation attribute module.

data/README.md

@@ -1,6 +1,7 @@
 # ActiveRecordCompose
 
-activemodel (activerecord) form object pattern. it embraces multiple AR models and provides a transparent interface as if they were a single model.
+ActiveRecordCompose lets you build form objects that combine multiple ActiveRecord models into a single, unified interface.
+More than just a simple form object, it is designed as a **business-oriented composed model** that encapsulates complex operations-such as user registration spanning multiple tables-making them easier to write, validate, and maintain.
 
 [![Gem Version](https://badge.fury.io/rb/active_record_compose.svg)](https://badge.fury.io/rb/active_record_compose)
 ![CI](https://github.com/hamajyotan/active_record_compose/workflows/CI/badge.svg)
@@ -10,16 +11,16 @@ activemodel (activerecord) form object pattern. it embraces multiple AR models a
 
 - [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)
+- [Quick Start](#quick-start)
+  - [Basic Example](#basic-example)
+  - [Attribute Delegation](#attribute-delegation)
+  - [Unified Error Handling](#unified-error-handling)
+  - [I18n Support](#i18n-support)
 - [Advanced Usage](#advanced-usage)
-  - [`destroy` option](#destroy-option)
-  - [Callback ordering by `#persisted?`](#callback-ordering-by-persisted)
-  - [`#save` with custom context option](#save-with-custom-context-option)
-- [Sample application as an example](#sample-application-as-an-example)
+  - [Destroy Option](#destroy-option)
+  - [Callback ordering with `#persisted?`](#callback-ordering-with-persisted)
+  - [Notes on adding models dynamically](#notes-on-adding-models-dynamically)
+- [Sample Application](#sample-application)
 - [Links](#links)
 - [Development](#development)
 - [Contributing](#contributing)
@@ -28,11 +29,20 @@ activemodel (activerecord) form object pattern. it embraces multiple AR models a
 
 ## 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 Rails, `ActiveRecord::Base` is responsible for persisting data to the database.
+By defining validations and callbacks, you can model use cases effectively.
 
-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.
+However, when a single model must serve multiple different use cases, you often end up with conditional validations (`on: :context`) or workarounds like `save(validate: false)`.
+This mixes unrelated concerns into one model, leading to unnecessary complexity.
 
-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.
+`ActiveModel::Model` helps here — it provides the familiar API (`attribute`, `errors`, validations, callbacks) without persistence, so you can isolate logic per use case.
+
+**ActiveRecordCompose** builds on `ActiveModel::Model` and is a powerful **business object** that acts as a first-class model within Rails.
+- Transparently accesses attributes across multiple models
+- Saves all associated models atomically in a transaction
+- Collects and exposes error information consistently
+
+This leads to cleaner domain models, better separation of concerns, and fewer surprises in validations and callbacks.
 
 ## Installation
 
@@ -48,15 +58,15 @@ Then bundle
 $ bundle
 ```
 
-## Usage
+## Quick Start
 
-### Basic usage
+### Basic Example
 
-(Below, it is assumed that there are two AR model definitions, `Account` and `Profile`, for the sake of explanation.)
+Suppose you have two models:
 
 ```ruby
 class Account < ApplicationRecord
-  has_one :profile  # can work without `autosave:true`
+  has_one :profile
   validates :name, :email, presence: true
 end
 
@@ -66,40 +76,23 @@ class Profile < ApplicationRecord
 end
 ```
 
-Here is an example of designing a model that updates both Account and Profile at the same time, using `ActiveRecordCompose::Model`.
+You can compose them into one form object:
 
 ```ruby
 class UserRegistration < ActiveRecordCompose::Model
-  def initialize
+  def initialize(attributes = {})
     @account = Account.new
     @profile = @account.build_profile
-
-    super()  # Don't forget to call `super()`
-             # RuboCop's Lint/MissingSuper cop assists in addressing this.
-
+    super(attributes)
     models << account << profile
-    # Alternatively, it can also be written as follows:
-    #     models.push(account)
-    #     models.push(profile)
   end
 
-  # Attribute declarations using ActiveModel::Attributes are supported.
   attribute :terms_of_service, :boolean
-
-  # 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
 
-  # 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
 
@@ -113,12 +106,11 @@ class UserRegistration < ActiveRecordCompose::Model
 end
 ```
 
-The above model is used as follows.
+Usage:
 
 ```ruby
+# === Standalone script ===
 registration = UserRegistration.new
-
-# Atomically update Account and Profile.
 registration.update!(
   name: "foo",
   email: "bar@example.com",
@@ -128,38 +120,41 @@ registration.update!(
   email_confirmation: "bar@example.com",
   terms_of_service: true,
 )
-```
 
-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.
+# === Or, in a Rails controller with strong parameters ===
+class UserRegistrationsController < ApplicationController
+  def create
+    @registration = UserRegistration.new(user_registration_params)
+    if @registration.save
+      redirect_to root_path, notice: "Registered!"
+    else
+      render :new
+    end
+  end
 
-```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
+  def user_registration_params
+    params.require(:user_registration).permit(
+      :name, :email, :firstname, :lastname, :age, :email_confirmation, :terms_of_service
+    )
+  end
+end
 ```
 
-### `delegate_attribute`
+Both `Account` and `Profile` will be updated **atomically in one transaction**.
+
+### Attribute Delegation
 
-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."
+`delegate_attribute` allows transparent access to attributes of inner models:
 
 ```ruby
-  # 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
+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`.
+They are also included in `#attributes`:
 
 ```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,
@@ -171,21 +166,21 @@ registration.attributes
 # }
 ```
 
-### Promotion to model from AR-model errors
+### Unified Error Handling
 
-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`.
+Validation errors from inner models are collected into the composed model:
 
 ```ruby
-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 = UserRegistration.new(
+  email: "foo@example.com",
+  email_confirmation: "BAZ@example.com",
+  age: 18,
+  terms_of_service: true,
+)
 
-user_registration.save
-#=> false
+user_registration.save # => false
 
-user_registration.errors.to_a
+user_registration.errors.full_messages
 # => [
 #   "Name can't be blank",
 #   "Firstname can't be blank",
@@ -194,12 +189,10 @@ user_registration.errors.to_a
 # ]
 ```
 
-### I18n
+### I18n Support
 
-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.)
+When `#save!` raises `ActiveRecord::RecordInvalid`,
+make sure you have locale entries such as:
 
 ```yaml
 en:
@@ -209,204 +202,104 @@ en:
         record_invalid: 'Validation failed: %{errors}'
 ```
 
-Alternatively, the following definition is also acceptable:
-
-```yaml
-en:
-  errors:
-    messages:
-      record_invalid: 'Validation failed: %{errors}'
-```
+For more complete usage patterns, see the [Sample Application](#sample-application) below.
 
 ## Advanced Usage
 
-### `destroy` option
+### 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 || account.build_profile
-    super()
-    models.push(account)
-    models.push(profile, destroy: true)
-  end
-
-  before_save :set_resigned_at
-
-  private
-
-  attr_reader :account, :profile
-
-  def set_resigned_at
-    account.resigned_at = Time.zone.now
-  end
-end
-```
 ```ruby
-account = Account.last
-
-account.resigned_at.present?  #=> nil
-account.profile.blank?        #=> false
-
-account_resignation = AccountResignation.new(account)
-account_resignation.save!
-
-account.reload
-account.resigned_at.present?  #=> Tue, 02 Jan 2024 22:58:01.991008870 JST +09:00
-account.profile.blank?        #=> true
+models.push(profile, destroy: true)
 ```
 
-Conditional destroy (or save) can be written like this.
+This deletes the model on `#save` instead of persisting it.
+Conditional deletion is also supported:
 
 ```ruby
-class AccountRegistration < ActiveRecordCompose::Model
-  def initialize(account)
-    @account = account
-    @profile = account.profile || account.build_profile
-    super()
-    models.push(account)
-
-    # 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
+models.push(profile, destroy: -> { profile_field_is_blank? })
+```
 
-  delegate_attribute :email, to: :account
-  delegate_attribute :name, :age, to: :profile
+### Callback ordering with `#persisted?`
 
-  private
+The result of `#persisted?` determines **which callbacks are fired**:
 
-  attr_reader :account, :profile
+- `persisted? == false` -> create callbacks (`before_create`, `after_create`, ...)
+- `persisted? == true` -> update callbacks (`before_update`, `after_update`, ...)
 
-  def profile_field_is_blank?
-    firstname.blank? && lastname.blank? && age.blank?
-  end
-end
-```
-
-### Callback ordering by `#persisted?`
-
-The behavior of `(before|after|around)_create` and `(before|after|around)_update` hooks depending on the evaluation result of `#persisted?`,
-either the create-related callbacks or the update-related callbacks will be triggered.
+This matches the behavior of normal ActiveRecord models.
 
 ```ruby
 class ComposedModel < ActiveRecordCompose::Model
-  # ...
-
-  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!' }
+  before_save     { puts "before_save" }
+  before_create   { puts "before_create" }
+  before_update   { puts "before_update" }
+  after_create    { puts "after_create" }
+  after_update    { puts "after_update" }
+  after_save      { puts "after_save" }
 
   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
+    account.persisted?
   end
 end
 ```
 
-```ruby
-# when `model.persisted?` returns `true`
+Example:
 
+```ruby
+# When persisted? == false
 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.save
+# => before_save
+# => before_create
+# => after_create
+# => after_save
 
+# When persisted? == true
 model = ComposedModel.new
+def model.persisted?; true; end
 
-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!
+model.save
+# => before_save
+# => before_update
+# => after_update
+# => after_save
 ```
 
-### `#save` with custom context option
-
-The interface remains consistent with standard ActiveModel and ActiveRecord models, so the :context option works with #save.
-
-```ruby
-composed_model.valid?(:custom_context)
-
-composed_model.save(context: :custom_context)
-```
+### Notes on adding models dynamically
 
-However, this may not be ideal from a design perspective.
-If your application requires complex context-specific validations, consider separating models by context.
+Avoid adding `models` to the models array **after validation has already run**
+(for example, inside `after_validation` or `before_save` callbacks).
 
 ```ruby
-class Account < ActiveRecord::Base
-  validates :name, presence: true
-  validates :email, presence: true
-  validates :email, format: { with: /\.edu\z/ }, on: :education
+class Example < ActiveRecordCompose::Model
+  before_save { models << AnotherModel.new }
 end
+```
 
-class Registration < ActiveRecordCompose::Model
-  def initialize(attributes = {})
-    models.push(@account = Account.new)
-    super(attributes)
-  end
-
-  attribute :accept, :boolean
-  validates :accept, presence: true, on: :education
+In this case, the newly added model will **not** run validations for the current save cycle.
+This may look like a bug, but it is the expected behavior: validations are only applied
+to models that were registered before validation started.
 
-  delegate_attribute :name, :email, to: :account
-
-  private
+We intentionally do not restrict this at the framework level, since there may be valid
+advanced use cases where models are manipulated dynamically.
+Instead, this behavior is documented here so that developers can make an informed decision.
 
-  attr_reader :account
-end
-```
-```ruby
-r = Registration.new(name: 'foo', email: 'example@example.com', accept: false)
-r.valid?
-#=> true
-
-r.valid?(:education)
-#=> false
-r.errors.map { [_1.attribute, _1.type] }
-#=> [[:email, :invalid], [:accept, :blank]]
-
-r.email = 'example@example.edu'
-r.accept = true
-
-r.valid?(:education)
-#=> true
-r.save(context: :education)
-#=> true
-```
+## Sample Application
 
-## Sample application as an example
+The sample app demonstrates a more complete usage of ActiveRecordCompose
+(e.g., user registration flows involving multiple models).
+It is not meant to cover every possible pattern, but can serve as a reference
+for putting the library into practice.
 
-With Github Codespaces, it can also be run directly in the browser. Naturally, a local environment is also possible.
+Try it out in your browser with GitHub Codespaces (or locally):
 
 - https://github.com/hamajyotan/active_record_compose-example
 
 ## Links
 
-- [Document from YARD](https://hamajyotan.github.io/active_record_compose/)
-- [Smart way to update multiple models simultaneously in Rails](https://dev.to/hamajyotan/smart-way-to-update-multiple-models-simultaneously-in-rails-51b6)
+- [API Documentation (YARD)](https://hamajyotan.github.io/active_record_compose/)
+- [Blog article introducing the concept](https://dev.to/hamajyotan/smart-way-to-update-multiple-models-simultaneously-in-rails-51b6)
 
 ## Development
 

data/lib/active_record_compose/attributes/attribute_predicate.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActiveRecordCompose
+  module Attributes
+    # @private
+    class AttributePredicate
+      def initialize(value)
+        @value = value
+      end
+
+      def call
+        case value
+        when true then true
+        when false, nil then false
+        else
+          if value.respond_to?(:zero?)
+            !value.zero?
+          else
+            value.present?
+          end
+        end
+      end
+
+      private
+
+      attr_reader :value
+    end
+  end
+end

data/lib/active_record_compose/attributes/delegation.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "attribute_predicate"
+
 module ActiveRecordCompose
   module Attributes
     # @private
@@ -17,7 +19,11 @@ module ActiveRecordCompose
 
       def define_delegated_attribute(klass)
         klass.delegate(reader, writer, to:, allow_nil:)
-        klass.define_attribute_methods(attribute)
+        klass.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{reader}?
+            ActiveRecordCompose::Attributes::AttributePredicate.new(#{reader}).call
+          end
+        RUBY
       end
 
       # @return [String] The attribute name as string

data/lib/active_record_compose/attributes/querying.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "attribute_predicate"
+
 module ActiveRecordCompose
   module Attributes
     # @private
@@ -50,19 +52,10 @@ module ActiveRecordCompose
 
       private
 
-      def attribute?(attr_name)
-        value = public_send(attr_name)
+      def attribute?(attr_name) = query?(public_send(attr_name))
 
-        case value
-        when true then true
-        when false, nil then false
-        else
-          if value.respond_to?(:zero?)
-            !value.zero?
-          else
-            value.present?
-          end
-        end
+      def query?(value)
+        ActiveRecordCompose::Attributes::AttributePredicate.new(value).call
       end
     end
   end

data/lib/active_record_compose/attributes.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "attributes/attribute_predicate"
 require_relative "attributes/delegation"
 require_relative "attributes/querying"
 
@@ -62,9 +63,6 @@ module ActiveRecordCompose
     end
 
     module ClassMethods
-      ALLOW_NIL_DEFAULT = Object.new.freeze # steep:ignore
-      private_constant :ALLOW_NIL_DEFAULT
-
       # Defines the reader and writer for the specified attribute.
       #
       # @example
@@ -97,34 +95,10 @@ module ActiveRecordCompose
       #   registration.attributes
       #   # => { "original_attribute" => "qux", "name" => "bar" }
       #
-      def delegate_attribute(*attributes, to:, allow_nil: ALLOW_NIL_DEFAULT) # steep:ignore
-        # steep:ignore:start
+      def delegate_attribute(*attributes, to:, allow_nil: false)
         if to.start_with?("@")
-          suggested_reader_name = to.to_s.sub(/^@+/, "")
-          suggested_method =
-            if to.start_with?("@@")
-              "def #{suggested_reader_name} = #{to}"
-            else
-              "attr_reader :#{suggested_reader_name}"
-            end
-
-          message = <<~MSG
-            Direct use of instance or class variables in `to:` will be removed in the next minor version.
-            Please define a reader method (private is fine) and refer to it by name instead.
-
-            For example,
-                delegate_attribute #{attributes.map { ":#{_1}" }.join(", ")}, to: :#{to}#{", allow_nil: #{allow_nil}" if allow_nil != ALLOW_NIL_DEFAULT}
-
-            Instead of the above, use the following
-                delegate_attribute #{attributes.map { ":#{_1}" }.join(", ")}, to: :#{suggested_reader_name}#{", allow_nil: #{allow_nil}" if allow_nil != ALLOW_NIL_DEFAULT}
-                private
-                #{suggested_method}
-
-          MSG
-          (ActiveRecord.respond_to?(:deprecator) ? ActiveRecord.deprecator : ActiveSupport::Deprecation).warn(message)
+          raise ArgumentError, "Instance variables cannot be specified in delegate to. (#{to})"
         end
-        allow_nil = false if allow_nil == ALLOW_NIL_DEFAULT
-        # steep:ignore:end
 
         delegations = attributes.map { Delegation.new(attribute: _1, to:, allow_nil:) }
         delegations.each { _1.define_delegated_attribute(self) }

data/lib/active_record_compose/callbacks.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "validations"
-
 module ActiveRecordCompose
   # @private
   #
@@ -23,8 +21,6 @@ module ActiveRecordCompose
     include ActiveModel::Validations::Callbacks
 
     included do
-      include ActiveRecordCompose::Validations
-
       define_model_callbacks :save
       define_model_callbacks :create
       define_model_callbacks :update

data/lib/active_record_compose/model.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 require_relative "attributes"
-require_relative "callbacks"
 require_relative "composed_collection"
 require_relative "persistence"
+require_relative "transaction_support"
+require_relative "validations"
 
 module ActiveRecordCompose
   # This is the core class of {ActiveRecordCompose}.
@@ -83,7 +84,8 @@ module ActiveRecordCompose
 
     include ActiveRecordCompose::Attributes
     include ActiveRecordCompose::Persistence
-    include ActiveRecordCompose::Callbacks
+    include ActiveRecordCompose::Validations
+    include ActiveRecordCompose::TransactionSupport
 
     begin
       # @group Model Core

data/lib/active_record_compose/persistence.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "callbacks"
 require_relative "composed_collection"
-require_relative "transaction_support"
 
 module ActiveRecordCompose
   using ComposedCollection::PackagePrivate
@@ -9,7 +9,7 @@ module ActiveRecordCompose
   # @private
   module Persistence
     extend ActiveSupport::Concern
-    include ActiveRecordCompose::TransactionSupport
+    include ActiveRecordCompose::Callbacks
 
     # Save the models that exist in models.
     # Returns false if any of the targets fail, true if all succeed.
@@ -24,11 +24,9 @@ module ActiveRecordCompose
     #
     # @return [Boolean] returns true on success, false on failure.
     def save(**options)
-      with_transaction_returning_status do
-        with_callbacks { save_models(**options, bang: false) }
-      rescue ActiveRecord::RecordInvalid
-        false
-      end
+      with_callbacks { save_models(**options, bang: false) }
+    rescue ActiveRecord::RecordInvalid
+      false
     end
 
     # Save the models that exist in models.
@@ -43,28 +41,22 @@ module ActiveRecordCompose
     # If the contexts differ, we recommend separating them into different model definitions.
     #
     def save!(**options)
-      with_transaction_returning_status do
-        with_callbacks { save_models(**options, bang: true) }
-      end || raise_on_save_error
+      with_callbacks { save_models(**options, bang: true) } || raise_on_save_error
     end
 
     # Assign attributes and save.
     #
     # @return [Boolean] returns true on success, false on failure.
-    def update(attributes = {})
-      with_transaction_returning_status do
-        assign_attributes(attributes)
-        save
-      end
+    def update(attributes)
+      assign_attributes(attributes)
+      save
     end
 
     # Behavior is same to `#update`, but raises an exception prematurely on failure.
     #
-    def update!(attributes = {})
-      with_transaction_returning_status do
-        assign_attributes(attributes)
-        save!
-      end
+    def update!(attributes)
+      assign_attributes(attributes)
+      save!
     end
 
     private

data/lib/active_record_compose/transaction_support.rb

@@ -6,18 +6,19 @@ module ActiveRecordCompose
     extend ActiveSupport::Concern
     include ActiveRecord::Transactions
 
-    module ClassMethods
-      def lease_connection
-        if ar_class.respond_to?(:lease_connection)
-          ar_class.lease_connection # steep:ignore
-        else
-          ar_class.connection
-        end
-      end
+    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
+    end
 
-      def connection = ar_class.connection
+    module ClassMethods
+      delegate :with_connection, :lease_connection, to: :ar_class
 
-      def with_connection(&) = ar_class.with_connection(&) # steep:ignore
+      # In ActiveRecord, it is soft deprecated.
+      delegate :connection, to: :ar_class
 
       def composite_primary_key? = false # steep:ignore
 

data/lib/active_record_compose/validations.rb

@@ -8,6 +8,7 @@ module ActiveRecordCompose
   # @private
   module Validations
     extend ActiveSupport::Concern
+    include ActiveModel::Validations::Callbacks
 
     included do
       validate :validate_models

data/lib/active_record_compose/version.rb

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

data/sig/_internal/package_private.rbs

@@ -15,6 +15,16 @@ module ActiveRecordCompose
       def delegated_attributes=: (Array[Delegation]) -> untyped
     end
 
+    class AttributePredicate
+      def initialize: (untyped value) -> void
+      def call: -> bool
+
+      @value: untyped
+
+      private
+      attr_reader value: untyped
+    end
+
     class Delegation
       def initialize: (attribute: String, to: Symbol, ?allow_nil: bool) -> void
       def attribute: () -> Symbol
@@ -40,6 +50,7 @@ module ActiveRecordCompose
 
       private
       def attribute?: (attribute_name) -> untyped
+      def query?: (untyped value) -> bool
     end
   end
 
@@ -87,6 +98,7 @@ module ActiveRecordCompose
   end
 
   module TransactionSupport
+    extend ActiveSupport::Concern
     include ActiveRecord::Transactions
 
     def id: -> untyped
@@ -108,8 +120,8 @@ module ActiveRecordCompose
 
     def save: (**untyped options) -> bool
     def save!: (**untyped options) -> untyped
-    def update: (?Hash[attribute_name, untyped]) -> bool
-    def update!: (?Hash[attribute_name, untyped]) -> untyped
+    def update: (Hash[attribute_name, untyped]) -> bool
+    def update!: (Hash[attribute_name, untyped]) -> untyped
 
     private
     def models: -> ComposedCollection

data/sig/active_record_compose.rbs

@@ -79,14 +79,10 @@ module ActiveRecordCompose
     def initialize: (?Hash[attribute_name, untyped]) -> void
     def save: (**untyped options) -> bool
     def save!: (**untyped options) -> untyped
-    def update: (?Hash[attribute_name, untyped]) -> bool
-    def update!: (?Hash[attribute_name, untyped]) -> untyped
-    def id: -> untyped
+    def update: (Hash[attribute_name, untyped]) -> bool
+    def update!: (Hash[attribute_name, untyped]) -> untyped
 
     private
     def models: -> ComposedCollection
-    def save_models: (bang: bool, **untyped options) -> bool
-    def raise_on_save_error: -> bot
-    def raise_on_save_error_message: -> String
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_compose
 version: !ruby/object:Gem::Version
-  version: 0.11.3
+  version: 1.0.0
 platform: ruby
 authors:
 - hamajyotan
@@ -15,7 +15,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
     - - "<"
       - !ruby/object:Gem::Version
         version: '8.1'
@@ -25,7 +25,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
     - - "<"
       - !ruby/object:Gem::Version
         version: '8.1'
@@ -45,6 +45,7 @@ files:
 - README.md
 - lib/active_record_compose.rb
 - lib/active_record_compose/attributes.rb
+- lib/active_record_compose/attributes/attribute_predicate.rb
 - lib/active_record_compose/attributes/delegation.rb
 - lib/active_record_compose/attributes/querying.rb
 - lib/active_record_compose/callbacks.rb
@@ -80,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.7.2
 specification_version: 4
 summary: activemodel form object pattern
 test_files: []