active_record_compose 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dba7d13bf8f2dc9ef449ead00c1a7ae3fff83e216f07b5d11606659a3c1f4650
-  data.tar.gz: 883a9480ff3e6bd4c99246c12200a7b5a6e44103c0d1c967ce97c4536aa478b1
+  metadata.gz: eae661ba621f2e95a089f01a029aa1918af952588e2a0204a8124e1c48aeecc3
+  data.tar.gz: '0208e91c70ea06235a2870901fcae2dfda328b8877b4ab9d776b14cd4e1de322'
 SHA512:
-  metadata.gz: 905bf7969733f738e00726f0dc7ed1442bce1f598485a72a0478fd67069c556b5d8299fdc5485636b1194e095649df550ba9f3c01ffb42c107a8a69afcde85ae
-  data.tar.gz: 22f44a63d515d31682f22641e112c3bf720c5b3ff29c8fb0a30ceb777b23847a74f053eb3591211c35bfe2e2f96de345523236d08b30365059fc3a7421437bf4
+  metadata.gz: 0e535cd4c0cc88700fbb50846db582848dd13b612274328a60382963ace26fafa06feb8ad9c724e95f4f48d257c2877ce2d74f828671f33639d533a341be2c37
+  data.tar.gz: 24ad34a3fd2b608c7f266f09417f9aeca97c494dcedd9b233a83eb5f2d6bb04e2f867acf1eb7260749886dbbbdce3f458885861277cd36dd34087ac7d7b33b8e

data/.rubocop.yml

@@ -24,6 +24,9 @@ Style/NumericPredicate:
 Style/OptionalBooleanParameter:
   Enabled: false
 
+Style/ParallelAssignment:
+  Enabled: false
+
 Style/StringLiterals:
   Enabled: true
 

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## [Unreleased]
 
+## [0.11.0] - 2025-05-30
+
+- `#attribute_names` now takes into account attributes declared in `.delegate_attribute`
+- Implemented query methods with a `?` suffix for each attribute.
+  Their evaluation behavior is consistent with ActiveRecord.
+  For example:
+  - Defining `attribute :foo` allows calling `model.foo?`.
+  - Defining `delegate_attribute :bar, to: :other` allows calling `model.bar?`.
+
+## [0.10.0] - 2025-04-07
+
+- avoid twice validation. As a side effect, save must accept argument `#save(**options)`.
+  In line with this, the model to be put into models must be
+  at least responsive to `model.valid? && model.save(validate: false)`, not `model.save()` (no arguments).
+- supports context as the first argument of `#valid?`, for example `model.valid(:custom_context)`.
+  At the same time, it accepts `options[:context]` in `#save(**options)`, such as `model.save(context: :custom_context)`.
+  However, this is a convenience support to unify the interface, not a positive one.
+
 ## [0.9.0] - 2025-03-16
 
 - removed `persisted_flag_callback_control` support.

data/README.md

@@ -2,7 +2,11 @@
 
 activemodel (activerecord) form object pattern. it embraces multiple AR models and provides a transparent interface as if they were a single model.
 
