active_record-associated_object 0.8.3 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4212b6fcecceb21ae133688c2a3332d29b8c0f5760f5a22a8ba3450037a95b20
-  data.tar.gz: 4b96fde3db82d00a3c94153cb9b212f1091bd0040d7d9771d300f2a0a0147d6f
+  metadata.gz: 1876318d0052119a7e4080257d42bff11fee22385ac25a5d78023ce958d46fb9
+  data.tar.gz: d1089ada8474d59399331a71ec0815afd5a4a792191530fd273d25f0f328a916
 SHA512:
-  metadata.gz: 262b75fdf718925e7772b7c1dd4e49ab6b73f6706be97081433712a4f3efef524b1677194ff5376415fe32e770bfa080afd5b347c2ccf78786517dfe5a21a9fb
-  data.tar.gz: 47c40f2a351cd49fe9bc5e0488d37ce79bcb3d30332b3aabbaff681ef7ac7f937d81d01c60d6b7f8393d3fc28f7fa92fb9b4d5eb99ae607d95d0389deea12764
+  metadata.gz: f8200ebd8b229a4077af91fe9ab7b3af686de67c844a208cf843b8d828cb1d5a19fd65560bf4d911a02a67525f08541e31ad21d701fdb452f7a0113a01792cd3
+  data.tar.gz: d88d3a02dc2e9fbecef0a1060d1bdb35798ca8280ff860800e1c89219247b815e3ff16a7d7c5b0c193fa1474900b18aa96b23ce6ffe89c1c1adb68d135095f2d

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    active_record-associated_object (0.8.3)
+    active_record-associated_object (0.9.0)
       activerecord (>= 6.1)
 
 GEM

data/README.md

@@ -151,7 +151,17 @@ end
 ### 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:
+any integrating code into the Associated Object.
+
+If you've got a few extensions, you can use `record` to access the Active Record class:
+
+```ruby
+class Post::Publisher < ActiveRecord::AssociatedObject
+  record.has_many :contracts, dependent: :destroy # `record` returns `Post` here.
+end
+```
+
+Alternatively, if you have many extensions, use the `extension` block:
 
 > [!NOTE]
 > Technically, `extension` is just `Post.class_eval` but with syntactic sugar.
@@ -231,7 +241,7 @@ Here's what [@nshki](https://github.com/nshki) found when they tried it:
 
 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
+### 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`.
 
