active_record-associated_object 0.5.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b973496c3658defdee08fb40292bad58fadbc743a732cface722c40f8b8152c
-  data.tar.gz: c6a3758599c0f5ce22470c18c23c958ebf05827a7f52ae0d07507cbd4b8b6346
+  metadata.gz: d24bf37946a6b4e5ddcb1626e90eb91e27932ae8d9f8f29c10c095ce3c53897c
+  data.tar.gz: 7f7d23788109d020fb1b010e8e6f3956880dfeb012c517dfc43e1f5c7862fd6c
 SHA512:
-  metadata.gz: 57db29d169ee310087c539e1eb64ccce3bdeb6a98bdb7532723db4f90656140d521c9925efb3aa17782cd84b3e1906dfaaf0cd6dd72d69ad54e90b159a423547
-  data.tar.gz: dca66954be7f3e84ea76010e7714366532c506eb3ab02c1174bd47122ecce0af5223656ee11ed425d962d86b5a443ce69b95a187d40318ff555f497103df88ff
+  metadata.gz: 72675998afa72ea4117fd3601e9df6c9dbd2f62ae1541e1b6677903dd5c32109bd06c281e9be98d7742b92dcf6e48f2792764a5c661729ef2df95d6ce54cd2c4
+  data.tar.gz: 3d4244067099adec3ac04a185019bd99aba3078578ede15315893eb6c8f6b9a98cf8cd6356e74e37a395f39ec20013e83529ab6f9766dd014f154d3d03591718

data/Gemfile.lock

@@ -1,39 +1,40 @@
 PATH
   remote: .
   specs:
