jbuilder 2.11.0 → 2.14.1

data/lib/jbuilder.rb

@@ -1,31 +1,38 @@
+# frozen_string_literal: true
+
+require 'active_support'
 require 'jbuilder/jbuilder'
 require 'jbuilder/blank'
 require 'jbuilder/key_formatter'
 require 'jbuilder/errors'
 require 'json'
-require 'ostruct'
 require 'active_support/core_ext/hash/deep_merge'
 
 class Jbuilder
   @@key_formatter = nil
   @@ignore_nil    = false
-
-  def initialize(options = {})
+  @@deep_format_keys = false
+
+  def initialize(
+    key_formatter: @@key_formatter,
+    ignore_nil: @@ignore_nil,
+    deep_format_keys: @@deep_format_keys,
+    &block
+  )
     @attributes = {}
+    @key_formatter = key_formatter
+    @ignore_nil = ignore_nil
+    @deep_format_keys = deep_format_keys
 
-    @key_formatter = options.fetch(:key_formatter){ @@key_formatter ? @@key_formatter.clone : nil}
-    @ignore_nil = options.fetch(:ignore_nil, @@ignore_nil)
-
-    yield self if ::Kernel.block_given?
+    yield self if block
   end
 
   # Yields a builder and automatically turns the result into a JSON string
-  def self.encode(*args, &block)
-    new(*args, &block).target!
+  def self.encode(...)
+    new(...).target!
   end
 
   BLANK = Blank.new
-  NON_ENUMERABLES = [ ::Struct, ::OpenStruct ].to_set
 
   def set!(key, value = BLANK, *args, &block)
     result = if ::Kernel.block_given?
@@ -56,20 +63,12 @@ class Jbuilder
     else
       # json.author @post.creator, :name, :email_address
       # { "author": { "name": "David", "email_address": "david@loudthinking.com" } }
-      _merge_block(key){ extract! value, *args }
+      _merge_block(key){ _extract value, args }
     end
 
     _set_value key, result
   end
 
-  def method_missing(*args, &block)
-    if ::Kernel.block_given?
-      set!(*args, &block)
-    else
-      set!(*args)
-    end
-  end
-
   # Specifies formatting to be applied to the key. Passing in a name of a function
   # will cause that function to be called on the key.  So :upcase will upper case
   # the key.  You can also pass in lambdas for more complex transformations.
@@ -98,13 +97,13 @@ class Jbuilder
   #
   #   { "_first_name": "David" }
   #
-  def key_format!(*args)
-    @key_formatter = KeyFormatter.new(*args)
+  def key_format!(...)
+    @key_formatter = KeyFormatter.new(...)
   end
 
   # Same as the instance method key_format! except sets the default.
-  def self.key_format(*args)
-    @@key_formatter = KeyFormatter.new(*args)
+  def self.key_format(...)
+    @@key_formatter = KeyFormatter.new(...)
   end
 
   # If you want to skip adding nil values to your JSON hash. This is useful
@@ -131,6 +130,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:
@@ -188,12 +212,12 @@ class Jbuilder
     elsif ::Kernel.block_given?
       _map_collection(collection, &block)
     elsif attributes.any?
-      _map_collection(collection) { |element| extract! element, *attributes }
+      _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.
@@ -214,18 +238,14 @@ class Jbuilder
   #
   #   json.(@person, :name, :age)
   def extract!(object, *attributes)
-    if ::Hash === object
-      _extract_hash_values(object, attributes)
-    else
-      _extract_method_values(object, attributes)
-    end
+    _extract object, attributes
   end
 
   def call(object, *attributes, &block)
     if ::Kernel.block_given?
       array! object, &block
     else
-      extract! object, *attributes
+      _extract object, attributes
     end
   end
 
@@ -244,7 +264,7 @@ class Jbuilder
   # Merges hash, array, or Jbuilder instance into current builder.
   def merge!(object)
     hash_or_array = ::Jbuilder === object ? object.attributes! : object
-    @attributes = _merge_values(@attributes, hash_or_array)
+    @attributes = _merge_values(@attributes, _format_keys(hash_or_array))
   end
 
   # Encodes the current builder as JSON.
@@ -254,17 +274,27 @@ class Jbuilder
 
   private
 
+  alias_method :method_missing, :set!
+
+  def _extract(object, attributes)
+    if ::Hash === object
+      _extract_hash_values(object, attributes)
+    else
+      _extract_method_values(object, attributes)
+    end
+  end
+
   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)
     current_value = _blank? ? BLANK : @attributes.fetch(_key(key), BLANK)
-    raise NullError.build(key) if current_value.nil?
+    ::Kernel.raise NullError.build(key) if current_value.nil?
     new_value = _scope{ yield self }
     _merge_values(current_value, new_value)
   end
@@ -273,21 +303,29 @@ class Jbuilder
     if _blank?(updates)
       current_value
     elsif _blank?(current_value) || updates.nil? || current_value.empty? && ::Array === updates
-      _format_keys(updates)
+      updates
     elsif ::Array === current_value && ::Array === updates
