jbuilder 2.0.6 → 2.11.5

data/lib/jbuilder.rb

@@ -1,51 +1,25 @@
-require 'active_support/core_ext/array/access'
-require 'active_support/core_ext/enumerable'
-require 'active_support/core_ext/hash'
-require 'multi_json'
-
-begin
-  require 'active_support/proxy_object'
-  JbuilderProxy = ActiveSupport::ProxyObject
-rescue LoadError
-  require 'active_support/basic_object'
-  JbuilderProxy = ActiveSupport::BasicObject
-end
-
-class Jbuilder < JbuilderProxy
-  class NullError < ::NoMethodError
-    def initialize(key)
-      super "Failed to add #{key.to_s.inspect} property to null object"
-    end
-  end
-
-  class KeyFormatter
-    def initialize(*args)
-      @format = {}
-      @cache = {}
+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
+  @@deep_format_keys = false
 
-      options = args.extract_options!
-      args.each do |name|
-        @format[name] = []
-      end
-      options.each do |name, paramaters|
-        @format[name] = paramaters
-      end
-    end
+  def initialize(options = {})
+    @attributes = {}
 
-    def initialize_copy(original)
-      @cache = {}
-    end
+    @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)
 
-    def format(key)
-      @cache[key] ||= @format.inject(key.to_s) do |result, args|
-        func, args = args
-        if ::Proc === func
-          func.call result, *args
-        else
-          result.send func, *args
-        end
-      end
-    end
+    yield self if ::Kernel.block_given?
   end
 
   # Yields a builder and automatically turns the result into a JSON string
@@ -53,58 +27,51 @@ class Jbuilder < JbuilderProxy
     new(*args, &block).target!
   end
 
-  @@key_formatter = KeyFormatter.new
-  @@ignore_nil    = false
-
-  def initialize(options = {}, &block)
-    @attributes = {}
-
-    @key_formatter = options.fetch(:key_formatter){ @@key_formatter.clone }
-    @ignore_nil = options.fetch(:ignore_nil, @@ignore_nil)
-    yield self if block
-  end
-
-  BLANK = ::Object.new
+  BLANK = Blank.new
+  NON_ENUMERABLES = [ ::Struct, ::OpenStruct ].to_set
 
   def set!(key, value = BLANK, *args, &block)
-
-    result = if block
-      if BLANK != value
+    result = if ::Kernel.block_given?
+      if !_blank?(value)
         # json.comments @post.comments { |comment| ... }
         # { "comments": [ { ... }, { ... } ] }
         _scope{ array! value, &block }
       else
         # json.comments { ... }
         # { "comments": ... }
-        _scope { yield self }
+        _merge_block(key){ yield self }
       end
     elsif args.empty?
       if ::Jbuilder === value
         # 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 _mapable_arguments?(value, *args)
+    elsif _is_collection?(value)
       # json.comments @post.comments, :content, :created_at
       # { "comments": [ { "content": "hello", "created_at": "..." }, { "content": "world", "created_at": "..." } ] }
       _scope{ array! value, *args }
     else
       # json.author @post.creator, :name, :email_address
       # { "author": { "name": "David", "email_address": "david@loudthinking.com" } }
-      _scope { extract! value, *args }
+      _merge_block(key){ extract! value, *args }
     end
 
     _set_value key, result
   end
 
-  alias_method :method_missing, :set!
-  private :method_missing
-
+  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
@@ -167,6 +134,31 @@ class Jbuilder < JbuilderProxy
     @@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:
@@ -185,7 +177,7 @@ class Jbuilder < JbuilderProxy
   #   end
   def child!
     @attributes = [] unless ::Array === @attributes
-    @attributes << _scope { yield self }
+    @attributes << _scope{ yield self }
   end
 
   # Turns the current element into an array and iterates over the passed collection, adding each iteration as
@@ -200,7 +192,7 @@ class Jbuilder < JbuilderProxy
   #
   #   [ { "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| ... }
   #
@@ -219,13 +211,17 @@ class Jbuilder < JbuilderProxy
   #
   #   [1,2,3]
   def array!(collection = [], *attributes, &block)
-    @attributes = if block
+    array = if collection.nil?
+      []
+    elsif ::Kernel.block_given?
       _map_collection(collection, &block)
     elsif attributes.any?
       _map_collection(collection) { |element| extract! element, *attributes }
     else
-      collection
+      _format_keys(collection.to_a)
     end
+
+    @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.
@@ -247,14 +243,14 @@ class Jbuilder < JbuilderProxy
   #   json.(@person, :name, :age)
   def extract!(object, *attributes)
     if ::Hash === object
-      _extract_hash_values(object, *attributes)
+      _extract_hash_values(object, attributes)
     else
-      _extract_method_values(object, *attributes)
+      _extract_method_values(object, attributes)
     end
   end
 
   def call(object, *attributes, &block)
