deep_hash_transformer 0.1.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1e1a32abac6889cf4b76e86815e230a64e35a24d
-  data.tar.gz: 87d63d20fba0c52e59d81d32a2425700300695c9
+SHA256:
+  metadata.gz: fd4691f4f42a7a731098aeb989eb7f333e5d34a2a627ddb3229653ff8e1a3a6f
+  data.tar.gz: 95b96a971d5b65f37411ead70ffd93d92624a145e65125a81d992cc238a87978
 SHA512:
-  metadata.gz: d6725f7676defb9af3e5bb19844bae02cf39d79d5f08138dff128cde79443a81d5a81c3a94c2a277d59a4e0bcaf71bf20603f28983fdd097bf6b06ae5a9e6f37
-  data.tar.gz: 503147021c5078826c189223e28a7edb9aba91ff27360d81694f43775398dfeb669ee589d8a4d5479aa98ec9839638a6d87d6b05fddc011f860cdded0165f6be
+  metadata.gz: f5f0e923fbed861df614b33a0e3465a8ebb24da4020750414ff911b779e07520507d6cf85c44ffa88bb0009b0fffcea192c3743a9ed7c5aa9562b2f28dc12861
+  data.tar.gz: 99412bba8c0260a5c90cd126726380f0336dfd5570d806b107601ca735edd2295d9fe8f642af9e5ac4b6a401ae8268e26fce8b59210143fabfe89e7274687180

data/lib/deep_hash_transformer/operation.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class DeepHashTransformer
+  module Operation
+    class << self
+      def camel_case(val)
+        pascal_case(val)
+          .sub(/^[A-Z]/, &:downcase)
+      end
+
+      def dasherize(val)
+        stringify(val)
+          .tr('_', '-')
+      end
+
+      def identity(val)
+        val
+      end
+
+      def pascal_case(val)
+        stringify(val)
+          .split(/(?=[A-Z])|[-_]/)
+          .map(&:capitalize)
+          .join
+      end
+
+      def stringify(val)
+        val.to_s
+      end
+
+      def symbolize(val)
+        val.to_sym
+      end
+
+      def underscore(val)
+        stringify(val)
+          .tr('-', '_')
+      end
+
+      def snake_case(val)
+        stringify(val)
+          .gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr('-', '_')
+          .downcase
+      end
+    end
+  end
+end

data/lib/deep_hash_transformer/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class DeepHashTransformer
-  VERSION = '0.1.1'.freeze
+  VERSION = '2.1.0'
 end

data/lib/deep_hash_transformer.rb

@@ -1,25 +1,36 @@
+# frozen_string_literal: true
+
+require 'deep_hash_transformer/operation'
 require 'deep_hash_transformer/version'
 
 class DeepHashTransformer
-  attr_reader :hash
-
-  OPS = {
-    dasherize:  ->(val) { val.to_s.tr('_'.freeze, '-'.freeze) },
-    identity:   ->(val) { val },
-    stringify:  ->(val) { val.to_s },
-    symbolize:  ->(val) { val.to_sym },
-    underscore: ->(val) { val.to_s.tr('-'.freeze, '_'.freeze) }
-  }.freeze
+  OPS = %i[
+    camel_case
+    dasherize
+    identity
+    pascal_case
+    snake_case
+    stringify
+    symbolize
+    underscore
+  ].freeze
 
   def initialize(hash)
     @hash = hash
   end
 
   def tr(*ops)
+    unknown_transformtions = ops.map(&:to_s) - OPS.map(&:to_s)
+    if unknown_transformtions.any?
+      raise(
+        ArgumentError, "unknown transformation(s): #{unknown_transformtions.join(',')}"
+      )
+    end
+
     transform_value(hash, ops)
   end
 
-  OPS.keys.each do |operation|
+  OPS.each do |operation|
     define_method(operation) { tr(operation) }
   end
 
@@ -32,9 +43,7 @@ class DeepHashTransformer
     when Array
       value.map { |e| transform_value(e, ops) }
     when Hash
-      Hash[
-        value.map { |k, v| [transform_key(k, ops), transform_value(v, ops)] }
-      ]
+      value.map { |k, v| [transform_key(k, ops), transform_value(v, ops)] }.to_h
     else
       value
     end