@@ -251,6 +261,87 @@ class Post::PublisherTest < ActiveSupport::TestCase
 end
 ```
 
+### Active Model integration
+
+Associated Objects quack like `ActiveModel`s because we:
+
+- [`extend ActiveModel::Naming`](https://api.rubyonrails.org/classes/ActiveModel/Naming.html)
+- [`include ActiveModel::Conversion`](https://api.rubyonrails.org/classes/ActiveModel/Conversion.html)
+
+This means you can pass them to helpers like `form_with` and route helpers like `url_for` too.
+
+> [!NOTE]
+> We don't `include ActiveModel::Model` since we don't need `assign_attributes` and validations really.
+
+```ruby
+# app/controllers/post/publishers_controller.rb
+class Post::PublishersController < ApplicationController
+  before_action :set_publisher
+
+  def new
+  end
+
+  def create
+    @publisher.publish params.expect(publisher: :toast)
+    redirect_back_or_to root_url, notice: "Out it goes!"
+  end
+
+  private
+    def set_publisher
+      # Associated Objects are POROs, so behind the scenes we're really doing `Post.find(…).publisher`.
+      @publisher = Post::Publisher.find(params[:id])
+    end
+end
+```
+
+And then on the view side, you can pass it into `form_with`:
+
+```erb
+<%# app/views/post/publishers/new.html.erb %>
+<%# Here `form_with` calls `url_for(@publisher)` which calls `post_publisher_path(@publisher)`. %>
+<%= form_with model: @publisher do |form| %>
+  <%= form.text_field :toast %>
+  <%= form.submit "Publish with toast" %>
+<% end %>
+```
+
+Finally, the routing is pretty standard fare:
+
+```ruby
+namespace :post do
+  resources :publishers
+end
+```
+
+#### Rendering Associated Objects
+
+Associated Objects respond to `to_partial_path`, so you can pass them directly to `render`.
+
+We're using Rails' conventions here, so view paths look like this:
+
+```erb
+<%# With a Post::Publisher, this renders app/views/post/publishers/_publisher.html.erb %>
+<%= render publisher %>
+
+<%# With a Post::Comment::Rating, this renders app/views/post/comment/ratings/_rating.html.erb %>
+<%= render rating %>
+```
+
+We've also got full support for fragment caching, so this is possible:
+
+```erb
+<%# app/views/post/publishers/_publisher.html.erb %>
+<%= cache publisher do %>
+  <%# More publishing specific view logic. %>
+<% end %>
+```
+
+> [!NOTE]
+> We only support recyclable cache keys which has been the default since Rails 5.2.
+> This means the Active Record you associate with must have `SomeModel.cache_versioning = true` enabled.
+>
+> Associated Objects respond to `cache_key`, `cache_version` and `cache_key_with_version` like Active Records.
+
 ### Polymorphic Associated Objects
 
 If you want to share logic between associated objects, you can do so via standard Ruby modules:

data/lib/active_record/associated_object/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   class AssociatedObject
-    VERSION = "0.8.3"
+    VERSION = "0.9.0"
   end
 end

data/lib/active_record/associated_object.rb

@@ -1,38 +1,63 @@
+# frozen_string_literal: true
+
 class ActiveRecord::AssociatedObject
+  extend ActiveModel::Naming
+  include ActiveModel::Conversion
+
   class << self
-    def inherited(klass)
-      record_klass   = klass.module_parent
-      record_name    = klass.module_parent_name.demodulize.underscore
-      attribute_name = klass.to_s.demodulize.underscore.to_sym
+    def inherited(new_object)
+      new_object.associated_via(new_object.module_parent)
+    end
 
-      unless record_klass.respond_to?(:descends_from_active_record?) && record_klass.descends_from_active_record?
-        raise ArgumentError, "#{record_klass} isn't valid; can only associate with ActiveRecord::Base subclasses"
+    def associated_via(record)
+      unless record.respond_to?(:descends_from_active_record?) && record.descends_from_active_record?
+        raise ArgumentError, "#{record} isn't a valid namespace; can only associate with ActiveRecord::Base subclasses"
       end
 
-      klass.alias_method record_name, :record
-      klass.define_singleton_method(:record_klass)   { record_klass }
-      klass.define_singleton_method(:attribute_name) { attribute_name }
-      klass.delegate :record_klass, :attribute_name, to: :class
+      @record, @attribute_name = record, model_name.element.to_sym
+      alias_method record.model_name.element, :record
     end
 
+    attr_reader :record, :attribute_name
+    delegate :primary_key, :unscoped, :transaction, to: :record
+
     def extension(&block)
-      record_klass.class_eval(&block)
+      record.class_eval(&block)
     end
 
-    def respond_to_missing?(...) = record_klass.respond_to?(...) || super
-    delegate :unscoped, :transaction, :primary_key, to: :record_klass
-
     def method_missing(method, ...)
-      if !record_klass.respond_to?(method) then super else
-        record_klass.public_send(method, ...).then do |value|
+      if !record.respond_to?(method) then super else
+        record.public_send(method, ...).then do |value|
           value.respond_to?(:each) ? value.map(&attribute_name) : value&.public_send(attribute_name)
         end
       end
     end
+    def respond_to_missing?(...) = record.respond_to?(...) || super
+  end
+
+  module Caching
+    def cache_key_with_version
+      "#{cache_key}-#{cache_version}".tap { _1.delete_suffix!("-") }
+    end
+    delegate :cache_version, to: :record
+
+    def cache_key
+      case
+      when !record.cache_versioning?
+        raise "ActiveRecord::AssociatedObject#cache_key only supports #{record_klass}.cache_versioning = true"
+      when new_record?
+        "#{model_name.cache_key}/new"
+      else
+        "#{model_name.cache_key}/#{id}"
+      end
+    end
   end
+  include Caching
 
   attr_reader :record
-  delegate :id, :transaction, to: :record
+  delegate :id, :new_record?, :persisted?, to: :record
+  delegate :updated_at, :updated_on, to: :record # Helpful when passing to `fresh_when`/`stale?`
+  delegate :transaction, to: :record
 
   def initialize(record)
     @record = record

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record-associated_object
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.9.0
 platform: ruby
 authors:
 - Kasper Timm Hansen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-13 00:00:00.000000000 Z
+date: 2025-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord