ditkrg/active_model_serializers
4
0
Fork 0
mirror of https://github.com/ditkrg/active_model_serializers.git synced 2026-01-22 22:06:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Swap out KeyTransform for CaseTransform (#1993)

Browse Source 
* delete KeyTransform, use CaseTransform

* added changelog
This commit is contained in:
L. Preston Sego III 2016-12-07 10:49:38 -05:00 committed by GitHub
parent fca2d4515d
commit 0422a1e772
7 changed files with 10 additions and 379 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -15,6 +15,7 @@ Fixes:
Misc:
- [#1984](https://github.com/rails-api/active_model_serializers/pull/1984) Make test attributes explicit. Test models have 'associations' support. (@bf4)
- [#1993](https://github.com/rails-api/active_model_serializers/pull/1993) Swap out KeyTransform for CaseTransform gem for the possibility of native extension use (@NullVoxPopuli)
### [v0.10.3 (2016-11-21)](https://github.com/rails-api/active_model_serializers/compare/v0.10.2...v0.10.3)

1
active_model_serializers.gemspec
View File

@ -43,6 +43,7 @@ Gem::Specification.new do |spec|
# 'thread_safe'
spec.add_runtime_dependency 'jsonapi', '0.1.1.beta2'
spec.add_runtime_dependency 'case_transform', '>= 0.2'
spec.add_development_dependency 'activerecord', rails_versions
# arel

4
lib/active_model_serializers/adapter/base.rb
View File

@ -1,4 +1,4 @@
require 'active_model_serializers/key_transform'
require 'case_transform'
module ActiveModelSerializers
module Adapter
@ -31,7 +31,7 @@ module ActiveModelSerializers
# @param options [Object] serializable resource options
# @return [Symbol] the default transform for the adapter
def self.transform_key_casing!(value, options)
KeyTransform.send(transform(options), value)
CaseTransform.send(transform(options), value)
end
def self.cache_key

2
lib/active_model_serializers/adapter/json_api/deserialization.rb
View File

@ -205,7 +205,7 @@ module ActiveModelSerializers
# @api private
def transform_keys(hash, options)
transform = options[:key_transform] || :underscore
KeyTransform.send(transform, hash)
CaseTransform.send(transform, hash)
end
end
end

74
lib/active_model_serializers/key_transform.rb
View File

@ -1,74 +0,0 @@
require 'active_support/core_ext/hash/keys'
module ActiveModelSerializers
module KeyTransform
module_function
# Transforms values to UpperCamelCase or PascalCase.
#
# @example:
# "some_key" => "SomeKey",
# @see {https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L66-L76 ActiveSupport::Inflector.camelize}
def camel(value)
case value
when Array then value.map { |item| camel(item) }
when Hash then value.deep_transform_keys! { |key| camel(key) }
when Symbol then camel(value.to_s).to_sym
when String then value.underscore.camelize
else value
end
end
# Transforms values to camelCase.
#
# @example:
# "some_key" => "someKey",
# @see {https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L66-L76 ActiveSupport::Inflector.camelize}
def camel_lower(value)
case value
when Array then value.map { |item| camel_lower(item) }
when Hash then value.deep_transform_keys! { |key| camel_lower(key) }
when Symbol then camel_lower(value.to_s).to_sym
when String then value.underscore.camelize(:lower)
else value
end
end
# Transforms values to dashed-case.
# This is the default case for the JsonApi adapter.
#
# @example:
# "some_key" => "some-key",
# @see {https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L185-L187 ActiveSupport::Inflector.dasherize}
def dash(value)
case value
when Array then value.map { |item| dash(item) }
when Hash then value.deep_transform_keys! { |key| dash(key) }
when Symbol then dash(value.to_s).to_sym
when String then value.underscore.dasherize
else value
end
end
# Transforms values to underscore_case.
# This is the default case for deserialization in the JsonApi adapter.
#
# @example:
# "some-key" => "some_key",
# @see {https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L89-L98 ActiveSupport::Inflector.underscore}
def underscore(value)
case value
when Array then value.map { |item| underscore(item) }
when Hash then value.deep_transform_keys! { |key| underscore(key) }
when Symbol then underscore(value.to_s).to_sym
when String then value.underscore
else value
end
end
# Returns the value unaltered
def unaltered(value)
value
end
end
end

297
test/active_model_serializers/key_transform_test.rb
View File

@ -1,297 +0,0 @@
require 'test_helper'
module ActiveModelSerializers
class KeyTransformTest < ActiveSupport::TestCase
def test_camel
obj = Object.new
scenarios = [
{
value: { :"some-key" => 'value' },
expected: { SomeKey: 'value' }
},
{
value: { someKey: 'value' },
expected: { SomeKey: 'value' }
},
{
value: { some_key: 'value' },
expected: { SomeKey: 'value' }
},
{
value: { 'some-key' => 'value' },
expected: { 'SomeKey' => 'value' }
},
{
value: { 'someKey' => 'value' },
expected: { 'SomeKey' => 'value' }
},
{
value: { 'some_key' => 'value' },
expected: { 'SomeKey' => 'value' }
},
{
value: :"some-value",
expected: :SomeValue
},
{
value: :some_value,
expected: :SomeValue
},
{
value: :someValue,
expected: :SomeValue
},
{
value: 'some-value',
expected: 'SomeValue'
},
{
value: 'someValue',
expected: 'SomeValue'
},
{
value: 'some_value',
expected: 'SomeValue'
},
{
value: obj,
expected: obj
},
{
value: nil,
expected: nil
},
{
value: [
{ some_value: 'value' }
],
expected: [
{ SomeValue: 'value' }
]
}
]
scenarios.each do |s|
result = ActiveModelSerializers::KeyTransform.camel(s[:value])
assert_equal s[:expected], result
end
end
def test_camel_lower
obj = Object.new
scenarios = [
{
value: { :"some-key" => 'value' },
expected: { someKey: 'value' }
},
{
value: { SomeKey: 'value' },
expected: { someKey: 'value' }
},
{
value: { some_key: 'value' },
expected: { someKey: 'value' }
},
{
value: { 'some-key' => 'value' },
expected: { 'someKey' => 'value' }
},
{
value: { 'SomeKey' => 'value' },
expected: { 'someKey' => 'value' }
},
{
value: { 'some_key' => 'value' },
expected: { 'someKey' => 'value' }
},
{
value: :"some-value",
expected: :someValue
},
{
value: :SomeValue,
expected: :someValue
},
{
value: :some_value,
expected: :someValue
},
{
value: 'some-value',
expected: 'someValue'
},
{
value: 'SomeValue',
expected: 'someValue'
},
{
value: 'some_value',
expected: 'someValue'
},
{
value: obj,
expected: obj
},
{
value: nil,
expected: nil
},
{
value: [
{ some_value: 'value' }
],
expected: [
{ someValue: 'value' }
]
}
]
scenarios.each do |s|
result = ActiveModelSerializers::KeyTransform.camel_lower(s[:value])
assert_equal s[:expected], result
end
end
def test_dash
obj = Object.new
scenarios = [
{
value: { some_key: 'value' },
expected: { :"some-key" => 'value' }
},
{
value: { 'some_key' => 'value' },
expected: { 'some-key' => 'value' }
},
{
value: { SomeKey: 'value' },
expected: { :"some-key" => 'value' }
},
{
value: { 'SomeKey' => 'value' },
expected: { 'some-key' => 'value' }
},
{
value: { someKey: 'value' },
expected: { :"some-key" => 'value' }
},
{
value: { 'someKey' => 'value' },
expected: { 'some-key' => 'value' }
},
{
value: :some_value,
expected: :"some-value"
},
{
value: :SomeValue,
expected: :"some-value"
},
{
value: 'SomeValue',
expected: 'some-value'
},
{
value: :someValue,
expected: :"some-value"
},
{
value: 'someValue',
expected: 'some-value'
},
{
value: obj,
expected: obj
},
{
value: nil,
expected: nil
},
{
value: [
{ 'some_value' => 'value' }
],
expected: [
{ 'some-value' => 'value' }
]
}
]
scenarios.each do |s|
result = ActiveModelSerializers::KeyTransform.dash(s[:value])
assert_equal s[:expected], result
end
end
def test_underscore
obj = Object.new
scenarios = [
{
value: { :"some-key" => 'value' },
expected: { some_key: 'value' }
},
{
value: { 'some-key' => 'value' },
expected: { 'some_key' => 'value' }
},
{
value: { SomeKey: 'value' },
expected: { some_key: 'value' }
},
{
value: { 'SomeKey' => 'value' },
expected: { 'some_key' => 'value' }
},
{
value: { someKey: 'value' },
expected: { some_key: 'value' }
},
{
value: { 'someKey' => 'value' },
expected: { 'some_key' => 'value' }
},
{
value: :"some-value",
expected: :some_value
},
{
value: :SomeValue,
expected: :some_value
},
{
value: :someValue,
expected: :some_value
},
{
value: 'some-value',
expected: 'some_value'
},
{
value: 'SomeValue',
expected: 'some_value'
},
{
value: 'someValue',
expected: 'some_value'
},
{
value: obj,
expected: obj
},
{
value: nil,
expected: nil
},
{
value: [
{ 'some-value' => 'value' }
],
expected: [
{ 'some_value' => 'value' }
]
}
]
scenarios.each do |s|
result = ActiveModelSerializers::KeyTransform.underscore(s[:value])
assert_equal s[:expected], result
end
end
end
end

10
test/benchmark/bm_transform.rb
View File

@ -25,21 +25,21 @@ adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
serialization = adapter.as_json
Benchmark.ams('camel', time: time, disable_gc: disable_gc) do
ActiveModelSerializers::KeyTransform.camel(serialization)
CaseTransform.camel(serialization)
end
Benchmark.ams('camel_lower', time: time, disable_gc: disable_gc) do
ActiveModelSerializers::KeyTransform.camel_lower(serialization)
CaseTransform.camel_lower(serialization)
end
Benchmark.ams('dash', time: time, disable_gc: disable_gc) do
ActiveModelSerializers::KeyTransform.dash(serialization)
CaseTransform.dash(serialization)
end
Benchmark.ams('unaltered', time: time, disable_gc: disable_gc) do
ActiveModelSerializers::KeyTransform.unaltered(serialization)
CaseTransform.unaltered(serialization)
end
Benchmark.ams('underscore', time: time, disable_gc: disable_gc) do
ActiveModelSerializers::KeyTransform.underscore(serialization)
CaseTransform.underscore(serialization)
end