jbuilder 2.8.0 → 2.11.2

data/lib/generators/rails/templates/controller.rb

@@ -1,19 +1,17 @@
 <% if namespaced? -%>
-require_dependency "<%= namespaced_file_path %>/application_controller"
+require_dependency "<%= namespaced_path %>/application_controller"
 
 <% end -%>
 <% module_namespacing do -%>
 class <%= controller_class_name %>Controller < ApplicationController
-  before_action :set_<%= singular_table_name %>, only: [:show, :edit, :update, :destroy]
+  before_action :set_<%= singular_table_name %>, only: %i[ show edit update destroy ]
 
-  # GET <%= route_url %>
-  # GET <%= route_url %>.json
+  # GET <%= route_url %> or <%= route_url %>.json
   def index
     @<%= plural_table_name %> = <%= orm_class.all(class_name) %>
   end
 
-  # GET <%= route_url %>/1
-  # GET <%= route_url %>/1.json
+  # GET <%= route_url %>/1 or <%= route_url %>/1.json
   def show
   end
 
@@ -26,42 +24,39 @@ class <%= controller_class_name %>Controller < ApplicationController
   def edit
   end
 
-  # POST <%= route_url %>
-  # POST <%= route_url %>.json
+  # POST <%= route_url %> or <%= route_url %>.json
   def create
     @<%= singular_table_name %> = <%= orm_class.build(class_name, "#{singular_table_name}_params") %>
 
     respond_to do |format|
       if @<%= orm_instance.save %>
-        format.html { redirect_to @<%= singular_table_name %>, notice: <%= "'#{human_name} was successfully created.'" %> }
+        format.html { redirect_to @<%= singular_table_name %>, notice: <%= %("#{human_name} was successfully created.") %> }
         format.json { render :show, status: :created, location: <%= "@#{singular_table_name}" %> }
       else
-        format.html { render :new }
+        format.html { render :new, status: :unprocessable_entity }
         format.json { render json: <%= "@#{orm_instance.errors}" %>, status: :unprocessable_entity }
       end
     end
   end
 
-  # PATCH/PUT <%= route_url %>/1
-  # PATCH/PUT <%= route_url %>/1.json
+  # PATCH/PUT <%= route_url %>/1 or <%= route_url %>/1.json
   def update
     respond_to do |format|
       if @<%= orm_instance.update("#{singular_table_name}_params") %>
-        format.html { redirect_to @<%= singular_table_name %>, notice: <%= "'#{human_name} was successfully updated.'" %> }
+        format.html { redirect_to @<%= singular_table_name %>, notice: <%= %("#{human_name} was successfully updated.") %> }
         format.json { render :show, status: :ok, location: <%= "@#{singular_table_name}" %> }
       else
-        format.html { render :edit }
+        format.html { render :edit, status: :unprocessable_entity }
         format.json { render json: <%= "@#{orm_instance.errors}" %>, status: :unprocessable_entity }
       end
     end
   end
 
-  # DELETE <%= route_url %>/1
-  # DELETE <%= route_url %>/1.json
+  # DELETE <%= route_url %>/1 or <%= route_url %>/1.json
   def destroy
     @<%= orm_instance.destroy %>
     respond_to do |format|
-      format.html { redirect_to <%= index_helper %>_url, notice: <%= "'#{human_name} was successfully destroyed.'" %> }
+      format.html { redirect_to <%= index_helper %>_url, notice: <%= %("#{human_name} was successfully destroyed.") %> }
       format.json { head :no_content }
     end
   end
@@ -72,12 +67,12 @@ class <%= controller_class_name %>Controller < ApplicationController
       @<%= singular_table_name %> = <%= orm_class.find(class_name, "params[:id]") %>
     end
 
-    # Never trust parameters from the scary internet, only allow the white list through.
+    # Only allow a list of trusted parameters through.
     def <%= "#{singular_table_name}_params" %>
       <%- if attributes_names.empty? -%>
       params.fetch(<%= ":#{singular_table_name}" %>, {})
       <%- else -%>
-      params.require(<%= ":#{singular_table_name}" %>).permit(<%= attributes_names.map { |name| ":#{name}" }.join(', ') %>)
+      params.require(<%= ":#{singular_table_name}" %>).permit(<%= permitted_params %>)
       <%- end -%>
     end
 end

data/lib/generators/rails/templates/index.json.jbuilder

@@ -1 +1 @@
-json.array! @<%= plural_table_name %>, partial: '<%= plural_table_name %>/<%= singular_table_name %>', as: :<%= singular_table_name %>
+json.array! @<%= plural_table_name %>, partial: "<%= plural_table_name %>/<%= singular_table_name %>", as: :<%= singular_table_name %>

data/lib/generators/rails/templates/partial.json.jbuilder

@@ -1,2 +1,16 @@
-json.extract! <%= singular_table_name %>, <%= attributes_list_with_timestamps %>
+json.extract! <%= singular_table_name %>, <%= full_attributes_list %>
 json.url <%= singular_table_name %>_url(<%= singular_table_name %>, format: :json)
