Fix changing key format in child elements

Since rails#486, key format is applied deeply to hashes and arrays that are
passed to `set!`, `merge!` and `array!`:

    json.key_format! :upcase
    json.set!(:foo, {some: "value"})

    # => {"FOO": {"SOME": "value"}}

    json.key_format! :upcase
    json.merge!({some: "value"})

    # => {"SOME": "value"}

    json.key_format! :upcase
    json.array!([{some: "value"}])

    # => [{"SOME": "value"}]

This also works for arrays and hashes extracted from objects:

    comment = Struct.new(:author).new({ first_name: 'John', last_name: 'Doe' })

    json.key_format! camlize: :lower
    json.set!(:comment, comment, :author)

    # => {"comment": {"author": {"firstName": "John", "lastName": "Doe"}}}

As a side effect of the change, key format is also applied to the
result of nested blocks, making it impossible to change key format in
the scope of a block:

    json.key_format! camelize: :lower
    json.level_one do
      json.key_format! :upcase
      json.value 'two'
    end

    # => jbuilder 2.10.0: {"levelOne": {"VALUE": "two"}}
    # => jbuilder 2.11.0: {"levelOne": {"vALUE": "two"}}

The string "vALUE" results from calling
`"value".upcase.camelize(:lower)`. The same happens when trying to
change the key format inside of an `array!` block.

This happens since key transformation was added in the `_merge_values`
method, which is used both by `merge!` but also when `set!` is called
with a block.

To restore the previous behavior, we pull the `_transform_keys` call
up into `merge!` itself. To make sure extracted hashes and arrays keep
being transformed (see comment/author example above), we apply
`_transform_keys` in `_extract_hash_values` and
`_extract_method_values`.

This also aligns the behavior of `extract!` which was left out in rails#486:

    comment = {author: { first_name: 'John', last_name: 'Doe' }}

    result = jbuild do |json|
      json.key_format! camelize: :lower
      json.extract! comment, :author
    end

    # => jbuilder 2.10 and 2.11: {"author": { :first_name => "John", :last_name => "Doe" }}
    # => now: {"author": { "firstName": "John", "lastName": "Doe" }}

Finally, to fix `array!`, we make it call `_merge_values` directly
instead of relying on `merge!`. `array!` then has to transform keys
itself when a collection is passed to preserve the new behavior
introduced by rails#486.

Author: tf

lib/jbuilder.rb

@@ -190,10 +190,10 @@ def array!(collection = [], *attributes, &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.
@@ -244,7 +244,7 @@ def attributes!
   # 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.
@@ -255,11 +255,11 @@ def target!
   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)
@@ -273,11 +273,11 @@ def _merge_values(current_value, updates)
     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)
     end

test/jbuilder_test.rb

@@ -566,6 +566,36 @@ class JbuilderTest < ActiveSupport::TestCase
     assert_equal 'one', result['level1']
   end
 
+  test 'key_format! can be changed in child elements' do
+    result = jbuild do |json|
+      json.key_format! camelize: :lower
+
+      json.level_one do
+        json.key_format! :upcase
+        json.value 'two'
+      end
+    end
+
+    assert_equal ['levelOne'], result.keys
+    assert_equal ['VALUE'], result['levelOne'].keys
+  end
+
+  test 'key_format! can be changed in array!' do
+    result = jbuild do |json|
+      json.key_format! camelize: :lower
+
+      json.level_one do
+        json.array! [{value: 'two'}] do |object|
+          json.key_format! :upcase
+          json.value object[:value]
+        end
+      end
+    end
+
+    assert_equal ['levelOne'], result.keys
+    assert_equal ['VALUE'], result['levelOne'][0].keys
+  end
+
   test 'key_format! with no parameter' do
     result = jbuild do |json|
       json.key_format! :upcase
@@ -623,6 +653,16 @@ class JbuilderTest < ActiveSupport::TestCase
     assert_equal %w[firstName lastName], result['names'][0].keys
   end
 
+  test 'key_format! with set! extracting hash from object' do
+    comment = Struct.new(:author).new({ first_name: 'camel', last_name: 'case' })
+    result = jbuild do |json|
+      json.key_format! camelize: :lower
+      json.set! :comment, comment, :author
+    end
+
+    assert_equal %w[firstName lastName], result['comment']['author'].keys
+  end
+
   test 'key_format! with array! of hashes' do
     names = [{ first_name: 'camel', last_name: 'case' }]
     result = jbuild do |json|
@@ -645,6 +685,36 @@ class JbuilderTest < ActiveSupport::TestCase
     assert_equal %w[firstName lastName], result[1].keys
   end
 
+  test 'key_format! is applied to hash extracted from object' do
+    comment = Struct.new(:author).new({ first_name: 'camel', last_name: 'case' })
+    result = jbuild do |json|
+      json.key_format! camelize: :lower
+      json.extract! comment, :author
+    end
+
+    assert_equal %w[firstName lastName], result['author'].keys
+  end
+
+  test 'key_format! is applied to hash extracted from hash' do
+    comment = {author: { first_name: 'camel', last_name: 'case' }}
+    result = jbuild do |json|
+      json.key_format! camelize: :lower
+      json.extract! comment, :author
+    end
+
+    assert_equal %w[firstName lastName], result['author'].keys
+  end
+
+  test 'key_format! is applied to hash extracted directly from array' do
+    comments = [Struct.new(:author).new({ first_name: 'camel', last_name: 'case' })]
+    result = jbuild do |json|
+      json.key_format! camelize: :lower
+      json.array! comments, :author
+    end
+
+    assert_equal %w[firstName lastName], result[0]['author'].keys
+  end
+
   test 'default key_format!' do
     Jbuilder.key_format camelize: :lower
     result = jbuild{ |json| json.camel_style 'for JS' }