deep_hash_transformer 2.2.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e757436383ce13e17ee8e2b68e48d419e2f9f3c2e57fcfa76503e723ecde5e0
-  data.tar.gz: 5508770653b53402c6be53f9a3b1c0ea42a899b42760c2844565c3befa4bc54c
+  metadata.gz: cd3cd6700a7e51238c1c16feb30a81fb8debe53c5225401f33442ef29d771c92
+  data.tar.gz: 93aeb34e4a4e0bdbefa97d6d946d21fc8ab87457bd8361d992aa66399100849e
 SHA512:
-  metadata.gz: 02c165dda7044c595af36f476fe4234dfca724654e4384d971c183f14dadab6a1f9782f58dd5736f2b82962b7811a41fd51350b2a755ef62cfe684b259dd705d
-  data.tar.gz: 41ed65816b738a755fdfbf9e97c0c6ef408fa022a16230d504b0acb4f744ef10279f98954b3eb1c22eaf7af552a9ef5a40c61b75e68cfe4f723f444ebd7e9987
+  metadata.gz: 515fe31abc501135498b1450e9f90820c7612161e643198f9276006095abc5eff05e5c54cb924c37ae4e801e078a9cf9f26ccb17900341b2b7f093e86f9d4c03
+  data.tar.gz: 4cb38f5bcfcf1265f77244e61c8d4b13f0d833a52b6ef4e334cbe43bbe157eeee4a3c467f5d08f45b2e738cfee936395cee3a073e79e2c9453a7ba8aef7ab001

data/lib/deep_hash_transformer/blank.rb

@@ -2,7 +2,7 @@
 
 class DeepHashTransformer
   class Blank
-    BLANK_STRING = /\A[[:space:]]*\z/.freeze
+    BLANK_STRING = /\A[[:space:]]*\z/
 
     def self.call(value)
       new(value).blank?
@@ -13,10 +13,10 @@ class DeepHashTransformer
     end
 
     def blank?
-      return true                       unless value
-      return value.blank?               if value.respond_to?(:blank?)
+      return true unless value
+      return value.blank? if value.respond_to?(:blank?)
       return BLANK_STRING.match?(value) if value.is_a?(String)
-      return value.empty?               if value.respond_to?(:empty?)
+      return value.empty? if value.respond_to?(:empty?)
 
       false
     end

data/lib/deep_hash_transformer/collection_operation.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative './blank'
+require_relative "blank"
 
 class DeepHashTransformer
   module CollectionOperation

data/lib/deep_hash_transformer/element_operation.rb

@@ -10,7 +10,7 @@ class DeepHashTransformer
 
       def dasherize(val)
         stringify(val)
-          .tr('_', '-')
+          .tr("_", "-")
       end
 
       def identity(val)
@@ -34,14 +34,14 @@ class DeepHashTransformer
 
       def underscore(val)
         stringify(val)
-          .tr('-', '_')
+          .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('-', '_')
+          .tr("-", "_")
           .downcase
       end
     end

data/lib/deep_hash_transformer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class DeepHashTransformer
-  VERSION = '2.2.0'
+  VERSION = "2.2.1"
 end