+[![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)
+[![DeepWiki](https://img.shields.io/badge/DeepWiki-hamajyotan%2Factive__record__compose-blue.svg?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACwAAAAyCAYAAAAnWDnqAAAAAXNSR0IArs4c6QAAA05JREFUaEPtmUtyEzEQhtWTQyQLHNak2AB7ZnyXZMEjXMGeK/AIi+QuHrMnbChYY7MIh8g01fJoopFb0uhhEqqcbWTp06/uv1saEDv4O3n3dV60RfP947Mm9/SQc0ICFQgzfc4CYZoTPAswgSJCCUJUnAAoRHOAUOcATwbmVLWdGoH//PB8mnKqScAhsD0kYP3j/Yt5LPQe2KvcXmGvRHcDnpxfL2zOYJ1mFwrryWTz0advv1Ut4CJgf5uhDuDj5eUcAUoahrdY/56ebRWeraTjMt/00Sh3UDtjgHtQNHwcRGOC98BJEAEymycmYcWwOprTgcB6VZ5JK5TAJ+fXGLBm3FDAmn6oPPjR4rKCAoJCal2eAiQp2x0vxTPB3ALO2CRkwmDy5WohzBDwSEFKRwPbknEggCPB/imwrycgxX2NzoMCHhPkDwqYMr9tRcP5qNrMZHkVnOjRMWwLCcr8ohBVb1OMjxLwGCvjTikrsBOiA6fNyCrm8V1rP93iVPpwaE+gO0SsWmPiXB+jikdf6SizrT5qKasx5j8ABbHpFTx+vFXp9EnYQmLx02h1QTTrl6eDqxLnGjporxl3NL3agEvXdT0WmEost648sQOYAeJS9Q7bfUVoMGnjo4AZdUMQku50McDcMWcBPvr0SzbTAFDfvJqwLzgxwATnCgnp4wDl6Aa+Ax283gghmj+vj7feE2KBBRMW3FzOpLOADl0Isb5587h/U4gGvkt5v60Z1VLG8BhYjbzRwyQZemwAd6cCR5/XFWLYZRIMpX39AR0tjaGGiGzLVyhse5C9RKC6ai42ppWPKiBagOvaYk8lO7DajerabOZP46Lby5wKjw1HCRx7p9sVMOWGzb/vA1hwiWc6jm3MvQDTogQkiqIhJV0nBQBTU+3okKCFDy9WwferkHjtxib7t3xIUQtHxnIwtx4mpg26/HfwVNVDb4oI9RHmx5WGelRVlrtiw43zboCLaxv46AZeB3IlTkwouebTr1y2NjSpHz68WNFjHvupy3q8TFn3Hos2IAk4Ju5dCo8B3wP7VPr/FGaKiG+T+v+TQqIrOqMTL1VdWV1DdmcbO8KXBz6esmYWYKPwDL5b5FA1a0hwapHiom0r/cKaoqr+27/XcrS5UwSMbQAAAABJRU5ErkJggg==)](https://deepwiki.com/hamajyotan/active_record_compose)
+
+
 
 ## Table of Contents
 
@@ -16,6 +20,8 @@ activemodel (activerecord) form object pattern. it embraces multiple AR models a
 - [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)
 - [Links](#links)
 - [Development](#development)
 - [Contributing](#contributing)
@@ -338,10 +344,70 @@ model.save # or `model.update` (the same callbacks will be triggered in all case
 # after_save called!
 ```
 
+### `#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)
+```
+
+However, this may not be ideal from a design perspective.
+If your application requires complex context-specific validations, consider separating models by context.
+
+```ruby
+class Account < ActiveRecord::Base
+  validates :name, presence: true
+  validates :email, presence: true
+  validates :email, format: { with: /\.edu\z/ }, on: :education
+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
+
+  delegate_attribute :name, :email, to: :account
+
+  private
+
+  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 as an example
+
+With Github Codespaces, it can also be run directly in the browser. Naturally, a local environment is also possible.
+
+- https://github.com/hamajyotan/active_record_compose-example
+
 ## Links
 
 - [Smart way to update multiple models simultaneously in Rails](https://dev.to/hamajyotan/smart-way-to-update-multiple-models-simultaneously-in-rails-51b6)
-- [Sample application as an example](https://github.com/hamajyotan/active_record_compose-example)
 
 ## Development
 

data/lib/active_record_compose/attribute_querying.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActiveRecordCompose
+  # = Attribute \Querying
+  #
+  # This provides predicate methods based on the attributes.
+  #
+  #   class AccountRegistration < ActiveRecordCompose::Model
+  #     def initialize
+  #       @account = Account.new
+  #       super()
+  #       models << account
+  #     end
+  #
+  #     attribute :original_attr
+  #     delegate_attribute :name, :email, to: :account
+  #
+  #     private
+  #
+  #     attr_reader :account
+  #   end
+  #
+  #   model = AccountRegistration.new
+  #
+  #   model.name                    #=> nil
+  #   model.name?                   #=> false
+  #   model.name = 'Alice'
+  #   model.name?                   #=> true
+  #
+  #   model.original_attr = "Bob"
+  #   model.original_attr?          #=> true
+  #   model.original_attr = ""
+  #   model.original_attr?          #=> false
+  #
+  #   # If the value is numeric, it returns the result of checking whether it is zero or not.
+  #   # This behavior is consistent with `ActiveRecord::AttributeMethods::Query`.
+  #   model.original_attr = 123
+  #   model.original_attr?          #=> true
+  #   model.original_attr = 0
+  #   model.original_attr?          #=> false
+  #
+  module AttributeQuerying
+    extend ActiveSupport::Concern
+
+    included do
+      attribute_method_suffix '?', parameters: false
+    end
+
+    private
+
+    def attribute?(attr_name)
+      value = 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
+    end
+  end
+end

data/lib/active_record_compose/callbacks.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveRecordCompose
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    included do
+      define_model_callbacks :save
+      define_model_callbacks :create
+      define_model_callbacks :update
+    end
+
+    private
+
+    def with_callbacks(&block) = run_callbacks(:save) { run_callbacks(callback_context, &block) }
+
+    def callback_context = persisted? ? :update : :create
+  end
+end

data/lib/active_record_compose/delegate_attribute.rb

@@ -58,6 +58,12 @@ module ActiveRecordCompose
       end
     end
 
+    # Returns a array of attribute name.
+    # Attributes declared with `delegate_attribute` are also merged.
+    #
+    # @return [Array<String>] array of attribute name.
+    def attribute_names = super + delegated_attributes
+
     # Returns a hash with the attribute name as key and the attribute value as value.
     # Attributes declared with `delegate_attribute` are also merged.
     #

data/lib/active_record_compose/model.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require 'active_record_compose/callbacks'
+require 'active_record_compose/attribute_querying'
 require 'active_record_compose/composed_collection'
 require 'active_record_compose/delegate_attribute'
 require 'active_record_compose/transaction_support'
+require 'active_record_compose/validations'
 
 module ActiveRecordCompose
   using ComposedCollection::PackagePrivate
@@ -12,12 +15,11 @@ module ActiveRecordCompose
     include ActiveModel::Validations::Callbacks
     include ActiveModel::Attributes
 
+    include ActiveRecordCompose::AttributeQuerying
+    include ActiveRecordCompose::Callbacks
     include ActiveRecordCompose::DelegateAttribute
     include ActiveRecordCompose::TransactionSupport
-
-    define_model_callbacks :save
-    define_model_callbacks :create
-    define_model_callbacks :update
+    prepend ActiveRecordCompose::Validations
 
     validate :validate_models
 
@@ -30,16 +32,16 @@ module ActiveRecordCompose
     #
     # The save is performed within a single transaction.
     #
-    # Options like `:validate` and `:context` are not accepted as arguments.
-    # The need for such values indicates that operations from multiple contexts are being handled.
-    # However, if the contexts are different, it is recommended to separate them into different model definitions.
+    # Only the `:validate` option takes effect as it is required internally.
+    # However, we do not recommend explicitly specifying `validate: false` to skip validation.
+    # Additionally, the `:context` option is not accepted.
+    # The need for such a value indicates that operations from multiple contexts are being processed.
+    # If the contexts differ, we recommend separating them into different model definitions.
     #
     # @return [Boolean] returns true on success, false on failure.
-    def save
-      return false if invalid?
-
+    def save(**options)
       with_transaction_returning_status do
-        with_callbacks { save_models(bang: false) }
+        with_callbacks { save_models(**options, bang: false) }
       rescue ActiveRecord::RecordInvalid
         false
       end
@@ -50,15 +52,15 @@ module ActiveRecordCompose
     #
     # Saving, like `#save`, is performed within a single transaction.
     #
-    # Options like `:validate` and `:context` are not accepted as arguments.
-    # The need for such values indicates that operations from multiple contexts are being handled.
-    # However, if the contexts are different, it is recommended to separate them into different model definitions.
+    # Only the `:validate` option takes effect as it is required internally.
+    # However, we do not recommend explicitly specifying `validate: false` to skip validation.
+    # Additionally, the `:context` option is not accepted.
+    # The need for such a value indicates that operations from multiple contexts are being processed.
+    # If the contexts differ, we recommend separating them into different model definitions.
     #
-    def save!
-      valid? || raise_validation_error
-
+    def save!(**options)
       with_transaction_returning_status do
-        with_callbacks { save_models(bang: true) }
+        with_callbacks { save_models(**options, bang: true) }
       end || raise_on_save_error
     end
 
@@ -66,15 +68,19 @@ module ActiveRecordCompose
     #
     # @return [Boolean] returns true on success, false on failure.
     def update(attributes = {})
-      assign_attributes(attributes)
-      save
+      with_transaction_returning_status do
+        assign_attributes(attributes)
+        save
+      end
     end
 
     # Behavior is same to `#update`, but raises an exception prematurely on failure.
     #
     def update!(attributes = {})
-      assign_attributes(attributes)
-      save!
+      with_transaction_returning_status do
+        assign_attributes(attributes)
+        save!
+      end
     end
 
     # Returns true if model is persisted.
@@ -90,20 +96,10 @@ module ActiveRecordCompose
 
     def models = @__models ||= ActiveRecordCompose::ComposedCollection.new(self)
 
-    def validate_models
-      models.__wrapped_models.lazy.select { _1.invalid? }.each { errors.merge!(_1) }
-    end
-
-    def with_callbacks(&block) = run_callbacks(:save) { run_callbacks(callback_context, &block) }
-
-    def callback_context = persisted? ? :update : :create
-
-    def save_models(bang:)
-      models.__wrapped_models.all? { bang ? _1.save! : _1.save }
+    def save_models(bang:, **options)
+      models.__wrapped_models.all? { bang ? _1.save!(**options, validate: false) : _1.save(**options, validate: false) }
     end
 
-    def raise_validation_error = raise ActiveRecord::RecordInvalid, self
-
     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.'

data/lib/active_record_compose/transaction_support.rb

@@ -18,7 +18,7 @@ module ActiveRecordCompose
 
       def with_connection(&) = ar_class.with_connection(&) # steep:ignore
 
-      def composite_primary_key? = false
+      def composite_primary_key? = false # steep:ignore
 
       private
 

data/lib/active_record_compose/validations.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveRecordCompose
+  using ComposedCollection::PackagePrivate
+
+  module Validations
+    def save(**options)
+      perform_validations(options) ? super : false
+    end
+
+    def save!(**options)
+      perform_validations(options) ? super : raise_validation_error
+    end
+
+    def valid?(context = nil) = context_for_override_validation.with_override(context) { super }
+
+    private
+
+    def validate_models
+      context = override_validation_context
+      models.__wrapped_models.lazy.select { _1.invalid?(context) }.each { errors.merge!(_1) }
+    end
+
+    def perform_validations(options)
+      options[:validate] == false || valid?(options[:context])
+    end
+
+    def raise_validation_error = raise ActiveRecord::RecordInvalid, self
+
+    def context_for_override_validation
+      @context_for_override_validation ||= OverrideValidationContext.new
+    end
+
+    def override_validation_context = context_for_override_validation.context
+
+    class OverrideValidationContext
+      attr_reader :context
+
+      def with_override(context)
+        @context, original = context, @context
+        yield
+      ensure
+        @context = original # steep:ignore
+      end
+    end
+    private_constant :OverrideValidationContext
+  end
+end

data/lib/active_record_compose/version.rb

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

data/lib/active_record_compose/wrapped_model.rb

@@ -60,7 +60,7 @@ 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
+    def save(**options)
       # 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`.
@@ -70,14 +70,14 @@ module ActiveRecordCompose
         m.destroy
       else
         # @type var m: ActiveRecordCompose::_ARLike
-        m.save
+        m.save(**options)
       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!
+    def save!(**options)
       # 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`.
@@ -87,15 +87,15 @@ module ActiveRecordCompose
         m.destroy!
       else
         # @type var model: ActiveRecordCompose::_ARLike
-        m.save!
+        m.save!(**options)
       end
     end
 
     # @return [Boolean]
-    def invalid? = destroy_context? ? false : model.invalid?
+    def invalid?(context = nil) = !valid?(context)
 
     # @return [Boolean]
-    def valid? = !invalid?
+    def valid?(context = nil) = destroy_context? || model.valid?(context)
 
     # Returns true if equivalent.
     #

data/sig/_internal/package_private.rbs

@@ -1,4 +1,23 @@
 module ActiveRecordCompose
+  module AttributeQuerying
+    extend ActiveSupport::Concern
+    extend ActiveModel::AttributeMethods::ClassMethods
+
+    private
+    def attribute?: (attribute_name) -> untyped
+  end
+
+  module Callbacks
+    include ActiveModel::Model
+    include ActiveModel::Validations::Callbacks
+    extend ActiveSupport::Concern
+    extend ActiveModel::Callbacks
+
+    private
+    def with_callbacks: { () -> bool } -> bool
+    def callback_context: -> (:create | :update)
+  end
+
   class ComposedCollection
     def initialize: (Model) -> void
 
@@ -20,7 +39,6 @@ module ActiveRecordCompose
   module DelegateAttribute : ActiveModel::Attributes
     extend ActiveSupport::Concern
 
-    def attributes: -> Hash[String, untyped]
     def delegated_attributes: () -> Array[String]
 
     module ClassMethods : Module
@@ -35,8 +53,13 @@ module ActiveRecordCompose
     extend DelegateAttribute::ClassMethods
     include TransactionSupport
     extend TransactionSupport::ClassMethods
+    include ActiveRecordCompose::Callbacks
 
     @__models: ComposedCollection
+
+    private
+    def validate_models: -> void
+    def override_validation_context: -> validation_context
   end
 
   module TransactionSupport
@@ -54,14 +77,37 @@ module ActiveRecordCompose
     end
   end
 
+  module Validations : Model
+    def save: (**untyped options) -> bool
+    def save!: (**untyped options) -> untyped
+    def valid?: (?validation_context context) -> bool
+
+    @context_for_override_validation: OverrideValidationContext
+
+    private
+
+    def perform_validations: (::Hash[untyped, untyped]) -> bool
+    def raise_validation_error: -> bot
+    def context_for_override_validation: -> OverrideValidationContext
+    def override_validation_context: -> validation_context
+
+    class OverrideValidationContext
+      @context: validation_context
+
+      attr_reader context: validation_context
+
+      def with_override: [T] (validation_context) { () -> T } -> T
+    end
+  end
+
   class WrappedModel
     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 save: (**untyped options) -> bool
+    def save!: (**untyped options) -> untyped
+    def invalid?: (?validation_context context) -> bool
+    def valid?: (?validation_context context) -> bool
     def is_a?: (untyped) -> bool
     def ==: (untyped) -> bool
 

data/sig/active_record_compose.rbs

@@ -5,27 +5,29 @@ module ActiveRecordCompose
   VERSION: String
 
   interface _ARLike
-    def save: -> bool
-    def save!: -> untyped
-    def invalid?: -> bool
-    def valid?: -> bool
+    def save: (**untyped options) -> bool
+    def save!: (**untyped options) -> untyped
+    def invalid?: (?validation_context context) -> bool
+    def valid?: (?validation_context context) -> bool
     def errors: -> untyped
     def is_a?: (untyped) -> bool
     def ==: (untyped) -> bool
   end
   interface _ARLikeWithDestroy
-    def save: -> bool
-    def save!: -> untyped
+    def save: (**untyped options) -> bool
+    def save!: (**untyped options) -> untyped
     def destroy: -> bool
     def destroy!: -> untyped
-    def invalid?: -> bool
-    def valid?: -> bool
+    def invalid?: (?validation_context context) -> bool
+    def valid?: (?validation_context context) -> bool
     def errors: -> untyped
     def is_a?: (untyped) -> bool
     def ==: (untyped) -> bool
   end
   type ar_like = (_ARLike | _ARLikeWithDestroy)
 
+  type validation_context = nil | Symbol | Array[Symbol]
+
   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
@@ -75,21 +77,15 @@ module ActiveRecordCompose
     def self.with_connection: [T] () { () -> T } -> T
 
     def initialize: (?Hash[attribute_name, untyped]) -> void
-    def save: -> bool
-    def save!: -> untyped
-    def create: (?Hash[attribute_name, untyped]) -> bool
-    def create!: (?Hash[attribute_name, untyped]) -> untyped
+    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
 
     private
     def models: -> ComposedCollection
-    def with_callbacks: { () -> bool } -> bool
-    def callback_context: -> (:create | :update)
-    def validate_models: -> void
-    def save_models: (bang: bool) -> bool
-    def raise_validation_error: -> bot
+    def save_models: (bang: bool, **untyped options) -> bool
     def raise_on_save_error: -> bot
     def raise_on_save_error_message: -> String
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: active_record_compose
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.11.0
 platform: ruby
 authors:
 - hamajyotan
 bindir: bin
 cert_chain: []
-date: 2025-03-16 00:00:00.000000000 Z
+date: 2025-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -37,10 +37,13 @@ files:
 - LICENSE.txt
 - README.md
 - lib/active_record_compose.rb
+- lib/active_record_compose/attribute_querying.rb
+- lib/active_record_compose/callbacks.rb
 - lib/active_record_compose/composed_collection.rb
 - lib/active_record_compose/delegate_attribute.rb
 - lib/active_record_compose/model.rb
 - lib/active_record_compose/transaction_support.rb
+- lib/active_record_compose/validations.rb
 - lib/active_record_compose/version.rb
 - lib/active_record_compose/wrapped_model.rb
 - sig/_internal/package_private.rbs
@@ -52,7 +55,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.9.0
+  documentation_uri: https://www.rubydoc.info/gems/active_record_compose/0.11.0
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: