Add default #render_in implementation to ActiveModel::Conversion

Follow-up to [rails#46202][]

Without overriding the new `#render_in` method, previous behavior will
be preserved: render the view partial determined by calling
`#to_partial_path`, then pass `object: self`.

With the following view partial:

```erb
<%# app/views/people/_person.html.erb %>
<% local_assigns.with_defaults(shout: false) => { shout: } %>

<%= shout ? person.name.upcase : person.name %>
```

Callers can render an instance of `Person` as a positional argument or a
`:renderable` option:

```ruby
person = Person.new(name: "Ralph")

render person                                       # => "Ralph"
render person, shout: true                          # => "RALPH"
render renderable: person                           # => "Ralph"
render renderable: person, locals: { shout: true }  # => "RALPH"
```

This preserves backward compatibility. At the same time, the
`#render_in` method provides applications with an more flexibility, and
an opportunity to manage how to transform models into Strings. For
example, users of ViewComponent can map a model directly to a
`ViewComponent::Base` instance.

[rails#46202]: rails#46202 (comment)

Author: seanpdoyle

actionview/lib/action_view/renderer/abstract_renderer.rb

@@ -79,7 +79,7 @@ def partial_path(object, view)
           path = if object.respond_to?(:to_partial_path)
             object.to_partial_path
           else
-            raise ArgumentError.new("'#{object.inspect}' is not an ActiveModel-compatible object. It must implement :to_partial_path.")
+            raise ArgumentError.new("'#{object.inspect}' is not an ActiveModel-compatible object. It must implement #to_partial_path.")
           end
 
           if view.prefix_partial_path_with_controller_namespace

actionview/lib/action_view/renderer/template_renderer.rb

@@ -41,7 +41,13 @@ def determine_template(options, &block)
           end
           Template::Inline.new(options[:inline], "inline template", handler, locals: keys, format: format)
         elsif options.key?(:renderable)
-          Template::Renderable.new(options[:renderable], &block)
+          renderable = options[:renderable]
+
+          unless renderable.respond_to?(:render_in)
+            raise ArgumentError, "'#{renderable.inspect}' is not a renderable object. It must implement #render_in."
+          end
+
+          Template::Renderable.new(renderable, &block)
         elsif options.key?(:template)
           if options[:template].respond_to?(:render)
             options[:template]

actionview/test/actionpack/controller/render_test.rb

@@ -592,6 +592,10 @@ def partial_hash_collection_with_locals
     render partial: "hash_greeting", collection: [ { first_name: "Pratik" }, { first_name: "Amy" } ], locals: { greeting: "Hola" }
   end
 
+  def renderable_hash
+    render renderable: Quiz::Question.new(params[:name])
+  end
+
   def partial_with_implicit_local_assignment
     @customer = Customer.new("Marcel")
     render partial: "customer"
@@ -706,6 +710,7 @@ class RenderTest < ActionController::TestCase
     get :partial_with_nested_object_shorthand, to: "test#partial_with_nested_object_shorthand"
     get :partial_with_hashlike_locals, to: "test#partial_with_hashlike_locals"
     get :partials_list, to: "test#partials_list"
+    get :renderable_hash, to: "test#renderable_hash"
     get :render_action_hello_world, to: "test#render_action_hello_world"
     get :render_action_hello_world_as_string, to: "test#render_action_hello_world_as_string"
     get :render_action_hello_world_with_symbol, to: "test#render_action_hello_world_with_symbol"
@@ -1483,6 +1488,11 @@ def test_partial_hash_collection_with_locals
     assert_equal "Hola: PratikHola: Amy", @response.body
   end
 
+  def test_renderable_hash
+    get :renderable_hash, params: { name: "Why?" }
+    assert_equal "Why?", @response.body
+  end
+
   def test_render_missing_partial_template
     assert_raise(ActionView::MissingTemplate) do
       get :missing_partial

actionview/test/template/render_test.rb

@@ -294,7 +294,21 @@ def test_render_partial_with_missing_filename
 
   def test_render_partial_with_incompatible_object
     e = assert_raises(ArgumentError) { @view.render(partial: nil) }
-    assert_equal "'#{nil.inspect}' is not an ActiveModel-compatible object. It must implement :to_partial_path.", e.message
+    assert_equal "'#{nil.inspect}' is not an ActiveModel-compatible object. It must implement #to_partial_path.", e.message
+  end
+
+  def test_render_renderable_with_nil
+    assert_raises ArgumentError, match: "'#{nil.inspect}' is not a renderable object. It must implement #render_in." do
+      @view.render renderable: nil
+    end
+  end
+
+  def test_render_renderable_with_incompatible_object
+    object = Object.new
+
+    assert_raises ArgumentError, match: "'#{object.inspect}' is not a renderable object. It must implement #render_in." do
+      @view.render renderable: object
+    end
   end
 
   def test_render_partial_starting_with_a_capital

activemodel/CHANGELOG.md

@@ -1,3 +1,28 @@
+*   Add default `#render_in` implementation to `ActiveModel::Conversion`
+
+    With the following view partial:
+
+    ```erb
+    <%# app/views/people/_person.html.erb %>
+    <% local_assigns.with_defaults(shout: false) => { shout: } %>
+
+    <%= shout ? person.name.upcase : person.name %>
+    ```
+
+    Callers can render an instance of `Person` as a positional argument or a
+    `:renderable` option:
+
+    ```ruby
+    person = Person.new(name: "Ralph")
+
+    render person                                       # => "Ralph"
+    render person, shout: true                          # => "RALPH"
+    render renderable: person                           # => "Ralph"
+    render renderable: person, locals: { shout: true }  # => "RALPH"
+    ```
+
+    *Sean Doyle*
+
 *   Port the `type_for_attribute` method to Active Model. Classes that include
     `ActiveModel::Attributes` will now provide this method. This method behaves
     the same for Active Model as it does for Active Record.

activemodel/lib/active_model/conversion.rb

@@ -104,6 +104,30 @@ def to_partial_path
       self.class._to_partial_path
     end
 
+    # Renders the object into an Action View context.
+    #
+    #   # app/models/person.rb
+    #   class Person
+    #     include ActiveModel::Conversion
+    #
+    #     attr_reader :name
+    #
+    #     def initialize(name)
+    #       @name = name
+    #     end
+    #   end
+    #
+    #   # app/views/people/_person.html.erb
+    #   <p><%= person.name %></p>
+    #
+    #   person = Person.new name: "Ralph"
+    #
+    #   render(person)              # => "<p>Ralph</p>
+    #   render(renderable: person)  # => "<p>Ralph</p>
+    def render_in(view_context, **options, &block)
+      view_context.render(partial: to_partial_path, object: self, **options, &block)
+    end
+
     module ClassMethods # :nodoc:
       # Provide a class level cache for #to_partial_path. This is an
       # internal method and should not be accessed directly.

activemodel/lib/active_model/lint.rb

@@ -60,6 +60,21 @@ def test_to_partial_path
         assert_kind_of String, model.to_partial_path
       end
 
+      # Passes if the object's model responds to <tt>render_in</tt>
+      # calling this method returns a string. Fails otherwise.
+      #
+      # <tt>render_in</tt> is used for rendering an instance. For example,
+      # a BlogPost model might render itself into a "blog_posts/blog_post" partial.
+      def test_render_in
+        view_context = Object.new
+          def view_context.render(...)
+            ""
+          end
+        end
+        assert_respond_to model, :render_in
+        assert_kind_of String, model.render_in(view_context)
+      end
+
       # Passes if the object's model responds to <tt>persisted?</tt> and if
       # calling this method returns either +true+ or +false+. Fails otherwise.
       #

activemodel/test/cases/conversion_test.rb

@@ -62,6 +62,15 @@ def persisted?
     assert_equal "attack_helicopters/ah-64", Helicopter::Apache.new.to_partial_path
   end
 
+  test "#render_in defaults to rendering a partial with the object" do
+    contact = Contact.new
+    view_context = Object.new
+
+    assert_called_with view_context, :render_in, [{ partial: contact.to_partial_path, object: contact }] do
+      contact.render_in(view_context)
+    end
+  end
+
   test "#to_param_delimiter allows redefining the delimiter used in #to_param" do
     old_delimiter = Contact.param_delimiter
     Contact.param_delimiter = "_"

guides/source/active_model_basics.md

@@ -163,6 +163,27 @@ irb> person.to_key
 => nil
 irb> person.to_param
 => nil
+irb> person.to_partial_path
+=> "people/person"
+```
+
+The `ActiveModel::Conversion` module also defines a `render_in` method for
+integration with Action View. For example, consider a `people/person` partial:
+
+```erb
+<%# app/views/people/_person.html.erb %>
+<p>Persisted: <%= person.persisted? %></p>
+```
+
+By default, passing the object to `render` will invoke `to_partial_path` to
+determine the view partial to render:
+
+```ruby
+render person
+# => <p>Persisted: false</p>
+
+render renderable: person
+# => <p>Persisted: false</p>
 ```
 
 ### Dirty