data/lib/deep_hash_transformer.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'deep_hash_transformer/collection_operation'
-require 'deep_hash_transformer/element_operation'
-require 'deep_hash_transformer/version'
+require "deep_hash_transformer/collection_operation"
+require "deep_hash_transformer/element_operation"
+require "deep_hash_transformer/version"
 
 class DeepHashTransformer
   ELEMENT_OPS = %i[
@@ -31,7 +31,7 @@ class DeepHashTransformer
     unknown_transformations = ops.map(&:to_s) - OPS.map(&:to_s)
     if unknown_transformations.any?
       raise(
-        ArgumentError, "unknown transformation(s): #{unknown_transformations.join(',')}"
+        ArgumentError, "unknown transformation(s): #{unknown_transformations.join(",")}"
       )
     end
 
@@ -54,13 +54,13 @@ class DeepHashTransformer
 
   def transform_value(value, ops)
     collection = case value
-                 when Array
-                   value.map { |e| transform_value(e, ops) }
-                 when Hash
-                   value.map { |k, v| [transform_key(k, ops), transform_value(v, ops)] }.to_h
-                 else
-                   value
-                 end
+    when Array
+      value.map { |e| transform_value(e, ops) }
+    when Hash
+      value.map { |k, v| [transform_key(k, ops), transform_value(v, ops)] }.to_h
+    else
+      value
+    end
 
     transform_collection(collection, ops)
   end

data/spec/deep_hash_transformer/blank_spec.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 RSpec.describe DeepHashTransformer::Blank do
-  describe '.call' do
+  describe ".call" do
     subject { described_class.call(value) }
 
-    presents = [true, 1, 0, 'any', [nil], { A: nil }]
-    blanks   = [nil, false, '', ' ', [], {}]
+    presents = [true, 1, 0, "any", [nil], {A: nil}]
+    blanks = [nil, false, "", " ", [], {}]
 
     presents.each do |value|
       context "with #{value.inspect}" do

data/spec/deep_hash_transformer/collection_operation_spec.rb

@@ -2,28 +2,28 @@
 
 RSpec.describe DeepHashTransformer::CollectionOperation do
   examples = [
-    { a: 'b' }, { a: nil }, { a: ' ' }, [:foo], ['', nil]
+    {a: "b"}, {a: nil}, {a: " "}, [:foo], ["", nil]
   ]
 
   subject do
     examples.map { |value| described_class.public_send(method, value) }
   end
 
-  describe '.compact' do
+  describe ".compact" do
     let(:method) { :compact }
 
     expected_output = [
-      { a: 'b' }, {}, { a: ' ' }, [:foo], ['']
+      {a: "b"}, {}, {a: " "}, [:foo], [""]
     ]
 
     it { is_expected.to eq(expected_output) }
   end
 
-  describe '.compact_blank' do
+  describe ".compact_blank" do
     let(:method) { :compact_blank }
 
     expected_output = [
-      { a: 'b' }, {}, {}, [:foo], []
+      {a: "b"}, {}, {}, [:foo], []
     ]
 
     it { is_expected.to eq(expected_output) }

data/spec/deep_hash_transformer/element_operation_spec.rb

@@ -2,7 +2,7 @@
 
 RSpec.describe DeepHashTransformer::ElementOperation do
   examples = [
-    :symbol, 'string', 'camelCase', 'dashed-key', 'PascalCase', 'under_scored'
+    :symbol, "string", "camelCase", "dashed-key", "PascalCase", "under_scored"
   ]
 
   subject do
@@ -11,14 +11,14 @@ RSpec.describe DeepHashTransformer::ElementOperation do
 
   # 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']
+    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
 

data/spec/deep_hash_transformer_spec.rb

@@ -3,9 +3,9 @@
 RSpec.describe DeepHashTransformer do
   subject(:operation) { described_class.new(example) }
 
-  let(:example) { { foo: 'bar' } }
+  let(:example) { {foo: "bar"} }
 
-  describe 'autogenerated methods' do
+  describe "autogenerated methods" do
     DeepHashTransformer::ELEMENT_OPS.each do |method|
       describe ".#{method}" do
         it "delegates to `Operation.#{method}`" do
@@ -19,37 +19,37 @@ RSpec.describe DeepHashTransformer do
     end
   end
 
-  describe '#tr' do
-    context 'with `:snake_case, :symbolize`' do
+  describe "#tr" do
+    context "with `:snake_case, :symbolize`" do
       subject { super().tr(:snake_case, :symbolize) }
 
-      let(:example) { { 'FooBar' => 'baz' } }
+      let(:example) { {"FooBar" => "baz"} }
 
-      it { is_expected.to eq(foo_bar: 'baz') }
+      it { is_expected.to eq(foo_bar: "baz") }
     end
 
-    context 'with an unknown transformation' do
+    context "with an unknown transformation" do
       subject(:unknown_ops) { operation.tr(:unknown) }
 
-      it 'raise an exception' do
+      it "raise an exception" do
         expect { unknown_ops }.to raise_error(ArgumentError, /unknown/)
       end
     end
 
-    context 'with a complex, nested example' do
+    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' => [
+          :symbol => {foo_bar: "bar"},
+          "string" => {"foo_bar" => 123},
+          "nested-array" => [
             {
-              'camelCased' => 'camelCased',
-              'dashed-key' => 'dashed-key',
-              'PascalCased' => 'PascalCased',
-              'under_scored' => 'under_scored'
+              "camelCased" => "camelCased",
+              "dashed-key" => "dashed-key",
+              "PascalCased" => "PascalCased",
+              "under_scored" => "under_scored"
             }
           ]
         }