-    if block
+    if ::Kernel.block_given?
       array! object, &block
     else
       extract! object, *attributes
@@ -273,60 +269,98 @@ class Jbuilder < JbuilderProxy
     @attributes
   end
 
-  # Merges hash or array into current builder.
-  def merge!(hash_or_array)
-    if ::Array === hash_or_array
-      @attributes = [] unless ::Array === @attributes
-      @attributes.concat hash_or_array
-    else
-      @attributes.update hash_or_array
-    end
+  # 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) }
-    end
+  def _extract_hash_values(object, attributes)
+    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) }
-    end
+  def _extract_method_values(object, attributes)
+    attributes.each{ |key| _set_value key, _format_keys(object.public_send(key)) }
+  end
 
-    def _set_value(key, value)
-      raise NullError, key if @attributes.nil?
-      unless @ignore_nil && value.nil?
-        @attributes[@key_formatter.format(key)] = value
-      end
+  def _merge_block(key)
+    current_value = _blank? ? BLANK : @attributes.fetch(_key(key), BLANK)
+    raise NullError.build(key) if current_value.nil?
+    new_value = _scope{ yield self }
+    _merge_values(current_value, new_value)
+  end
+
+  def _merge_values(current_value, updates)
+    if _blank?(updates)
+      current_value
+    elsif _blank?(current_value) || updates.nil? || current_value.empty? && ::Array === updates
+      updates
+    elsif ::Array === current_value && ::Array === updates
+      current_value + updates
+    elsif ::Hash === current_value && ::Hash === updates
+      current_value.deep_merge(updates)
+    else
+      raise MergeError.build(current_value, updates)
     end
+  end
 
-    def _map_collection(collection)
-      return [] if collection.nil?
+  def _key(key)
+    @key_formatter ? @key_formatter.format(key) : key.to_s
+  end
 
-      collection.map do |element|
-        _scope { yield element }
-      end
-    end
+  def _format_keys(hash_or_array)
+    return hash_or_array unless @deep_format_keys
 
-    def _scope
-      parent_attributes, parent_formatter = @attributes, @key_formatter
-      @attributes = {}
-      yield
-      @attributes
-    ensure
-      @attributes, @key_formatter = parent_attributes, parent_formatter
+    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 _mapable_arguments?(value, *args)
-      value.respond_to?(:map)
-    end
+  def _set_value(key, value)
+    raise NullError.build(key) if @attributes.nil?
+    raise ArrayError.build(key) if ::Array === @attributes
+    return if @ignore_nil && value.nil? or _blank?(value)
+    @attributes = {} if _blank?
+    @attributes[_key(key)] = value
+  end
+
+  def _map_collection(collection)
+    collection.map do |element|
+      _scope{ yield element }
+    end - [BLANK]
+  end
+
+  def _scope
+    parent_attributes, parent_formatter, parent_deep_format_keys = @attributes, @key_formatter, @deep_format_keys
+    @attributes = BLANK
+    yield
+    @attributes
+  ensure
+    @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 }
+  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/jbuilder_template' if defined?(ActionView::Template)
-require 'jbuilder/dependency_tracker'
-require 'jbuilder/railtie' if defined?(Rails::VERSION::MAJOR) && Rails::VERSION::MAJOR == 4
+require 'jbuilder/railtie' if defined?(Rails)

data/test/jbuilder_dependency_tracker_test.rb

@@ -1,5 +1,4 @@
-require 'test/unit'
-require 'active_support/test_case'
+require 'test_helper'
 require 'jbuilder/dependency_tracker'
 
 
@@ -54,7 +53,7 @@ class JbuilderDependencyTrackerTest < ActiveSupport::TestCase
       assert_equal %w[path/to/partial], dependencies
     end
 
-    test 'detects partial in indirect collecton calls' do
+    test 'detects partial in indirect collection calls' do
       dependencies = track_dependencies <<-RUBY
         json.comments @post.comments, partial: 'comments/comment', as: :comment
       RUBY
@@ -62,7 +61,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

@@ -1,3 +1,4 @@
+require 'test_helper'
 require 'rails/generators/test_case'
 require 'generators/rails/jbuilder_generator'
 
@@ -13,19 +14,45 @@ class JbuilderGeneratorTest < Rails::Generators::TestCase
     %w(index show).each do |view|
       assert_file "app/views/posts/#{view}.json.jbuilder"
     end
+    assert_file "app/views/posts/_post.json.jbuilder"
   end
 
   test 'index content' do
     run_generator
 
     assert_file 'app/views/posts/index.json.jbuilder' do |content|
-      assert_match /json\.array!\(@posts\) do \|post\|/, content
-      assert_match /json\.extract! post, :id, :title, :body/, content
-      assert_match /json\.url post_url\(post, format: :json\)/, 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 /json\.extract! @post, :id, :title, :body, :created_at, :updated_at/, content
+      assert_match %r{json\.partial! "posts/post", post: @post}, content
+    end
+
+    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