-    active_record-associated_object (0.5.2)
+    active_record-associated_object (0.7.0)
       activerecord (>= 6.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    actionpack (7.1.1)
-      actionview (= 7.1.1)
-      activesupport (= 7.1.1)
+    actionpack (7.1.2)
+      actionview (= 7.1.2)
+      activesupport (= 7.1.2)
       nokogiri (>= 1.8.5)
+      racc
       rack (>= 2.2.4)
       rack-session (>= 1.0.1)
       rack-test (>= 0.6.3)
       rails-dom-testing (~> 2.2)
       rails-html-sanitizer (~> 1.6)
-    actionview (7.1.1)
-      activesupport (= 7.1.1)
+    actionview (7.1.2)
+      activesupport (= 7.1.2)
       builder (~> 3.1)
       erubi (~> 1.11)
       rails-dom-testing (~> 2.2)
       rails-html-sanitizer (~> 1.6)
-    active_job-performs (0.2.0)
+    active_job-performs (0.3.0)
       activejob (>= 6.1)
-    activejob (7.1.1)
-      activesupport (= 7.1.1)
+    activejob (7.1.2)
+      activesupport (= 7.1.2)
       globalid (>= 0.3.6)
-    activemodel (7.1.1)
-      activesupport (= 7.1.1)
-    activerecord (7.1.1)
-      activemodel (= 7.1.1)
-      activesupport (= 7.1.1)
+    activemodel (7.1.2)
+      activesupport (= 7.1.2)
+    activerecord (7.1.2)
+      activemodel (= 7.1.2)
+      activesupport (= 7.1.2)
       timeout (>= 0.4.0)
-    activesupport (7.1.1)
+    activesupport (7.1.2)
       base64
       bigdecimal
       concurrent-ruby (~> 1.0, >= 1.0.2)
@@ -43,45 +44,45 @@ GEM
       minitest (>= 5.1)
       mutex_m
       tzinfo (~> 2.0)
-    base64 (0.1.1)
-    bigdecimal (3.1.4)
+    base64 (0.2.0)
+    bigdecimal (3.1.5)
     builder (3.2.4)
     concurrent-ruby (1.2.2)
     connection_pool (2.4.1)
     crass (1.0.6)
-    debug (1.8.0)
-      irb (>= 1.5.0)
-      reline (>= 0.3.1)
-    drb (2.1.1)
+    debug (1.9.1)
+      irb (~> 1.10)
+      reline (>= 0.3.8)
+    drb (2.2.0)
       ruby2_keywords
     erubi (1.12.0)
     globalid (1.2.1)
       activesupport (>= 6.1)
     i18n (1.14.1)
       concurrent-ruby (~> 1.0)
-    io-console (0.6.0)
-    irb (1.8.3)
+    io-console (0.7.1)
+    irb (1.11.0)
       rdoc
       reline (>= 0.3.8)
-    kredis (1.6.0)
+    kredis (1.7.0)
       activemodel (>= 6.0.0)
       activesupport (>= 6.0.0)
       redis (>= 4.2, < 6)
-    loofah (2.21.4)
+    loofah (2.22.0)
       crass (~> 1.0.2)
       nokogiri (>= 1.12.0)
     minitest (5.20.0)
     minitest-sprint (1.2.2)
       path_expander (~> 1.1)
-    mutex_m (0.1.2)
-    nokogiri (1.15.4-arm64-darwin)
+    mutex_m (0.2.0)
+    nokogiri (1.16.0-arm64-darwin)
       racc (~> 1.4)
-    nokogiri (1.15.4-x86_64-linux)
+    nokogiri (1.16.0-x86_64-linux)
       racc (~> 1.4)
     path_expander (1.1.1)
-    psych (5.1.1.1)
+    psych (5.1.2)
       stringio
-    racc (1.7.1)
+    racc (1.7.3)
     rack (3.0.8)
     rack-session (2.0.0)
       rack (>= 3.0.0)
@@ -97,29 +98,29 @@ GEM
     rails-html-sanitizer (1.6.0)
       loofah (~> 2.21)
       nokogiri (~> 1.14)
-    railties (7.1.1)
-      actionpack (= 7.1.1)
-      activesupport (= 7.1.1)
+    railties (7.1.2)
+      actionpack (= 7.1.2)
+      activesupport (= 7.1.2)
       irb
       rackup (>= 1.0.0)
       rake (>= 12.2)
       thor (~> 1.0, >= 1.2.2)
       zeitwerk (~> 2.6)
     rake (13.1.0)
-    rdoc (6.5.0)
+    rdoc (6.6.2)
       psych (>= 4.0.0)
     redis (5.0.8)
       redis-client (>= 0.17.0)
-    redis-client (0.18.0)
+    redis-client (0.19.1)
       connection_pool
-    reline (0.3.9)
+    reline (0.4.2)
       io-console (~> 0.5)
     ruby2_keywords (0.0.5)
-    sqlite3 (1.6.7-arm64-darwin)
-    sqlite3 (1.6.7-x86_64-linux)
-    stringio (3.0.8)
+    sqlite3 (1.7.0-arm64-darwin)
+    sqlite3 (1.7.0-x86_64-linux)
+    stringio (3.1.0)
     thor (1.3.0)
-    timeout (0.4.0)
+    timeout (0.4.1)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
     webrick (1.8.1)
@@ -129,6 +130,7 @@ PLATFORMS
   arm64-darwin-20
   arm64-darwin-21
   arm64-darwin-22
+  arm64-darwin-23
   x86_64-linux
 
 DEPENDENCIES
@@ -144,4 +146,4 @@ DEPENDENCIES
   sqlite3
 
 BUNDLED WITH
-   2.4.21
+   2.5.4

data/README.md

@@ -1,81 +1,249 @@
 # ActiveRecord::AssociatedObject
 
-Associate a Ruby PORO with an Active Record class and have it quack like one. Build and extend your domain model relying on the Active Record association to make it unique.
+Rails applications can end up with models that get way too big, and so far, the
+Ruby community response has been Service Objects. But sometimes `app/services`
+can turn into another junk drawer that doesn't help you build and make concepts for your Domain Model.
 
-## Usage
+`ActiveRecord::AssociatedObject` takes that head on. Associated Objects are a new domain concept, a context object, that's meant to
+help you tease out collaborator objects for your Active Record models.
+
+They're essentially POROs that you associate with an Active Record model to get benefits both in simpler code as well as automatic `app/models` organization.
+
+Let's look at an example. Say you have a `Post` model that encapsulates a blog post in a Content-Management-System:
+
+```ruby
+class Post < ApplicationRecord
+end
+```
+
+You've identified that several things need to happen when a post gets published.
+But where does that behavior live; in `Post`? That might get messy.
+
+If we put it in a classic Service Object, we've got access to a `def call` method and that's it — what if we need other methods that operate on the state? And then having `PublishPost` or a similar ad-hoc name in `app/services` can pollute that folder over time.
+
+What if we instead identified a `Publisher` collaborator object, a Ruby class that handles publishing? What if we required it to be placed within `Post::` to automatically help connote the object as belonging to and collaborating with `Post`? Then we'd get `app/models/post/publisher.rb` which guides naming and gives more organization in your app automatically through that convention — and helps prevent a junk drawer from forming.
+
+This is what Associated Objects are! We'd define it like this:
+
+```ruby
+# app/models/post/publisher.rb
+class Post::Publisher < ActiveRecord::AssociatedObject
+end
+```
+
+And then you can declare it in `Post`:
 
 ```ruby
 # app/models/post.rb
-class Post < ActiveRecord::Base
-  # `has_object` defines a `publisher` method that calls Post::Publisher.new(post).
+class Post < ApplicationRecord
   has_object :publisher
 end
+```
 
-# app/models/post/publisher.rb
+There isn't anything super special happening yet. Here's essentially what's happening under the hood:
+
+```ruby
 class Post::Publisher
-  def initialize(post)
-    @post = post
-  end
+  attr_reader :post
+  def initialize(post) = @post = post
+end
+
+class Post < ApplicationRecord
+  def publisher = (@associated_objects ||= {})[:publisher] ||= Post::Publisher.new(self)
 end
 ```
 
-If you want Active Job, GlobalID and Kredis integration you can also have `Post::Publisher` inherit from `ActiveRecord::AssociatedObject`. This extends the standard PORO with details from the `Post::` namespace and the post primary key.
+Note: due to Ruby's Object Shapes, we use a single `@associated_objects` instance variable that's assigned to `nil` on `Post.new`. This prevents Active Record's from ballooning into many different shapes in Ruby's internals.
+We've fixed this so you don't need to care, but this is what's happening.
 
-```ruby
-# app/models/post/publisher.rb
-class Post::Publisher < ActiveRecord::AssociatedObject
-  # ActiveRecord::AssociatedObject defines initialize(post) automatically. It's derived from the `Post::` namespace.
+> [!TIP]
+> `has_object` only requires a namespace and an initializer that takes a single argument. The above `Post::Publisher` is perfectly valid as an Associated Object — same goes for `class Post::Publisher < Data.define(:post); end`.
 
-  kredis_datetime :publish_at # Kredis integration generates a "post:publishers:<post_id>:publish_at" key.
+> [!TIP]
+> You can pass multiple names too: `has_object :publisher, :classified, :fortification`. I recommend `-[i]er`, `-[i]ed` and `-ion` as the general naming conventions for your Associated Objects.
 
-  # `performs` builds a `Post::Publisher::PublishJob` and routes configs over to it.
-  performs :publish, queue_as: :important, discard_on: SomeError do
-    retry_on TimeoutError, wait: :exponentially_longer
-  end
+See how we're always expecting a link to the model, here `post`?
+
+Because of that, you can rely on `post` from the associated object:
 
+```ruby
+class Post::Publisher < ActiveRecord::AssociatedObject
   def publish
     # `transaction` is syntactic sugar for `post.transaction` here.
     transaction do
-      # A `post` method is generated to access the associated post. There's also a `record` alias available.
       post.update! published: true
       post.subscribers.post_published post
+
+      # There's also a `record` alias available if you prefer the more general reading version:
+      # record.update! published: true
+      # record.subscribers.post_published record
     end
   end
 end
 ```
 
-### Namespaced models
+### Forwarding callbacks onto the associated object
 
-If you have a namespaced Active Record like this:
+To further help illustrate how your collaborator Associated Objects interact with your domain model, you can forward callbacks.
+
+Say we wanted to have our `publisher` automatically publish posts after they're created. Or we need to refresh a publishing after a post has been touched. Or what if we don't want posts to be destroyed if they're published due to HAHA BUSINESS rules?
+
+So `has_object` can state this and forward those callbacks onto the Associated Object:
 
 ```ruby
-# app/models/post/comment.rb
-class Post::Comment < ApplicationRecord
-  belongs_to :post
+class Post < ActiveRecord::Base
+  # Passing `true` forwards the same name, e.g. `after_touch`.
+  has_object :publisher, after_touch: true, after_create_commit: :publish,
+    before_destroy: :prevent_errant_post_destroy
 
-  has_object :rating
+  # The above is the same as writing:
+  after_create_commit { publisher.publish }
+  after_touch { publisher.after_touch }
+  before_destroy { publisher.prevent_errant_post_destroy }
+end
+
+class Post::Publisher < ActiveRecord::AssociatedObject
+  def publish
+  end
+
+  def after_touch
+    # Respond to the after_touch on the Post.
+  end
+
+  def prevent_errant_post_destroy
+    # Passed callbacks can throw :abort too, and in this example prevent post.destroy.
+    throw :abort if haha_business?
+  end
 end
 ```
 
-You can define the associated object in the same way it was done for `Post::Publisher` above, within the `Post::Comment` namespace:
+### Extending the Active Record from within the Associated Object
+
+Since `has_object` eager-loads the Associated Object class, you can also move
+any integrating code into a provided `extension` block:
+
+> [!NOTE]
+> Technically, `extension` is just `Post.class_eval` but with syntactic sugar.
 
 ```ruby
-# app/models/post/comment/rating.rb
-class Post::Comment::Rating < ActiveRecord::AssociatedObject
-  def great?
-    # A `comment` method is generated to access the associated comment. There's also a `record` alias available.
-    comment.author.subscriber_of? comment.post.author
+class Post::Publisher < ActiveRecord::AssociatedObject
+  extension do
+    # Here we're within Post and can extend it:
+    has_many :contracts, dependent: :destroy do
+      def signed? = all?(&:signed?)
+    end
+
+    def self.with_contracts = includes(:contracts)
+
+    after_create_commit :publish_later, if: -> { contracts.signed? }
+
+    # An integrating method that operates on `publisher`.
+    private def publish_later = publisher.publish_later
   end
 end
 ```
 
-### Composite primary keys
+This is meant as an alternative to having a wrapping `ActiveSupport::Concern` in yet-another file like this:
 
-We support Active Record models with composite primary keys out of the box.
+```ruby
+class Post < ApplicationRecord
+  include Published
+end
 
-Just setup the associated objects like the above examples and you've got GlobalID/Active Job and Kredis support automatically.
+# app/models/post/published.rb
+module Post::Published
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :contracts, dependent: :destroy do
+      def signed? = all?(&:signed?)
+    end
+
+    has_object :publisher
+    after_create_commit :publish_later, if: -> { contracts.signed? }
+  end
+
+  class_methods do
+    def with_contracts = includes(:contracts)
+  end
 
-### Remove Active Job boilerplate with `performs`
+  # An integrating method that operates on `publisher`.
+  private def publish_later = publisher.publish_later
+end
+```
+
+> [!NOTE]
+> Notice how in the `extension` version you don't need to:
+>
+> - have a naming convention for Concerns and where to place them.
+> - look up two files to read the feature (the concern and the associated object).
+> - wrap integrating code in an `included` block.
+> - wrap class methods in a `class_methods` block.
+
+### Primary Benefit: Organization through Convention
+
+The primary benefit for right now is that by focusing the concept of namespaced Collaborator Objects through Associated Objects, you will start seeing them when you're modelling new features and it'll change how you structure and write your apps.
+
+This is what [@natematykiewicz](https://github.com/natematykiewicz) found when they started using the gem (we'll get to `ActiveJob::Performs` soon):
+
+> We're running `ActiveRecord::AssociatedObject` and `ActiveJob::Performs` (via the associated object) in 3 spots in production so far. It massively improved how I was architecting a new feature. I put a PR up for review and a coworker loved how organized and easy to follow the large PR was because of those 2 gems. I'm now working on another PR in our app where I'm using them again. I keep seeing use-cases for them now. I love it. Thank you for these gems!
+>
+> Anyone reading this, if you haven't checked them out yet, I highly recommend it.
+
+And about a month later it was still holding up:
+
+> Just checking in to say we've added like another 4 associated objects to production since my last message. `ActiveRecord::AssociatedObject` + `ActiveJob::Performs` is like a 1-2 punch super power. I'm a bit surprised that this isn't Rails core to be honest. I want to migrate so much of our code over to this. It feels much more organized and sane. Then my app/jobs folder won't have much in it because most jobs will actually be via some associated object's _later method. app/jobs will then basically be cron-type things (deactivate any expired subscriptions).
+
+Let's look at testing, then we'll get to passing these POROs to jobs like the quotes mentioned!
+
+### A Quick Aside: Testing Associated Objects
+
+Follow the `app/models/post.rb` and `app/models/post/publisher.rb` naming structure in your tests and add `test/models/post/publisher_test.rb`.
+
+Then test it like any other object:
+
+```ruby
+# test/models/post/publisher_test.rb
+class Post::PublisherTest < ActiveSupport::TestCase
+  # You can use Fixtures/FactoryBot to get a `post` and then extract its `publisher`:
+  setup { @publisher = posts(:one).publisher }
+  setup { @publisher = FactoryBot.build(:post).publisher }
+
+  test "publish updates the post" do
+    @publisher.publish
+    assert @publisher.post.reload.published?
+  end
+end
+```
+
+### Active Job integration via GlobalID
+
+Associated Objects include `GlobalID::Identification` and have automatic Active Job serialization support that looks like this:
+
+```ruby
+class Post::Publisher < ActiveRecord::AssociatedObject
+  class PublishJob < ApplicationJob
+    def perform(publisher) = publisher.publish
+  end
+
+  def publish_later
+    PublishJob.perform_later self # We're passing this PORO to the job!
+  end
+
+  def publish
+    # …
+  end
+end
+```
+
+> [!NOTE]
+> Internally, Active Job serializes Active Records as GlobalIDs. Active Record also includes `GlobalID::Identification`, which requires the `find` and `where(id:)` class methods.
+>
+> We've added `Post::Publisher.find` & `Post::Publisher.where(id:)` that calls `Post.find(id).publisher` and `Post.where(id:).map(&:publisher)` respectively.
+
+This pattern of a job `perform` consisting of calling an instance method on a sole domain object is ripe for a convention, here's how to do that.
+
+#### Remove Active Job boilerplate with `performs`
 
 If you also bundle [`active_job-performs`](https://github.com/kaspth/active_job-performs) in your Gemfile like this:
 
@@ -84,7 +252,7 @@ gem "active_job-performs"
 gem "active_record-associated_object"
 ```
 
-Every associated object now has access to the `performs` macro, so you can do this:
+Every Associated Object (and Active Records too) now has access to the `performs` macro, so you can do this:
 
 ```ruby
 class Post::Publisher < ActiveRecord::AssociatedObject
@@ -100,7 +268,7 @@ class Post::Publisher < ActiveRecord::AssociatedObject
 end
 ```
 
-which is equivalent to this:
+which spares you writing all this:
 
 ```ruby
 class Post::Publisher < ActiveRecord::AssociatedObject
@@ -111,56 +279,87 @@ class Post::Publisher < ActiveRecord::AssociatedObject
 
   # Individual method jobs inherit from the `Post::Publisher::Job` defined above.
   class PublishJob < Job
-    def perform(publisher, *arguments, **options)
-      # GlobalID integration means associated objects can be passed into jobs like Active Records, i.e. we don't have to do `post.publisher`.
-      publisher.publish(*arguments, **options)
-    end
+    # Here's the GlobalID integration again, i.e. we don't have to do `post.publisher`.
+    def perform(publisher, *, **) = publisher.publish(*, **)
   end
 
   class RetractJob < Job
-    def perform(publisher, *arguments, **options)
-      publisher.retract(*arguments, **options)
-    end
+    def perform(publisher, *, **) = publisher.retract(*, **)
   end
 
-  def publish_later(*arguments, **options)
-    PublishJob.perform_later(self, *arguments, **options)
-  end
+  def publish_later(*, **) = PublishJob.perform_later(self, *, **)
+  def retract_later(*, **) = RetractJob.perform_later(self, *, **)
+end
+```
 
-  def retract_later(*arguments, **options)
-    RetractJob.perform_later(self, *arguments, **options)
-  end
+Note: you can also pass more complex configuration like this:
+
+```ruby
+performs :publish, queue_as: :important, discard_on: SomeError do
+  retry_on TimeoutError, wait: :exponentially_longer
 end
 ```
 
-See the `ActiveJob::Performs` README for more details.
+See [the `ActiveJob::Performs` README](https://github.com/kaspth/active_job-performs) for more details.
 
-### Passing callbacks onto the associated object
+### Automatic Kredis integration
 
-`has_object` accepts a hash of callbacks to pass.
+We've got automatic Kredis integration for Associated Objects, so you can use any `kredis_*` type just like in Active Record classes:
 
 ```ruby
-class Post < ActiveRecord::Base
-  # Callbacks can be passed too to a specific method.
-  has_object :publisher, after_touch: true, before_destroy: :prevent_errant_post_destroy
+class Post::Publisher < ActiveRecord::AssociatedObject
+  kredis_datetime :publish_at # Uses a namespaced "post:publishers:<post_id>:publish_at" key.
+end
+```
 
-  # The above is the same as writing:
-  after_touch { publisher.after_touch }
-  before_destroy { publisher.prevent_errant_post_destroy }
+> [!NOTE]
+> Under the hood, this reuses the same info we needed for automatic Active Job support. Namely, the Active Record class, here `Post`, and its `id`.
+
+### Namespaced models
+
+If you have a namespaced Active Record like this:
+
+```ruby
+# app/models/post/comment.rb
+class Post::Comment < ApplicationRecord
+  belongs_to :post
+  belongs_to :creator, class_name: "User"
+
+  has_object :rating
 end
+```
 
-class Post::Publisher < ActiveRecord::AssociatedObject
-  def after_touch
-    # Respond to the after_touch on the Post.
+You can define the associated object in the same way it was done for `Post::Publisher` above, within the `Post::Comment` namespace:
+
+```ruby
+# app/models/post/comment/rating.rb
+class Post::Comment::Rating < ActiveRecord::AssociatedObject
+  def good?
+    # A `comment` method is generated to access the associated comment. There's also a `record` alias available.
+    comment.creator.subscriber_of? comment.post.creator
   end
+end
+```
 
-  def prevent_errant_post_destroy
-    # Passed callbacks can throw :abort too, and in this example prevent post.destroy.
-    throw :abort if haha_business?
+And then test it in `test/models/post/comment/rating_test.rb`:
+
+```ruby
+class Post::Comment::RatingTest < ActiveSupport::TestCase
+  setup { @rating = posts(:one).comments.first.rating }
+  setup { @rating = FactoryBot.build(:post_comment).rating }
+
+  test "pretty, pretty, pretty, pretty good" do
+    assert @rating.good?
   end
 end
 ```
 
+### Composite primary keys
+
+We support Active Record models with composite primary keys out of the box.
+
+Just setup the associated objects like the above examples and you've got GlobalID/Active Job and Kredis support automatically.
+
 ## Risks of depending on this gem
 
 This gem is relatively tiny and I'm not expecting more significant changes on it, for right now. It's unofficial and not affiliated with Rails core.

data/active_record-associated_object.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.summary  = "Associate a Ruby PORO with an Active Record class and have it quack like one."
   spec.homepage = "https://github.com/kaspth/active_record-associated_object"
   spec.license  = "MIT"
-  spec.required_ruby_version = ">= 2.7.0"
+  spec.required_ruby_version = ">= 3.0.0"
 
   spec.metadata["homepage_uri"]    = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage

data/lib/active_record/associated_object/object_association.rb

@@ -1,4 +1,6 @@
 module ActiveRecord::AssociatedObject::ObjectAssociation
+  def self.included(klass) = klass.extend(ClassMethods)
+
   using Module.new {
     refine Module do
       def extend_source_from(chunks, &block)
@@ -9,15 +11,22 @@ module ActiveRecord::AssociatedObject::ObjectAssociation
     end
   }
 
-  def has_object(*names, **callbacks)
-    extend_source_from(names) do |name|
-      "def #{name}; @#{name} ||= #{self.name}::#{name.to_s.classify}.new(self); end"
-    end
+  module ClassMethods
+    def has_object(*names, **callbacks)
+      extend_source_from(names) do |name|
+        "def #{name}; (@associated_objects ||= {})[:#{name}] ||= #{name.to_s.classify}.new(self); end"
+      end
 
-    extend_source_from(names) do |name|
-      callbacks.map do |callback, method|
-        "#{callback} { #{name}.#{method == true ? callback : method} }"
+      extend_source_from(names) do |name|
+        callbacks.map do |callback, method|
+          "#{callback} { #{name}.#{method == true ? callback : method} }"
+        end
       end
     end
   end
+
+  def init_internals
+    @associated_objects = nil
+    super
+  end
 end

data/lib/active_record/associated_object/railtie.rb

@@ -16,7 +16,7 @@ class ActiveRecord::AssociatedObject::Railtie < Rails::Railtie
 
     ActiveSupport.on_load :active_record do
       require "active_record/associated_object/object_association"
-      extend ActiveRecord::AssociatedObject::ObjectAssociation
+      include ActiveRecord::AssociatedObject::ObjectAssociation
     end
   end
 end

data/lib/active_record/associated_object/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   class AssociatedObject
-    VERSION = "0.5.2"
+    VERSION = "0.7.0"
   end
 end

data/lib/active_record/associated_object.rb

@@ -15,6 +15,10 @@ class ActiveRecord::AssociatedObject
       klass.delegate :record_klass, :attribute_name, to: :class
     end
 
+    def extension(&block)
+      record_klass.class_eval(&block)
+    end
+
     def respond_to_missing?(...) = record_klass.respond_to?(...) || super
     delegate :unscoped, :transaction, :primary_key, to: :record_klass
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record-associated_object
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Kasper Timm Hansen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-13 00:00:00.000000000 Z
+date: 2024-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -58,14 +58,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Associate a Ruby PORO with an Active Record class and have it quack like