@@ -43,6 +52,6 @@ class DeepHashTransformer
   def transform_key(key, ops)
     return key unless [String, Symbol].include?(key.class)
 
-    ops.inject(key) { |k, op| OPS.fetch(op).call(k) }
+    ops.inject(key) { |k, op| Operation.public_send(op, k) }
   end
 end

data/spec/deep_hash_transformer/operation_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+RSpec.describe DeepHashTransformer::Operation do
+  examples = [
+    :symbol, 'string', 'camelCase', 'dashed-key', 'PascalCase', 'under_scored'
+  ]
+
+  subject do
+    examples.map { |value| described_class.public_send(method, value) }
+  end
+
+  # rubocop:disable Layout/HashAlignment, Style/SymbolArray, Style/WordArray
+  expected_output = {
+    camel_case:  ['symbol', 'string', 'camelCase',  'dashedKey',   'pascalCase',  'underScored'],
+    dasherize:   ['symbol', 'string', 'camelCase',  'dashed-key',  'PascalCase',  'under-scored'],
+    identity:    [:symbol,  'string', 'camelCase',  'dashed-key',  'PascalCase',  'under_scored'],
+    pascal_case: ['Symbol', 'String', 'CamelCase',  'DashedKey',   'PascalCase',  'UnderScored'],
+    snake_case:  ['symbol', 'string', 'camel_case', 'dashed_key',  'pascal_case', 'under_scored'],
+    stringify:   ['symbol', 'string', 'camelCase',  'dashed-key',  'PascalCase',  'under_scored'],
+    symbolize:   [:symbol,  :string,  :camelCase,   :'dashed-key', :PascalCase,   :under_scored],
+    underscore:  ['symbol', 'string', 'camelCase',  'dashed_key',  'PascalCase',  'under_scored']
+  }
+  # rubocop:enable Layout/HashAlignment, Style/SymbolArray, Style/WordArray
+
+  DeepHashTransformer::OPS.each do |method|
+    describe "##{method}" do
+      let(:method) { method }
+
+      it { is_expected.to eq(expected_output[method]) }
+    end
+  end
+end

data/spec/deep_hash_transformer_spec.rb

@@ -1,85 +1,79 @@
-RSpec.describe DeepHashTransformer do
-  let(:hash) do
-    {
-      Integer => 123,
-      :foobar => { bar: 'bar' },
-      'aa_zz' => [{ 'bar' => :bar, 'a-z' => 'a-z' }]
-    }
-  end
+# frozen_string_literal: true
 
-  describe '#tr with `%i[underscore symbolize]`' do
-    subject { DeepHashTransformer.new(hash).tr(:underscore, :symbolize) }
+RSpec.describe DeepHashTransformer do
+  subject(:operation) { described_class.new(example) }
 
-    it do
-      is_expected.to eq(
-        Integer => 123,
-        :foobar => { bar: 'bar' },
-        :aa_zz  => [{ bar: :bar, a_z: 'a-z' }]
-      )
-    end
-  end
+  let(:example) { { foo: 'bar' } }
 
-  describe '#dasherize' do
-    subject { DeepHashTransformer.new(hash).dasherize }
+  describe 'autogenerated methods' do
+    DeepHashTransformer::OPS.each do |method|
+      describe ".#{method}" do
+        it "delegates to `Operation.#{method}`" do
+          expect(
+            DeepHashTransformer::Operation
+          ).to receive(method).with(:foo).once # rubocop:disable RSpec/MessageSpies
 
-    it do
-      is_expected.to eq(
-        Integer => 123,
-        'foobar' => { 'bar' => 'bar' },
-        'aa-zz'  => [{ 'bar' => :bar, 'a-z' => 'a-z' }]
-      )
+          operation.public_send(method)
+        end
+      end
     end
   end
 
-  describe '#identity' do
-    subject { DeepHashTransformer.new(hash).identity }
+  describe '#tr' do
+    context 'with `:snake_case, :symbolize`' do
+      subject { super().tr(:snake_case, :symbolize) }
 
-    it do
-      is_expected.to eq(
-        Integer => 123,
-        :foobar => { bar: 'bar' },
-        'aa_zz' => [{ 'bar' => :bar, 'a-z' => 'a-z' }]
-      )
-    end
-  end
-
-  describe '#stringify' do
-    subject { DeepHashTransformer.new(hash).stringify }
+      let(:example) { { 'FooBar' => 'baz' } }
 