-      current_value + _format_keys(updates)
+      current_value + updates
     elsif ::Hash === current_value && ::Hash === updates
-      current_value.deep_merge(_format_keys(updates))
+      current_value.deep_merge(updates)
     else
-      raise MergeError.build(current_value, updates)
+      ::Kernel.raise MergeError.build(current_value, updates)
     end
   end
 
   def _key(key)
-    @key_formatter ? @key_formatter.format(key) : key.to_s
+    if @key_formatter
+      @key_formatter.format(key)
+    elsif key.is_a?(::Symbol)
+      key.name
+    else
+      key.to_s
+    end
   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
@@ -298,8 +336,8 @@ class Jbuilder
   end
 
   def _set_value(key, value)
-    raise NullError.build(key) if @attributes.nil?
-    raise ArrayError.build(key) if ::Array === @attributes
+    ::Kernel.raise NullError.build(key) if @attributes.nil?
+    ::Kernel.raise ArrayError.build(key) if ::Array === @attributes
     return if @ignore_nil && value.nil? or _blank?(value)
     @attributes = {} if _blank?
     @attributes[_key(key)] = value
@@ -312,25 +350,21 @@ 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)
-    _object_respond_to?(object, :map, :count) && NON_ENUMERABLES.none?{ |klass| klass === object }
+    object.respond_to?(:map) && object.respond_to?(:count) && !(::Struct === object)
   end
 
   def _blank?(value=@attributes)
     BLANK == value
   end
-
-  def _object_respond_to?(object, *methods)
-    methods.all?{ |m| object.respond_to?(m) }
-  end
 end
 
 require 'jbuilder/railtie' if defined?(Rails)

data/test/jbuilder_dependency_tracker_test.rb

@@ -1,6 +1,5 @@
 require 'test_helper'
-require 'jbuilder/dependency_tracker'
-
+require 'jbuilder/jbuilder_dependency_tracker'
 
 class FakeTemplate
     attr_reader :source, :handler
@@ -61,7 +60,7 @@ class JbuilderDependencyTrackerTest < ActiveSupport::TestCase
       assert_equal %w[comments/comment], dependencies
     end
 
-    test 'detects explicit depedency' do
+    test 'detects explicit dependency' do
       dependencies = track_dependencies <<-RUBY
         # Template Dependency: path/to/partial
         json.foo 'bar'

data/test/jbuilder_generator_test.rb

@@ -44,15 +44,25 @@ class JbuilderGeneratorTest < Rails::Generators::TestCase
     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
+  test 'namespaced views are generated correctly for index' do
+    run_generator %w(Admin::Post --model-name=Post)
+
+    assert_file 'app/views/admin/posts/index.json.jbuilder' do |content|
+      assert_match %r{json\.array! @posts, partial: "admin/posts/post", as: :post}, content
+    end
+
+    assert_file 'app/views/admin/posts/show.json.jbuilder' do |content|
+      assert_match %r{json\.partial! "admin/posts/post", post: @post}, content
+    end
+  end
+
+  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

data/test/jbuilder_template_test.rb

@@ -49,6 +49,17 @@ class JbuilderTemplateTest < ActiveSupport::TestCase
     assert_equal "hello", result["content"]
   end
 
+  test "partial by name with hash value omission (punning) as last statement [3.1+]" do
+    major, minor, _ = RUBY_VERSION.split(".").map(&:to_i)
+    return unless (major == 3 && minor >= 1) || major > 3
+
+    result = render(<<-JBUILDER)
+      content = "hello"
+      json.partial! "partial", content:
+    JBUILDER
+    assert_equal "hello", result["content"]
+  end
+
   test "partial by options containing nested locals" do
     result = render('json.partial! partial: "partial", locals: { content: "hello" }')
     assert_equal "hello", result["content"]
@@ -73,6 +84,14 @@ class JbuilderTemplateTest < ActiveSupport::TestCase
     assert_equal "Pavel", result[5]["author"]["first_name"]
   end
 