@@ -58,71 +58,71 @@ RSpec.describe DeepHashTransformer do
       it do # rubocop:disable RSpec/ExampleLength
         is_expected.to eq( # rubocop:disable RSpec/ImplicitSubject
           Integer => 123,
-          :symbol => { fooBar: 'bar' },
-          :string => { fooBar: 123 },
+          :symbol => {fooBar: "bar"},
+          :string => {fooBar: 123},
           :nestedArray => [
             {
-              camelCased: 'camelCased',
-              dashedKey: 'dashed-key',
-              pascalCased: 'PascalCased',
-              underScored: 'under_scored'
+              camelCased: "camelCased",
+              dashedKey: "dashed-key",
+              pascalCased: "PascalCased",
+              underScored: "under_scored"
             }
           ]
         )
       end
     end
 
-    context 'with nil values' do
+    context "with nil values" do
       subject { super().tr(:compact, :stringify) }
 
       let(:example) do
-        { a: { b: ['', nil, :value], c: '', d: nil, e: true, f: false, g: 123, h: [''] } }
+        {a: {b: ["", nil, :value], c: "", d: nil, e: true, f: false, g: 123, h: [""]}}
       end
 
       it do # rubocop:disable RSpec/ExampleLength
         is_expected.to eq( # rubocop:disable RSpec/ImplicitSubject
-          'a' => {
-            'b' => ['', :value],
-            'c' => '',
-            'e' => true,
-            'f' => false,
-            'g' => 123,
-            'h' => ['']
+          "a" => {
+            "b" => ["", :value],
+            "c" => "",
+            "e" => true,
+            "f" => false,
+            "g" => 123,
+            "h" => [""]
           }
         )
       end
     end
 
-    context 'with blank values' do
+    context "with blank values" do
       subject { super().tr(:compact_blank, :stringify) }
 
       let(:example) do
-        { a: { b: ['', nil, :value], c: '', d: nil, e: true, f: false, g: 123, h: [''] } }
+        {a: {b: ["", nil, :value], c: "", d: nil, e: true, f: false, g: 123, h: [""]}}
       end
 
       it do # rubocop:disable RSpec/ExampleLength
         is_expected.to eq( # rubocop:disable RSpec/ImplicitSubject
-          'a' => {
-            'b' => [:value],
-            'e' => true,
-            'g' => 123
+          "a" => {
+            "b" => [:value],
+            "e" => true,
+            "g" => 123
           }
         )
       end
     end
 
-    context 'with deeply nested blank values' do
+    context "with deeply nested blank values" do
       subject { super().tr(:compact_blank) }
 
       let(:example) do
-        { a: { b: [nil, { c: nil }] } }
+        {a: {b: [nil, {c: nil}]}}
       end
 
       it { is_expected.to eq({}) }
     end
   end
 
-  it 'has a version number' do
+  it "has a version number" do
     expect(DeepHashTransformer::VERSION).not_to be_nil
   end
 end

data/spec/spec_helper.rb

@@ -1,22 +1,26 @@
 # frozen_string_literal: true
 
-require 'bundler/setup'
-require 'deep_hash_transformer'
-require 'deep_hash_transformer/blank'
-require 'deep_hash_transformer/collection_operation'
-require 'deep_hash_transformer/element_operation'
-require 'simplecov'
+require "bundler/setup"
+require "deep_hash_transformer"
+require "deep_hash_transformer/blank"
+require "deep_hash_transformer/collection_operation"
+require "deep_hash_transformer/element_operation"
+
+require "simplecov"
 
 SimpleCov.start do
-  if ENV['CI']
-    require 'simplecov-lcov'
+  if ENV["CI"]
+    require "simplecov_json_formatter"
+    require "simplecov-lcov"
 
     SimpleCov::Formatter::LcovFormatter.config do |c|
       c.report_with_single_file = true
-      c.single_report_path = 'coverage/lcov.info'
+      c.single_report_path = "coverage/lcov.info"
     end
 
-    formatter SimpleCov::Formatter::LcovFormatter
+    formatter SimpleCov::Formatter::MultiFormatter.new [
+      SimpleCov::Formatter::JSONFormatter, SimpleCov::Formatter::LcovFormatter
+    ]
   end
 
   add_filter %w[version.rb initializer.rb]
@@ -24,7 +28,7 @@ end
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure
-  config.example_status_persistence_file_path = '.rspec_status'
+  config.example_status_persistence_file_path = ".rspec_status"
 
   config.expect_with :rspec do |c|
     c.syntax = :expect

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deep_hash_transformer
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.1
 platform: ruby
 authors:
 - Martin Spickermann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-16 00:00:00.000000000 Z
+date: 2023-12-25 00:00:00.000000000 Z
 dependencies: []
 description: "    DeepHashTransformer helps to transform keys in deeply nested hash
   structures\n"
@@ -42,14 +42,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Transforms deeply nested hash structure