-    it do
-      is_expected.to eq(
-        Integer => 123,
-        'foobar' => { 'bar' => 'bar' },
-        'aa_zz'  => [{ 'bar' => :bar, 'a-z' => 'a-z' }]
-      )
+      it { is_expected.to eq(foo_bar: 'baz') }
     end
-  end
 
-  describe '#symbolize' do
-    subject { DeepHashTransformer.new(hash).symbolize }
+    context 'with an unknown transformation' do
+      subject(:unknown_ops) { operation.tr(:unknown) }
 
-    it do
-      is_expected.to eq(
-        Integer => 123,
-        :foobar => { bar: 'bar' },
-        :aa_zz  => [{ :bar => :bar, :'a-z' => 'a-z' }]
-      )
+      it 'raise an exception' do
+        expect { unknown_ops }.to raise_error(ArgumentError, /unknown/)
+      end
     end
-  end
 
-  describe '#underscore' do
-    subject { DeepHashTransformer.new(hash).underscore }
+    context 'with a complex, nested example' do
+      subject { super().tr(:camel_case, :symbolize) }
+
+      let(:example) do
+        {
+          Integer => 123,
+          :symbol => { foo_bar: 'bar' },
+          'string' => { 'foo_bar' => 123 },
+          'nested-array' => [
+            {
+              'camelCased' => 'camelCased',
+              'dashed-key' => 'dashed-key',
+              'PascalCased' => 'PascalCased',
+              'under_scored' => 'under_scored'
+            }
+          ]
+        }
+      end
 
-    it do
-      is_expected.to eq(
-        Integer => 123,
-        'foobar' => { 'bar' => 'bar' },
-        'aa_zz'  => [{ 'bar' => :bar, 'a_z' => 'a-z' }]
-      )
+      it do # rubocop:disable RSpec/ExampleLength
+        is_expected.to eq( # rubocop:disable RSpec/ImplicitSubject
+          Integer => 123,
+          :symbol => { fooBar: 'bar' },
+          :string => { fooBar: 123 },
+          :nestedArray => [
+            {
+              camelCased: 'camelCased',
+              dashedKey: 'dashed-key',
+              pascalCased: 'PascalCased',
+              underScored: 'under_scored'
+            }
+          ]
+        )
+      end
     end
   end
 
   it 'has a version number' do
-    expect(DeepHashTransformer::VERSION).not_to be nil
+    expect(DeepHashTransformer::VERSION).not_to be_nil
   end
 end

data/spec/spec_helper.rb

@@ -1,8 +1,24 @@
+# frozen_string_literal: true
+
 require 'bundler/setup'
-require 'coveralls'
 require 'deep_hash_transformer'
+require 'deep_hash_transformer/operation'
+require 'simplecov'
+
+SimpleCov.start do
+  if ENV['CI']
+    require 'simplecov-lcov'
+
+    SimpleCov::Formatter::LcovFormatter.config do |c|
+      c.report_with_single_file = true
+      c.single_report_path = 'coverage/lcov.info'
+    end
 
-Coveralls.wear!
+    formatter SimpleCov::Formatter::LcovFormatter
+  end
+
+  add_filter %w[version.rb initializer.rb]
+end
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deep_hash_transformer
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Martin Spickermann
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-04-27 00:00:00.000000000 Z
+date: 2022-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +53,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -66,7 +94,36 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: "    DeepHashTransformer helps to transform deeply nested hash structures\n"
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-lcov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "    DeepHashTransformer helps to transform keys in deeply nested hash
+  structures\n"
 email:
 - spickermann@gmail.com
 executables: []
@@ -75,14 +132,17 @@ extra_rdoc_files: []
 files:
 - MIT-LICENSE
 - lib/deep_hash_transformer.rb
+- lib/deep_hash_transformer/operation.rb
 - lib/deep_hash_transformer/version.rb
+- spec/deep_hash_transformer/operation_spec.rb
 - spec/deep_hash_transformer_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/spickermann/deep_hash_transformer
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -90,16 +150,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: Transforms deeply nested hash structure
 test_files: []