Integrate with Active Model + cache_key support (#36)

We're bringing a lot more potential power to Associated Objects here.

Now objects can be passed to forms, used in route helpers and are cacheable via `cache_key`.

Author: kaspth

README.md

@@ -241,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`.
 
@@ -261,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:

lib/active_record/associated_object.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 class ActiveRecord::AssociatedObject
   extend ActiveModel::Naming
+  include ActiveModel::Conversion
 
   class << self
     def inherited(new_object)
@@ -32,8 +35,29 @@ def method_missing(method, ...)
     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

test/active_record/associated_object/integration_test.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+require "action_view"
+
+class ActiveRecord::AssociatedObject::IntegrationTest < ActionView::TestCase
+  Rails.application.routes.draw do
+    namespace :post do
+      resources :publishers
+    end
+  end
+
+  include Rails.application.routes.url_helpers
+
+  ActionController::Base.cache_store = :memory_store
+
+  setup do
+    @post = Post.first
+    @publisher = @post.publisher
+  end
+
+  test "url helper" do
+    assert_equal "/post/publishers/#{@post.id}", post_publisher_path(@publisher)
+  end
+
+  test "form_with" do
+    concat form_with(model: @publisher)
+    assert_select "form[action='/post/publishers/#{@post.id}']"
+  end
+
+  test "cache" do
+    cache(@publisher) { concat "initial" }
+    assert_equal "initial", fragment_for(@publisher, {}) { "second" }
+  end
+end

test/active_record/associated_object_test.rb

@@ -86,6 +86,42 @@ class ActiveRecord::AssociatedObjectTest < ActiveSupport::TestCase
     assert_equal Post.new.instance_variable_get(:@new_record), true
   end
 
+  test "active model conversion integration" do
+    assert_equal @publisher, @publisher.to_model
+    assert_equal [@post.id], @publisher.to_key
+    assert_equal @post.id.to_s, @publisher.to_param
+    assert_equal "post/publishers/publisher", @publisher.to_partial_path
+
+    assert_equal @rating, @rating.to_model
+    assert_equal @comment.id, @rating.to_key
+    assert_equal @comment.id.join("-"), @rating.to_param
+    assert_equal "post/comment/ratings/rating", @rating.to_partial_path
+  end
+
+  test "cache_key integration" do
+    assert_equal "post/publishers/new", Post.new.publisher.cache_key
+    assert_equal "post/publishers/#{@post.id}", @publisher.cache_key
+
+    assert_match /\d+/, @publisher.cache_version
+    assert_equal @post.cache_version, @publisher.cache_version
+    assert_match %r(post/publishers/#{@post.id}-\d+), @publisher.cache_key_with_version
+
+
+    assert_equal "post/comment/ratings/new", Post::Comment.new.rating.cache_key
+    assert_equal "post/comment/ratings/#{@comment.id}", @rating.cache_key
+
+    assert_match /\d+/, @rating.cache_version
+    assert_equal @comment.cache_version, @rating.cache_version
+    assert_match %r(post/comment/ratings/.*?-\d+), @rating.cache_key_with_version
+  end
+
+  test "cache_key integration without cache_versioning" do
+    previous_versioning, Post.cache_versioning = Post.cache_versioning, false
+    assert_raises { @publisher.cache_key }
+  ensure
+    Post.cache_versioning = previous_versioning
+  end
+
   test "kredis integration" do
     Time.new(2022, 4, 20, 1).tap do |publish_at|
       @publisher.publish_at.value = publish_at

test/boot/active_record.rb

@@ -3,23 +3,27 @@
 
 ActiveRecord::Schema.define do
   create_table :authors, force: true do |t|
+    t.timestamps
   end
 
   create_table :posts, force: true do |t|
     t.string :title
     t.integer :author_id
+    t.timestamps
   end
 
   create_table :post_comments, primary_key: [:post_id, :author_id] do |t|
     t.integer :post_id, null: false
     t.integer :author_id, null: false
     t.string :body
+    t.timestamps
   end
 end
 
 # Shim what an app integration would look like.
 class ApplicationRecord < ActiveRecord::Base
   self.abstract_class = true
+  self.cache_versioning = true # Rails sets this during application booting, so we need to do it manually here.
 end
 
 class Author < ApplicationRecord

test/test_helper.rb

@@ -2,7 +2,7 @@
 
 $LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 
-require "rails/railtie"
+require "rails"
 require "kredis"
 require "debug"
 require "logger"
@@ -17,8 +17,11 @@
 require "minitest/autorun"
 
 # Simulate Rails app boot and run the railtie initializers manually.
+class ActiveRecord::AssociatedObject::Application < Rails::Application
+end
+
 ActiveRecord::AssociatedObject::Railtie.run_initializers
-ActiveSupport.run_load_hooks :after_initialize, Rails::Railtie
+ActiveSupport.run_load_hooks :after_initialize, Rails.application
 
 Kredis.configurator = Class.new do
   def config_for(name) = { db: "1" }