+<%- virtual_attributes.each do |attribute| -%>
+<%- if attribute.type == :rich_text -%>
+json.<%= attribute.name %> <%= singular_table_name %>.<%= attribute.name %>.to_s
+<%- elsif attribute.type == :attachment -%>
+json.<%= attribute.name %> url_for(<%= singular_table_name %>.<%= attribute.name %>)
+<%- elsif attribute.type == :attachments -%>
+json.<%= attribute.name %> do
+  json.array!(<%= singular_table_name %>.<%= attribute.name %>) do |<%= attribute.singular_name %>|
+    json.id <%= attribute.singular_name %>.id
+    json.url url_for(<%= attribute.singular_name %>)
+  end
+end
+<%- end -%>
+<%- end -%>

data/lib/jbuilder.rb

@@ -2,18 +2,21 @@ require 'jbuilder/jbuilder'
 require 'jbuilder/blank'
 require 'jbuilder/key_formatter'
 require 'jbuilder/errors'
-require 'multi_json'
+require 'json'
 require 'ostruct'
+require 'active_support/core_ext/hash/deep_merge'
 
 class Jbuilder
   @@key_formatter = nil
   @@ignore_nil    = false
+  @@deep_format_keys = false
 
   def initialize(options = {})
     @attributes = {}
 
     @key_formatter = options.fetch(:key_formatter){ @@key_formatter ? @@key_formatter.clone : nil}
     @ignore_nil = options.fetch(:ignore_nil, @@ignore_nil)
+    @deep_format_keys = options.fetch(:deep_format_keys, @@deep_format_keys)
 
     yield self if ::Kernel.block_given?
   end
@@ -26,12 +29,12 @@ class Jbuilder
   BLANK = Blank.new
   NON_ENUMERABLES = [ ::Struct, ::OpenStruct ].to_set
 
-  def set!(key, value = BLANK, *args)
+  def set!(key, value = BLANK, *args, &block)
     result = if ::Kernel.block_given?
       if !_blank?(value)
         # json.comments @post.comments { |comment| ... }
         # { "comments": [ { ... }, { ... } ] }
-        _scope{ array! value, &::Proc.new }
+        _scope{ array! value, &block }
       else
         # json.comments { ... }
         # { "comments": ... }
@@ -42,11 +45,11 @@ class Jbuilder
         # json.age 32
         # json.person another_jbuilder
         # { "age": 32, "person": { ...  }
-        value.attributes!
+        _format_keys(value.attributes!)
       else
         # json.age 32
         # { "age": 32 }
-        value
+        _format_keys(value)
       end
     elsif _is_collection?(value)
       # json.comments @post.comments, :content, :created_at
@@ -61,9 +64,9 @@ class Jbuilder
     _set_value key, result
   end
 
-  def method_missing(*args)
+  def method_missing(*args, &block)
     if ::Kernel.block_given?
-      set!(*args, &::Proc.new)
+      set!(*args, &block)
     else
       set!(*args)
     end
@@ -130,6 +133,31 @@ class Jbuilder
     @@ignore_nil = value
   end
 
+  # Deeply apply key format to nested hashes and arrays passed to
+  # methods like set!, merge! or array!.
+  #
+  # Example:
+  #
+  #   json.key_format! camelize: :lower
+  #   json.settings({some_value: "abc"})
+  #
+  #   { "settings": { "some_value": "abc" }}
+  #
+  #   json.key_format! camelize: :lower
+  #   json.deep_format_keys!
+  #   json.settings({some_value: "abc"})
+  #
+  #   { "settings": { "someValue": "abc" }}
+  #
+  def deep_format_keys!(value = true)
+    @deep_format_keys = value
+  end
+
+  # Same as instance method deep_format_keys! except sets the default.
+  def self.deep_format_keys(value = true)
+    @@deep_format_keys = value
+  end
+
   # Turns the current element into an array and yields a builder to add a hash.
   #
   # Example:
@@ -163,7 +191,7 @@ class Jbuilder
   #
   #   [ { "name": David", "age": 32 }, { "name": Jamie", "age": 31 } ]
   #
-  # If you are using Ruby 1.9+, you can use the call syntax instead of an explicit extract! call:
+  # You can use the call syntax instead of an explicit extract! call:
   #
   #   json.(@people) { |person| ... }
   #
@@ -181,18 +209,18 @@ class Jbuilder
   #   json.array! [1, 2, 3]
   #
   #   [1,2,3]
-  def array!(collection = [], *attributes)
+  def array!(collection = [], *attributes, &block)
     array = if collection.nil?
       []
     elsif ::Kernel.block_given?
-      _map_collection(collection, &::Proc.new)
+      _map_collection(collection, &block)
     elsif attributes.any?
       _map_collection(collection) { |element| extract! element, *attributes }
     else
-      collection.to_a
+      _format_keys(collection.to_a)
     end
 
-    merge! array
+    @attributes = _merge_values(@attributes, array)
   end
 
   # Extracts the mentioned attributes or hash elements from the passed object and turns them into attributes of the JSON.
@@ -220,9 +248,9 @@ class Jbuilder
     end
   end
 