+  test "partial collection by name with caching" do
+    result = render('json.partial! "post", collection: @posts, cached: true, 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 collection by name with string local" do
     result = render('json.partial! "post", collection: @posts, as: "post"', posts: POSTS)
     assert_equal 10, result.count
@@ -90,10 +109,12 @@ class JbuilderTemplateTest < ActiveSupport::TestCase
   end
 
   test "nil partial collection by name" do
+    Jbuilder::CollectionRenderer.expects(:new).never
     assert_equal [], render('json.partial! "post", collection: @posts, as: :post', posts: nil)
   end
 
   test "nil partial collection by options" do
+    Jbuilder::CollectionRenderer.expects(:new).never
     assert_equal [], render('json.partial! partial: "post", collection: @posts, as: :post', posts: nil)
   end
 
@@ -105,7 +126,13 @@ class JbuilderTemplateTest < ActiveSupport::TestCase
     assert_equal "Pavel", result[5]["author"]["first_name"]
   end
 
+  test "empty array of partials from empty collection" do
+    Jbuilder::CollectionRenderer.expects(:new).never
+    assert_equal [], render('json.array! @posts, partial: "post", as: :post', posts: [])
+  end
+
   test "empty array of partials from nil collection" do
+    Jbuilder::CollectionRenderer.expects(:new).never
     assert_equal [], render('json.array! @posts, partial: "post", as: :post', posts: nil)
   end
 
@@ -118,10 +145,17 @@ class JbuilderTemplateTest < ActiveSupport::TestCase
   end
 
   test "empty array of partials under key from nil collection" do
+    Jbuilder::CollectionRenderer.expects(:new).never
     result = render('json.posts @posts, partial: "post", as: :post', posts: nil)
     assert_equal [], result["posts"]
   end
 
+  test "empty array of partials under key from an empy collection" do
+    Jbuilder::CollectionRenderer.expects(:new).never
+    result = render('json.posts @posts, partial: "post", as: :post', posts: [])
+    assert_equal [], result["posts"]
+  end
+
   test "object fragment caching" do
     render(<<-JBUILDER)
       json.cache! "cache-key" do
@@ -159,7 +193,7 @@ class JbuilderTemplateTest < ActiveSupport::TestCase
   end
 
   test "object fragment caching with expiry" do
-    travel_to "2018-05-12 11:29:00 -0400"
+    travel_to Time.iso8601("2018-05-12T11:29:00-04:00")
 
     render <<-JBUILDER
       json.cache! "cache-key", expires_in: 1.minute do
@@ -283,6 +317,99 @@ class JbuilderTemplateTest < ActiveSupport::TestCase
     assert_equal "David", result["firstName"]
   end
 
+  test "returns an empty array for an empty collection" do
+    Jbuilder::CollectionRenderer.expects(:new).never
+    result = render('json.array! @posts, partial: "post", as: :post, cached: true', posts: [])
+
+    # Do not use #assert_empty as it is important to ensure that the type of the JSON result is an array.
+    assert_equal [], result
+  end
+
+  test "works with an enumerable object" do
+    enumerable_class = Class.new do
+      include Enumerable
+
+      def each(&block)
+        [].each(&block)
+      end
+    end
+
+    result = render('json.array! @posts, partial: "post", as: :post, cached: true', posts: enumerable_class.new)
+
+    # Do not use #assert_empty as it is important to ensure that the type of the JSON result is an array.
+    assert_equal [], result
+  end
+
+  test "supports the cached: true option" do
+    result = render('json.array! @posts, partial: "post", as: :post, cached: true', 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"]
+
+    expected = {
+      "id" => 1,
+      "body" => "Post #1",
+      "author" => {
+        "first_name" => "David",
+        "last_name" => "Heinemeier Hansson"
+      }
+    }
+
+    assert_equal expected, Rails.cache.read("post-1")
+
+    result = render('json.array! @posts, partial: "post", as: :post, cached: true', 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 "supports the cached: ->() {} option" do
+    result = render('json.array! @posts, partial: "post", as: :post, cached: ->(post) { [post, "foo"] }', 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"]
+
+    expected = {
+      "id" => 1,
+      "body" => "Post #1",
+      "author" => {
+        "first_name" => "David",
+        "last_name" => "Heinemeier Hansson"
+      }
+    }
+
+    assert_equal expected, Rails.cache.read("post-1/foo")
+
+    result = render('json.array! @posts, partial: "post", as: :post, cached: ->(post) { [post, "foo"] }', 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 "raises an error on a render call with the :layout option" do
+    error = assert_raises NotImplementedError do
+      render('json.array! @posts, partial: "post", as: :post, layout: "layout"', posts: POSTS)
+    end
+
+    assert_equal "The `:layout' option is not supported in collection rendering.", error.message
+  end
+
+  test "raises an error on a render call with the :spacer_template option" do
+    error = assert_raises NotImplementedError do
+      render('json.array! @posts, partial: "post", as: :post, spacer_template: "template"', posts: POSTS)
+    end
+
+    assert_equal "The `:spacer_template' option is not supported in collection rendering.", error.message
+  end
+
   private
     def render(*args)
       JSON.load render_without_parsing(*args)
@@ -290,7 +417,7 @@ class JbuilderTemplateTest < ActiveSupport::TestCase
 
     def render_without_parsing(source, assigns = {})
       view = build_view(fixtures: PARTIALS.merge("source.json.jbuilder" => source), assigns: assigns)
-      view.render(template: "source.json.jbuilder")
+      view.render(template: "source")
     end
 
     def build_view(options = {})
@@ -298,14 +425,12 @@ class JbuilderTemplateTest < ActiveSupport::TestCase
       lookup_context = ActionView::LookupContext.new([ resolver ], {}, [""])
       controller = ActionView::TestCase::TestController.new
 
-      # 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
+      view = ActionView::Base.with_empty_template_cache.new(lookup_context, options.fetch(:assigns, {}), controller)
 
       def view.view_cache_dependencies; []; end
+      def view.combined_fragment_cache_key(key) [ key ] end
+      def view.cache_fragment_name(key, *) key end
+      def view.fragment_name_with_digest(key) key end
 
       view
     end