-  def call(object, *attributes)
+  def call(object, *attributes, &block)
     if ::Kernel.block_given?
-      array! object, &::Proc.new
+      array! object, &block
     else
       extract! object, *attributes
     end
@@ -240,24 +268,25 @@ class Jbuilder
     @attributes
   end
 
-  # Merges hash or array into current builder.
-  def merge!(hash_or_array)
-    @attributes = _merge_values(@attributes, hash_or_array)
+  # Merges hash, array, or Jbuilder instance into current builder.
+  def merge!(object)
+    hash_or_array = ::Jbuilder === object ? object.attributes! : object
+    @attributes = _merge_values(@attributes, _format_keys(hash_or_array))
   end
 
   # Encodes the current builder as JSON.
   def target!
-    ::MultiJson.dump(@attributes)
+    @attributes.to_json
   end
 
   private
 
   def _extract_hash_values(object, attributes)
-    attributes.each{ |key| _set_value key, object.fetch(key) }
+    attributes.each{ |key| _set_value key, _format_keys(object.fetch(key)) }
   end
 
   def _extract_method_values(object, attributes)
-    attributes.each{ |key| _set_value key, object.public_send(key) }
+    attributes.each{ |key| _set_value key, _format_keys(object.public_send(key)) }
   end
 
   def _merge_block(key)
@@ -275,7 +304,7 @@ class Jbuilder
     elsif ::Array === current_value && ::Array === updates
       current_value + updates
     elsif ::Hash === current_value && ::Hash === updates
-      current_value.merge(updates)
+      current_value.deep_merge(updates)
     else
       raise MergeError.build(current_value, updates)
     end
@@ -285,6 +314,18 @@ class Jbuilder
     @key_formatter ? @key_formatter.format(key) : key.to_s
   end
 
+  def _format_keys(hash_or_array)
+    return hash_or_array unless @deep_format_keys
+
+    if ::Array === hash_or_array
+      hash_or_array.map { |value| _format_keys(value) }
+    elsif ::Hash === hash_or_array
+      ::Hash[hash_or_array.collect { |k, v| [_key(k), _format_keys(v)] }]
+    else
+      hash_or_array
+    end
+  end
+
   def _set_value(key, value)
     raise NullError.build(key) if @attributes.nil?
     raise ArrayError.build(key) if ::Array === @attributes
@@ -300,12 +341,12 @@ class Jbuilder
   end
 
   def _scope
-    parent_attributes, parent_formatter = @attributes, @key_formatter
+    parent_attributes, parent_formatter, parent_deep_format_keys = @attributes, @key_formatter, @deep_format_keys
     @attributes = BLANK
     yield
     @attributes
   ensure
-    @attributes, @key_formatter = parent_attributes, parent_formatter
+    @attributes, @key_formatter, @deep_format_keys = parent_attributes, parent_formatter, parent_deep_format_keys
   end
 
   def _is_collection?(object)

data/lib/jbuilder/jbuilder_template.rb

@@ -73,8 +73,8 @@ class JbuilderTemplate < Jbuilder
   #   json.cache_if! !admin?, @person, expires_in: 10.minutes do
   #     json.extract! @person, :name, :age
   #   end
-  def cache_if!(condition, *args)
-    condition ? cache!(*args, &::Proc.new) : yield
+  def cache_if!(condition, *args, &block)
+    condition ? cache!(*args, &block) : yield
   end
 
   def target!
@@ -104,7 +104,7 @@ class JbuilderTemplate < Jbuilder
   private
 
   def _render_partial_with_options(options)
-    options.reverse_merge! locals: {}
+    options.reverse_merge! locals: options.except(:partial, :as, :collection)
     options.reverse_merge! ::JbuilderTemplate.template_lookup_options
     as = options[:as]
 
@@ -164,7 +164,7 @@ class JbuilderTemplate < Jbuilder
     if @context.respond_to?(:cache_fragment_name)
       # Current compatibility, fragment_name_with_digest is private again and cache_fragment_name
       # should be used instead.
-      @context.cache_fragment_name(key, options)
+      @context.cache_fragment_name(key, **options)
     elsif @context.respond_to?(:fragment_name_with_digest)
       # Backwards compatibility for period of time when fragment_name_with_digest was made public.
       @context.fragment_name_with_digest(key)
@@ -222,11 +222,12 @@ end
 
 class JbuilderHandler
   cattr_accessor :default_format
-  self.default_format = Mime[:json]
+  self.default_format = :json
 
-  def self.call(template)
+  def self.call(template, source = nil)
+    source ||= template.source
     # this juggling is required to keep line numbers right in the error
-    %{__already_defined = defined?(json); json||=JbuilderTemplate.new(self); #{template.source}
+    %{__already_defined = defined?(json); json||=JbuilderTemplate.new(self); #{source}
       json.target! unless (__already_defined && __already_defined != "method")}
   end
 end

data/test/jbuilder_generator_test.rb

@@ -21,18 +21,38 @@ class JbuilderGeneratorTest < Rails::Generators::TestCase
     run_generator
 
     assert_file 'app/views/posts/index.json.jbuilder' do |content|
-      assert_match %r{json.array! @posts, partial: 'posts/post', as: :post}, content
+      assert_match %r{json\.array! @posts, partial: "posts/post", as: :post}, content
     end
 
     assert_file 'app/views/posts/show.json.jbuilder' do |content|
-      assert_match %r{json.partial! \"posts/post\", post: @post}, content
+      assert_match %r{json\.partial! "posts/post", post: @post}, content
     end
-    
-    assert_file 'app/views/posts/_post.json.jbuilder' do |content|            
+
+    assert_file 'app/views/posts/_post.json.jbuilder' do |content|
       assert_match %r{json\.extract! post, :id, :title, :body}, content
+      assert_match %r{:created_at, :updated_at}, content
       assert_match %r{json\.url post_url\(post, format: :json\)}, content
     end
-    
+  end
+
+  test 'timestamps are not generated in partial with --no-timestamps' do
+    run_generator %w(Post title body:text --no-timestamps)
+
+    assert_file 'app/views/posts/_post.json.jbuilder' do |content|
+      assert_match %r{json\.extract! post, :id, :title, :body$}, content
+      assert_no_match %r{:created_at, :updated_at}, content
+    end
+  end
 
+  if Rails::VERSION::MAJOR >= 6
+    test 'handles virtual attributes' do
+      run_generator %w(Message content:rich_text video:attachment photos:attachments)
+
+      assert_file 'app/views/messages/_message.json.jbuilder' do |content|
+        assert_match %r{json\.content message\.content\.to_s}, content
+        assert_match %r{json\.video url_for\(message\.video\)}, content
+        assert_match %r{json\.photos do\n  json\.array!\(message\.photos\) do \|photo\|\n    json\.id photo\.id\n    json\.url url_for\(photo\)\n  end\nend}, content
+      end
+    end
   end
 end

data/test/jbuilder_template_test.rb

@@ -1,457 +1,312 @@
 require "test_helper"
-require "mocha/setup"
-require "active_model"
-require "action_view"
 require "action_view/testing/resolvers"
-require "active_support/cache"
-require "jbuilder/jbuilder_template"
-
-BLOG_POST_PARTIAL = <<-JBUILDER
-  json.extract! blog_post, :id, :body
-  json.author do
-    first_name, last_name = blog_post.author_name.split(nil, 2)
-    json.first_name first_name
-    json.last_name last_name
-  end
-JBUILDER
-
-COLLECTION_PARTIAL = <<-JBUILDER
-  json.extract! collection, :id, :name
-JBUILDER
-
-RACER_PARTIAL = <<-JBUILDER
-  json.extract! racer, :id, :name
-JBUILDER
-
-class Racer
-  extend ActiveModel::Naming
-  include ActiveModel::Conversion
-
-  def initialize(id, name)
-    @id, @name = id, name
-  end
-
-  attr_reader :id, :name
-end
-
 
-BlogPost = Struct.new(:id, :body, :author_name)
-Collection = Struct.new(:id, :name)
-blog_authors = [ "David Heinemeier Hansson", "Pavel Pravosud" ].cycle
-BLOG_POST_COLLECTION = Array.new(10){ |i| BlogPost.new(i+1, "post body #{i+1}", blog_authors.next) }
-COLLECTION_COLLECTION = Array.new(5){ |i| Collection.new(i+1, "collection #{i+1}") }
-
-ActionView::Template.register_template_handler :jbuilder, JbuilderHandler
-
-PARTIALS = {
-  "_partial.json.jbuilder"  => "foo ||= 'hello'; json.content foo",
-  "_blog_post.json.jbuilder" => BLOG_POST_PARTIAL,
-  "racers/_racer.json.jbuilder" => RACER_PARTIAL,
-  "_collection.json.jbuilder" => COLLECTION_PARTIAL
-}
-
-module Rails
-  def self.cache
-    @cache ||= ActiveSupport::Cache::MemoryStore.new
-  end
-end
+class JbuilderTemplateTest < ActiveSupport::TestCase
+  POST_PARTIAL = <<-JBUILDER
+    json.extract! post, :id, :body
+    json.author do
+      first_name, last_name = post.author_name.split(nil, 2)
+      json.first_name first_name
+      json.last_name last_name
+    end
+  JBUILDER
 
-class JbuilderTemplateTest < ActionView::TestCase
-  setup do
-    @context = self
-    Rails.cache.clear
-  end
+  COLLECTION_PARTIAL = <<-JBUILDER
+    json.extract! collection, :id, :name
+  JBUILDER
 
-  def jbuild(source, options = {})
-    @rendered = []
-    partials = options.fetch(:partials, PARTIALS).clone
-    partials["test.json.jbuilder"] = source
-    resolver = ActionView::FixtureResolver.new(partials)
-    lookup_context.view_paths = [resolver]
-    template = ActionView::Template.new(source, "test", JbuilderHandler, virtual_path: "test")
-    json = template.render(self, {}).strip
-    MultiJson.load(json)
-  end
+  RACER_PARTIAL = <<-JBUILDER
+    json.extract! racer, :id, :name
+  JBUILDER
 
-  def undef_context_methods(*names)
-    self.class_eval do
-      names.each do |name|
-        undef_method name.to_sym if method_defined?(name.to_sym)
-      end
-    end
-  end
+  PARTIALS = {
+    "_partial.json.jbuilder"      => "json.content content",
+    "_post.json.jbuilder"         => POST_PARTIAL,
+    "racers/_racer.json.jbuilder" => RACER_PARTIAL,
+    "_collection.json.jbuilder"   => COLLECTION_PARTIAL,
 
-  def assert_collection_rendered(result, context = nil)
-    result = result.fetch(context) if context
+    # Ensure we find only Jbuilder partials from within Jbuilder templates.
+    "_post.html.erb" => "Hello world!"
+  }
 
-    assert_equal 10, result.length
-    assert_equal Array, result.class
-    assert_equal "post body 5",        result[4]["body"]
-    assert_equal "Heinemeier Hansson", result[2]["author"]["last_name"]
-    assert_equal "Pavel",              result[5]["author"]["first_name"]
-  end
+  AUTHORS = [ "David Heinemeier Hansson", "Pavel Pravosud" ].cycle
+  POSTS   = (1..10).collect { |i| Post.new(i, "Post ##{i}", AUTHORS.next) }
 
-  test "rendering" do
-    result = jbuild(<<-JBUILDER)
-      json.content "hello"
-    JBUILDER
+  setup { Rails.cache.clear }
 
+  test "basic template" do
+    result = render('json.content "hello"')
     assert_equal "hello", result["content"]
   end
 
-  test "key_format! with parameter" do
-    result = jbuild(<<-JBUILDER)
-      json.key_format! camelize: [:lower]
-      json.camel_style "for JS"
-    JBUILDER
-
-    assert_equal ["camelStyle"], result.keys
-  end
-
-  test "key_format! propagates to child elements" do
-    result = jbuild(<<-JBUILDER)
-      json.key_format! :upcase
-      json.level1 "one"
-      json.level2 do
-        json.value "two"
-      end
-    JBUILDER
-
-    assert_equal "one", result["LEVEL1"]
-    assert_equal "two", result["LEVEL2"]["VALUE"]
+  test "partial by name with top-level locals" do
+    result = render('json.partial! "partial", content: "hello"')
+    assert_equal "hello", result["content"]
   end
 
-  test "partial! renders partial" do
-    result = jbuild(<<-JBUILDER)
-      json.partial! "partial"
-    JBUILDER
-
+  test "partial by name with nested locals" do
+    result = render('json.partial! "partial", locals: { content: "hello" }')
     assert_equal "hello", result["content"]
   end
 
-  test "partial! + locals via :locals option" do
-    result = jbuild(<<-JBUILDER)
-      json.partial! "partial", locals: { foo: "howdy" }
-    JBUILDER
-
-    assert_equal "howdy", result["content"]
+  test "partial by options containing nested locals" do
+    result = render('json.partial! partial: "partial", locals: { content: "hello" }')
+    assert_equal "hello", result["content"]
   end
 
-  test "partial! + locals without :locals key" do
-    result = jbuild(<<-JBUILDER)
-      json.partial! "partial", foo: "goodbye"
-    JBUILDER
-
-    assert_equal "goodbye", result["content"]
+  test "partial by options containing top-level locals" do
+    result = render('json.partial! partial: "partial", content: "hello"')
+    assert_equal "hello", result["content"]
   end
 
-  test "partial! renders collections" do
-    result = jbuild(<<-JBUILDER)
-      json.partial! "blog_post", collection: BLOG_POST_COLLECTION, as: :blog_post
-    JBUILDER
-
-    assert_collection_rendered result
+  test "partial for Active Model" do
+    result = render('json.partial! @racer', racer: Racer.new(123, "Chris Harris"))
+    assert_equal 123, result["id"]
+    assert_equal "Chris Harris", result["name"]
   end
 
-  test "partial! renders collections when as argument is a string" do
-    result = jbuild(<<-JBUILDER)
-      json.partial! "blog_post", collection: BLOG_POST_COLLECTION, as: "blog_post"
-    JBUILDER
-
-    assert_collection_rendered result
+  test "partial collection by name with symbol local" do
+    result = render('json.partial! "post", collection: @posts, as: :post', posts: POSTS)
+    assert_equal 10, result.count
+    assert_equal "Post #5", result[4]["body"]
+    assert_equal "Heinemeier Hansson", result[2]["author"]["last_name"]
+    assert_equal "Pavel", result[5]["author"]["first_name"]
   end
 
-  test "partial! renders collections as collections" do
-    result = jbuild(<<-JBUILDER)
-      json.partial! "collection", collection: COLLECTION_COLLECTION, as: :collection
-    JBUILDER
-
-    assert_equal 5, result.length
+  test "partial collection by name with string local" do
+    result = render('json.partial! "post", collection: @posts, as: "post"', posts: POSTS)
+    assert_equal 10, result.count
+    assert_equal "Post #5", result[4]["body"]
+    assert_equal "Heinemeier Hansson", result[2]["author"]["last_name"]
+    assert_equal "Pavel", result[5]["author"]["first_name"]
   end
 
-  test "partial! renders as empty array for nil-collection" do
-    result = jbuild(<<-JBUILDER)
-      json.partial! "blog_post", collection: nil, as: :blog_post
-    JBUILDER
-
-    assert_equal [], result
+  test "partial collection by options" do
+    result = render('json.partial! partial: "post", collection: @posts, as: :post', posts: POSTS)
+    assert_equal 10, result.count
+    assert_equal "Post #5", result[4]["body"]
+    assert_equal "Heinemeier Hansson", result[2]["author"]["last_name"]
+    assert_equal "Pavel", result[5]["author"]["first_name"]
   end
 
-  test "partial! renders collection (alt. syntax)" do
-    result = jbuild(<<-JBUILDER)
-      json.partial! partial: "blog_post", collection: BLOG_POST_COLLECTION, as: :blog_post
-    JBUILDER
-
-    assert_collection_rendered result
+  test "nil partial collection by name" do
+    assert_equal [], render('json.partial! "post", collection: @posts, as: :post', posts: nil)
   end
 
-  test "partial! renders as empty array for nil-collection (alt. syntax)" do
-    result = jbuild(<<-JBUILDER)
-      json.partial! partial: "blog_post", collection: nil, as: :blog_post
-    JBUILDER
-
-    assert_equal [], result
+  test "nil partial collection by options" do
+    assert_equal [], render('json.partial! partial: "post", collection: @posts, as: :post', posts: nil)
   end
 
-  test "render array of partials" do
-    result = jbuild(<<-JBUILDER)
-      json.array! BLOG_POST_COLLECTION, partial: "blog_post", as: :blog_post
-    JBUILDER
-
-    assert_collection_rendered result
+  test "array of partials" do
+    result = render('json.array! @posts, partial: "post", as: :post', posts: POSTS)
+    assert_equal 10, result.count
+    assert_equal "Post #5", result[4]["body"]
+    assert_equal "Heinemeier Hansson", result[2]["author"]["last_name"]
+    assert_equal "Pavel", result[5]["author"]["first_name"]
   end
 
-  test "render array of partials as empty array with nil-collection" do
-    result = jbuild(<<-JBUILDER)
-      json.array! nil, partial: "blog_post", as: :blog_post
-    JBUILDER
-
-    assert_equal [], result
+  test "empty array of partials from nil collection" do
+    assert_equal [], render('json.array! @posts, partial: "post", as: :post', posts: nil)
   end
 
-  test "render array of partials as a value" do
-    result = jbuild(<<-JBUILDER)
-      json.posts BLOG_POST_COLLECTION, partial: "blog_post", as: :blog_post
-    JBUILDER
-
-    assert_collection_rendered result, "posts"
+  test "array of partials under key" do
+    result = render('json.posts @posts, partial: "post", as: :post', posts: POSTS)
+    assert_equal 10, result["posts"].count
+    assert_equal "Post #5", result["posts"][4]["body"]
+    assert_equal "Heinemeier Hansson", result["posts"][2]["author"]["last_name"]
+    assert_equal "Pavel", result["posts"][5]["author"]["first_name"]
   end
 
-  test "render as empty array if partials as a nil value" do
-    result = jbuild <<-JBUILDER
-      json.posts nil, partial: "blog_post", as: :blog_post
-    JBUILDER
-
+  test "empty array of partials under key from nil collection" do
+    result = render('json.posts @posts, partial: "post", as: :post', posts: nil)
     assert_equal [], result["posts"]
   end
 
-  test "cache an empty block" do
-    undef_context_methods :fragment_name_with_digest, :cache_fragment_name
-
-    jbuild <<-JBUILDER
-      json.cache! "nothing" do
+  test "object fragment caching" do
+    render(<<-JBUILDER)
+      json.cache! "cache-key" do
+        json.name "Hit"
       end
     JBUILDER
 
-    result = nil
-
-    assert_nothing_raised do
-      result = jbuild(<<-JBUILDER)
-        json.foo "bar"
-        json.cache! "nothing" do
-        end
-      JBUILDER
-    end
-
-    assert_equal "bar", result["foo"]
+    hit = render('json.cache! "cache-key" do; end')
+    assert_equal "Hit", hit["name"]
   end
 
-  test "fragment caching a JSON object" do
-    undef_context_methods :fragment_name_with_digest, :cache_fragment_name
-
-    jbuild <<-JBUILDER
-      json.cache! "cachekey" do
-        json.name "Cache"
+  test "conditional object fragment caching" do
+    render(<<-JBUILDER)
+      json.cache_if! true, "cache-key" do
+        json.a "Hit"
       end
-    JBUILDER
 
-    result = jbuild(<<-JBUILDER)
-      json.cache! "cachekey" do
-        json.name "Miss"
+      json.cache_if! false, "cache-key" do
+        json.b "Hit"
       end
     JBUILDER
 
-    assert_equal "Cache", result["name"]
-  end
-
-  test "conditionally fragment caching a JSON object" do
-    undef_context_methods :fragment_name_with_digest, :cache_fragment_name
-
-    jbuild <<-JBUILDER
-      json.cache_if! true, "cachekey" do
-        json.test1 "Cache"
+    result = render(<<-JBUILDER)
+      json.cache_if! true, "cache-key" do
+        json.a "Miss"
       end
-      json.cache_if! false, "cachekey" do
-        json.test2 "Cache"
-      end
-    JBUILDER
 
-    result = jbuild(<<-JBUILDER)
-      json.cache_if! true, "cachekey" do
-        json.test1 "Miss"
-      end
-      json.cache_if! false, "cachekey" do
-        json.test2 "Miss"
+      json.cache_if! false, "cache-key" do
+        json.b "Miss"
       end
     JBUILDER
 
-    assert_equal "Cache", result["test1"]
-    assert_equal "Miss", result["test2"]
+    assert_equal "Hit", result["a"]
+    assert_equal "Miss", result["b"]
   end
 
-  test "fragment caching deserializes an array" do
-    undef_context_methods :fragment_name_with_digest, :cache_fragment_name
+  test "object fragment caching with expiry" do
+    travel_to "2018-05-12 11:29:00 -0400"
 
-    jbuild <<-JBUILDER
-      json.cache! "cachekey" do
-        json.array! %w[a b c]
+    render <<-JBUILDER
+      json.cache! "cache-key", expires_in: 1.minute do
+        json.name "Hit"
       end
     JBUILDER
 
-    result = jbuild(<<-JBUILDER)
-      json.cache! "cachekey" do
-        json.array! %w[1 2 3]
+    travel 30.seconds
+
+    result = render(<<-JBUILDER)
+      json.cache! "cache-key", expires_in: 1.minute do
+        json.name "Miss"
       end
     JBUILDER
 
-    assert_equal %w[a b c], result
-  end
-
-  test "fragment caching works with current cache digests" do
-    undef_context_methods :fragment_name_with_digest
+    assert_equal "Hit", result["name"]
 
-    @context.expects :cache_fragment_name
-    ActiveSupport::Cache.expects :expand_cache_key
+    travel 31.seconds
 
-    jbuild <<-JBUILDER
-      json.cache! "cachekey" do
-        json.name "Cache"
+    result = render(<<-JBUILDER)
+      json.cache! "cache-key", expires_in: 1.minute do
+        json.name "Miss"
       end
     JBUILDER
-  end
 
-  test "fragment caching uses combined_fragment_cache_key" do
-    undef_context_methods :fragment_name_with_digest, :cache_fragment_name
-
-    @context.expects(:combined_fragment_cache_key).with("cachekey")
+    assert_equal "Miss", result["name"]
+  end
 
-    jbuild <<-JBUILDER
-      json.cache! "cachekey" do
-        json.name "Cache"
+  test "object root caching" do
+    render <<-JBUILDER
+      json.cache_root! "cache-key" do
+        json.name "Hit"
       end
     JBUILDER
-  end
-
-  test "fragment caching instrumentation" do
-    undef_context_methods :fragment_name_with_digest, :cache_fragment_name
 
-    payloads = {}
-    ActiveSupport::Notifications.subscribe("read_fragment.action_controller") { |*args| payloads[:read_fragment] = args.last }
-    ActiveSupport::Notifications.subscribe("write_fragment.action_controller") { |*args| payloads[:write_fragment] = args.last }
+    assert_equal JSON.dump(name: "Hit"), Rails.cache.read("jbuilder/root/cache-key")
 
-    jbuild <<-JBUILDER
-      json.cache! "cachekey" do
-        json.name "Cache"
+    result = render(<<-JBUILDER)
+      json.cache_root! "cache-key" do
+        json.name "Miss"
       end
     JBUILDER
 
-    assert_equal "jbuilder/cachekey", payloads[:read_fragment][:key]
-    assert_equal "jbuilder/cachekey", payloads[:write_fragment][:key]
+    assert_equal "Hit", result["name"]
   end
 
-  test "current cache digest option accepts options" do
-    undef_context_methods :fragment_name_with_digest
-
-    @context.expects(:cache_fragment_name).with("cachekey", skip_digest: true)
-    ActiveSupport::Cache.expects :expand_cache_key
-
-    jbuild <<-JBUILDER
-      json.cache! "cachekey", skip_digest: true do
-        json.name "Cache"
+  test "array fragment caching" do
+    render <<-JBUILDER
+      json.cache! "cache-key" do
+        json.array! %w[ a b c ]
       end
     JBUILDER
-  end
 
-  test "fragment caching accepts expires_in option" do
-    undef_context_methods :fragment_name_with_digest
-
-    @context.expects(:cache_fragment_name).with("cachekey", {})
-
-    jbuild <<-JBUILDER
-      json.cache! "cachekey", expires_in: 1.minute do
-        json.name "Cache"
-      end
-    JBUILDER
+    assert_equal %w[ a b c ], render('json.cache! "cache-key" do; end')
   end
 
-  test "caching root structure" do
-    undef_context_methods :fragment_name_with_digest, :cache_fragment_name
-
-    cache_miss_result = jbuild <<-JBUILDER
-      json.cache_root! "cachekey" do
-        json.name "Miss"
+  test "array root caching" do
+    render <<-JBUILDER
+      json.cache_root! "cache-key" do
+        json.array! %w[ a b c ]
       end
     JBUILDER
 
-    cache_hit_result = jbuild <<-JBUILDER
-      json.cache_root! "cachekey" do
-        json.name "Hit"
+    assert_equal JSON.dump(%w[ a b c ]), Rails.cache.read("jbuilder/root/cache-key")
+
+    assert_equal %w[ a b c ], render(<<-JBUILDER)
+      json.cache_root! "cache-key" do
+        json.array! %w[ d e f ]
       end
     JBUILDER
-
-    assert_equal cache_miss_result, cache_hit_result
   end
 
-  test "failing to cache root after attributes have been defined" do
+  test "failing to cache root after JSON structures have been defined" do
     assert_raises ActionView::Template::Error, "cache_root! can't be used after JSON structures have been defined" do
-      jbuild <<-JBUILDER
+      render <<-JBUILDER
         json.name "Kaboom"
-        json.cache_root! "cachekey" do
+        json.cache_root! "cache-key" do
           json.name "Miss"
         end
       JBUILDER
     end
   end
 
-  test "does not perform caching when controller.perform_caching is false" do
-    controller.perform_caching = false
+  test "empty fragment caching" do
+    render 'json.cache! "nothing" do; end'
 
-    jbuild <<-JBUILDER
-      json.cache! "cachekey" do
-        json.name "Cache"
-      end
-    JBUILDER
+    result = nil
+
+    assert_nothing_raised do
+      result = render(<<-JBUILDER)
+        json.foo "bar"
+        json.cache! "nothing" do; end
+      JBUILDER
+    end
 
-    assert_equal Rails.cache.inspect[/entries=(\d+)/, 1], "0"
+    assert_equal "bar", result["foo"]
   end
 
-  test "invokes templates via params via set!" do
-    @post = BLOG_POST_COLLECTION.first
+  test "cache instrumentation" do
+    payloads = {}
 
-    result = jbuild(<<-JBUILDER)
-      json.post @post, partial: "blog_post", as: :blog_post
+    ActiveSupport::Notifications.subscribe("read_fragment.action_controller") { |*args| payloads[:read] = args.last }
+    ActiveSupport::Notifications.subscribe("write_fragment.action_controller") { |*args| payloads[:write] = args.last }
+
+    render <<-JBUILDER
+      json.cache! "cache-key" do
+        json.name "Cache"
+      end
     JBUILDER
 
-    assert_equal 1, result["post"]["id"]
-    assert_equal "post body 1", result["post"]["body"]
-    assert_equal "David", result["post"]["author"]["first_name"]
+    assert_equal "jbuilder/cache-key", payloads[:read][:key]
+    assert_equal "jbuilder/cache-key", payloads[:write][:key]
   end
 
-  test "invokes templates implicitly for ActiveModel objects" do
-    @racer = Racer.new(123, "Chris Harris")
-
-    result = jbuild(<<-JBUILDER)
-      json.partial! @racer
+  test "camelized keys" do
+    result = render(<<-JBUILDER)
+      json.key_format! camelize: [:lower]
+      json.first_name "David"
     JBUILDER
 
-    assert_equal %w[id name], result.keys
-    assert_equal 123, result["id"]
-    assert_equal "Chris Harris", result["name"]
+    assert_equal "David", result["firstName"]
   end
 
-  test "renders partial via set! with same name as HTML partial" do
-    partials = {
-      "_blog_post.html.erb" => "Hello!",
-      "_blog_post.json.jbuilder" => BLOG_POST_PARTIAL
-    }
+  private
+    def render(*args)
+      JSON.load render_without_parsing(*args)
+    end
 
-    @post = BLOG_POST_COLLECTION.first
+    def render_without_parsing(source, assigns = {})
+      view = build_view(fixtures: PARTIALS.merge("source.json.jbuilder" => source), assigns: assigns)
+      view.render(template: "source.json.jbuilder")
+    end
 
-    result = jbuild(<<-JBUILDER, partials: partials)
-      json.post @post, partial: "blog_post", as: :blog_post
-    JBUILDER
+    def build_view(options = {})
+      resolver = ActionView::FixtureResolver.new(options.fetch(:fixtures))
+      lookup_context = ActionView::LookupContext.new([ resolver ], {}, [""])
+      controller = ActionView::TestCase::TestController.new
 
-    assert_not_nil result["post"]
-    assert_equal 1, result["post"]["id"]
-  end
+      # TODO: Use with_empty_template_cache unconditionally after dropping support for Rails <6.0.
+      view = if ActionView::Base.respond_to?(:with_empty_template_cache)
+        ActionView::Base.with_empty_template_cache.new(lookup_context, options.fetch(:assigns, {}), controller)
+      else
+        ActionView::Base.new(lookup_context, options.fetch(:assigns, {}), controller)
+      end
+
+      def view.view_cache_dependencies; []; end
+
+      view
+    end
 end