deep_hash_transformer 2.2.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd3cd6700a7e51238c1c16feb30a81fb8debe53c5225401f33442ef29d771c92
-  data.tar.gz: 93aeb34e4a4e0bdbefa97d6d946d21fc8ab87457bd8361d992aa66399100849e
+  metadata.gz: 61bf68f57a229a41899b5c91536acfd67d687bc6e32b3b0d783f67607ce63d7d
+  data.tar.gz: da363a1e6058dc2bd8c997600cc5dc8e64b347acf5026836b51bb801027f5d83
 SHA512:
-  metadata.gz: 515fe31abc501135498b1450e9f90820c7612161e643198f9276006095abc5eff05e5c54cb924c37ae4e801e078a9cf9f26ccb17900341b2b7f093e86f9d4c03
-  data.tar.gz: 4cb38f5bcfcf1265f77244e61c8d4b13f0d833a52b6ef4e334cbe43bbe157eeee4a3c467f5d08f45b2e738cfee936395cee3a073e79e2c9453a7ba8aef7ab001
+  metadata.gz: 0a809f6749a8d01eff82ac032735c82f238d456da8a59476c873d469a0210a995d62d1cbe924e6de1fcf67900dfd8026754c745c63426dea291f7cd8457c2d07
+  data.tar.gz: a1162926bfe17950fcf918e19ecdb7f065f33b425dba4a66a1b515a1f0c62b68124c83adfd5f109637124a3163b5ef5773939b4790f77017bc4740bb5912f8a6

data/CHANGELOG.md

@@ -0,0 +1,78 @@
+*3.0.0 (September 30, 2026)*
+
+Maintenance status:
+
+* Enter maintenance mode: the feature set is considered complete and no new features
+  are planned. Security fixes may be released when needed. Compatibility with future
+  Ruby versions is not guaranteed.
+
+Breaking behavior changes:
+
+* Execute String operation names; previously accepted String names did nothing.
+* Reject operation-name objects other than Strings or Symbols with ArgumentError.
+* Lowercase Unicode initial capitals in camel_case (über_name becomes überName).
+* Transform String-subclass keys instead of skipping them.
+* Raise ArgumentError for cycles through collection values instead of SystemStackError.
+
+Fixes and maintenance:
+
+* Recognize valid UTF-16/UTF-32 whitespace during compact_blank cleanup.
+* Normalize and partition operations once per call, skip cleanup dispatch on scalars,
+  and build hashes directly to reduce traversal time and allocations. See benchmark
+  methodology and measured limits in docs/performance.md in the source repository.
+* Preserve last-value-wins collisions, combined traversal, and existing leaf sharing.
+* Restore coverage instrumentation before library loading and add behavioral regression tests.
+* Correct operation descriptions, the ActiveSupport comparison, and the contribution link.
+* Package README.md and CHANGELOG.md; omit specs from the runtime package.
+* Retain Ruby 3.0 support and test Ruby 3.0–3.4 and 4.0 using their latest patch releases.
+* Add isolated package verification and a reproducible runtime/allocation benchmark.
+
+See README migration notes before upgrading.
+
+*2.2.1 (December 25, 2023)*
+
+* Ensure Ruby 3.3 compability
+* Stop testing against Ruby < 3.0
+* Switch from Rubocop to Standard
+
+*2.2.0 (May 17, 2023)*
+
+* Two new transformations added:
+  - compact
+  - compact_blank
+* Ensure Ruby 3.2 compability
+* Ensure Ruby 3.3.0-preview compability
+* Rename default branch to `main`
+
+*2.1.0 (March 06, 2022)*
+
+* Three new transformations added:
+  - snake_case (thanks, @Finnegan5),
+  - camel_case,
+  - pascal_case
+* Improved error message when called with an unknown transformation name
+* Improved documentation
+* Ensure Ruby 3.1 compability
+* Switch from Travis CI to GitHub Actions
+
+*2.0.0 (December 28, 2020)*
+
+* Ensure Ruby 2.6 compability
+* Ensure Ruby 2.7 compability
+* Ensure Ruby 3.0 compability
+* Drops support for Ruby <= 2.2
+* Drops support for Ruby 2.3
+* Drops support for Ruby 2.4
+
+*1.0.0 (December 26, 2017)*
+
+* Runs specs against Ruby up to version 2.5
+* Drops support for Ruby <= 2.1
+
+*0.1.0 (April 27, 2017)*
+
+* Initial version
+
+*0.1.1 (April 27, 2017)*
+
+* Fix `undefined method 'Array#to_h'` on Ruby '< 2.1'

data/README.md

@@ -0,0 +1,217 @@
+# DeepHashTransformer
+
+Transform keys and recursively clean nested hashes and arrays without runtime dependencies.
+Combine operations to convert API data into Ruby-friendly structures:
+
+```ruby
+require "deep_hash_transformer"
+
+input = {
+  "nested-array" => [{"a-key" => "a-value", "b-key" => nil}],
+  "foo_bar" => "baz"
+}
+
+DeepHashTransformer.new(input).tr(:underscore, :symbolize, :compact)
+# => {nested_array: [{a_key: "a-value"}], foo_bar: "baz"}
+```
+
+[![License MIT](https://img.shields.io/badge/license-MIT-brightgreen.svg)](MIT-LICENSE)
+[![Gem Version](https://badge.fury.io/rb/deep_hash_transformer.svg)](https://rubygems.org/gems/deep_hash_transformer)
+[![Build Status](https://github.com/spickermann/deep_hash_transformer/actions/workflows/CI.yml/badge.svg)](https://github.com/spickermann/deep_hash_transformer/actions/workflows/CI.yml)
+
+## Maintenance status
+
+DeepHashTransformer is in maintenance mode. Its feature set is considered complete,
+and no new features are planned. Security fixes may be released when needed.
+Compatibility with future Ruby versions is not guaranteed.
+
+For general-purpose recursive key transformations, consider ActiveSupport’s
+[`deep_transform_keys`](https://api.rubyonrails.org/classes/Hash.html#method-i-deep_transform_keys),
+which supports nested hashes and arrays.
+
+DeepHashTransformer remains useful for applications that need combined key
+transformations and recursive cleanup without runtime dependencies. If that
+matches your requirements, the existing functionality remains available and
+documented.
+
+## Installation
+
+Ruby **3.0 or newer** is required. CI tests the latest patch releases of Ruby 3.0,
+3.1, 3.2, 3.3, 3.4 and 4.0. Older series remain supported while the implementation
+can support them without version-specific behavior.
+
+Add `gem "deep_hash_transformer", "~> 3.0"` to your Gemfile and run `bundle install`,
+or run `gem install deep_hash_transformer`.
+
+## Operations
+
+```ruby
+DeepHashTransformer.new({foo_bar: "baz"}).camel_case
+# => {"fooBar" => "baz"}
+
+DeepHashTransformer.new({"FooBar" => "baz"}).tr("snake_case", :symbolize)
+# => {foo_bar: "baz"}
+```
+
+`tr` accepts known operation names as symbols or strings; other arguments raise
+`ArgumentError`. Each operation also has a method of the same name.
+
+| Operation | Effect on keys or collections |
+|---|---|
+| `camel_case` | `"foo_bar"` → `"fooBar"`; `"über_name"` → `"überName"` |
+| `pascal_case` | `"foo_bar"` → `"FooBar"` |
+| `snake_case` | `"HTTPServer"` → `"http_server"` |
+| `dasherize` | Replaces underscores with dashes: `"foo_bar"` → `"foo-bar"` |
+| `underscore` | Replaces dashes with underscores: `:"foo-bar"` → `"foo_bar"` |
+| `stringify` | Converts symbol keys to strings: `:foo` → `"foo"` |
+| `symbolize` | Converts string keys to symbols: `"foo"` → `:foo` |
+| `identity` | Leaves keys unchanged |
+| `compact` | Removes `nil` hash values and array elements |
+| `compact_blank` | Removes blank hash values and array elements, recursively |
+
+Key operations apply to strings (including subclasses) and symbols. Other key
+types are unchanged; collections used as keys are not traversed. Case and
+separator conversions return strings; `symbolize` returns symbols. `identity`,
+`compact`, and `compact_blank` preserve key types. `tr` without arguments copies
+the collection structure without converting keys.
+
+Word-boundary detection remains ASCII-based. There is no acronym registry or
+locale-specific inflection: `camel_case` converts `"HTTPServer"` to `"hTTPServer"`.
+Its initial-letter lowercasing supports Unicode, but that does not make all word
+segmentation Unicode-aware. `underscore` only replaces separators; use
+`snake_case` when you also want case boundaries converted.
+
+## Combined operations and collisions
+
+`tr` combines operations in **one recursive traversal**, not a series of complete
+transformations. At each hash:
+
+1. Key operations run in their supplied order, and values are recursively transformed.
+2. The result hash is assembled. If multiple keys become equal, **the last value wins**.
+3. Collection operations run in their supplied order on the result.
+
+Arrays transform their elements before collection operations run. Cleanup thus
+proceeds from the inside out. The position of a collection operation relative to
+a key operation does not change this model:
+
+```ruby
+input = {"a" => 1, :a => nil}
+DeepHashTransformer.new(input).tr(:compact, :stringify)
+# => {}: stringify first causes a collision; compact then removes the winning nil.
+DeepHashTransformer.new(input).tr(:stringify, :compact)
+# => {}
+```
+
+For complete sequential transformations, use separate instances:
+
+```ruby
+cleaned = DeepHashTransformer.new(input).compact
+DeepHashTransformer.new(cleaned).stringify
+# => {"a" => 1}
+```
+
+Key-operation order still matters: `tr(:snake_case, :symbolize)` returns symbol
+keys, while `tr(:symbolize, :snake_case)` returns string keys.
+
+## Recursive cleanup and root values
+
+`compact` removes only `nil`, retaining `false`, whitespace, and empty collections.
+`compact_blank` additionally removes `false`, empty strings/collections, and
+strings containing only whitespace. Zero remains. Blankness honors an object's
+`blank?` method when present, otherwise checks string whitespace or `empty?`.
+User-defined methods and loaded extensions can therefore affect blankness.
+
+```ruby
+DeepHashTransformer.new({a: {b: [nil, {c: " "}]}}).compact_blank
+# => {}
+DeepHashTransformer.new({a: [nil]}).compact
+# => {a: []}
+DeepHashTransformer.new([nil, {"FooBar" => 1}]).tr(:snake_case, :compact)
+# => [{"foo_bar" => 1}]
+```
+
+Array roots are supported. Scalar roots are returned unchanged, even `nil`,
+`false`, or whitespace: cleanup removes entries from collections, not the root
+itself. Empty roots remain `{}` or `[]`.
+
+Whitespace detection includes Unicode whitespace such as nonbreaking space, and
+supports valid UTF-16/UTF-32 strings. Zero-width space is not whitespace here.
+Invalid byte sequences raise Ruby argument/encoding errors; they are not silently
+discarded. This encoding support concerns cleanup, not every key conversion.
+
+## Mutation, references, and supported structures
+
+The transformer does not mutate ordinary input collections or values. Frozen
+collections are accepted. Results contain new, mutable hashes and arrays **per
+occurrence**; shared input collections are copied independently. Mutable leaf
+objects and unchanged non-string keys remain shared. Mutating a returned leaf
+can therefore change the input's leaf; this is not a general-purpose deep copy.
+The input is read when a transformation runs, not snapshotted at initialization.
+
+Output collections are ordinary `Hash` and `Array` instances. Subclass identity,
+hash defaults/default procs, `compare_by_identity`, and frozen state are not
+preserved. Ordinary key equality applies even to identity hashes. Transformed
+string keys need not retain their subclass.
+
+Cycles through hash values and array elements raise `ArgumentError` with a
+`cyclic Hash/Array structure` message. Repeated references without cycles are
+allowed. Recursion depth is bounded by Ruby's stack; extremely deep acyclic
+inputs can still raise `SystemStackError`. Heavily shared graphs may expand
+substantially because collections are copied per occurrence. Custom methods on
+user objects are responsible for their own side effects.
+
+## Ruby and ActiveSupport
+
+Ruby's `transform_keys` and `compact` handle one collection level.
+[ActiveSupport's `deep_transform_keys`](https://api.rubyonrails.org/classes/Hash.html#method-i-deep_transform_keys)
+already traverses nested hashes **and arrays**. Use it when that API meets your
+needs, especially in an application that already loads ActiveSupport.
+
+DeepHashTransformer offers named, combinable operations and recursive cleanup
+without runtime dependencies or core-class extensions. It is not a drop-in
+replacement for ActiveSupport's key-type, subclass, or inflection behavior, nor
+is it guaranteed to be faster. See [benchmark methodology and results](https://github.com/spickermann/deep_hash_transformer/blob/main/docs/performance.md)
+in the source repository.
+
+## Migrating from 2.2.1
+
+Version 3.0.0 intentionally changes these results:
+
+- String operation names now execute instead of silently doing nothing.
+- `camel_case` lowercases Unicode initial capitals: `"über_name"` now becomes
+  `"überName"`, previously `"ÜberName"`.
+- String subclasses used as keys now participate in transformations.
+- Cyclic collections raise `ArgumentError` instead of exhausting the stack.
+- Arbitrary objects are no longer accepted as operation names via `to_s`.
+
+Review generated keys and possible new collisions, especially if they identify
+persisted fields or external API parameters. Last-value collision resolution and
+the combined traversal model remain unchanged. Ruby 3.0 support is retained.
+README and Changelog are now packaged; specs are no longer included in the gem.
+
+## Development and release
+
+Run `bundle install`, then `bundle exec rake` for tests and Standard.
+`ruby script/verify_package.rb` builds the gem under `pkg/`, checks its contents,
+and installs/tests that exact package in a temporary isolated gem directory.
+It does not publish anything. The committed `Gemfile.lock` fixes development
+dependencies across the supported Ruby versions. Update it using the oldest
+supported Ruby, then verify the complete CI matrix before committing the update.
+The lockfile is not included in the published gem and adds no runtime dependencies.
+
+See [release procedure](https://github.com/spickermann/deep_hash_transformer/blob/main/docs/releasing.md) in the source repository for the
+separate review and publication steps. `bundle exec rake release` is a publishing
+command: it creates and pushes a Git tag, pushes the branch, and uploads the gem.
+It does **not** run the test suite first or create a GitHub Release.
+
+## Contributing
+
+Bug reports and pull requests are welcome at
+[spickermann/deep_hash_transformer](https://github.com/spickermann/deep_hash_transformer).
+[Fork this repository](https://github.com/spickermann/deep_hash_transformer/fork),
+create a branch, add tests for your change, and open a pull request.
+Please follow the [Code of Conduct](https://github.com/spickermann/deep_hash_transformer/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+[MIT](MIT-LICENSE).

data/lib/deep_hash_transformer/blank.rb

@@ -15,7 +15,7 @@ class DeepHashTransformer
     def blank?
       return true unless value
       return value.blank? if value.respond_to?(:blank?)
-      return BLANK_STRING.match?(value) if value.is_a?(String)
+      return blank_string? if value.is_a?(String)
       return value.empty? if value.respond_to?(:empty?)
 
       false
@@ -24,5 +24,11 @@ class DeepHashTransformer
     private
 
     attr_reader :value
+
+    def blank_string?
+      BLANK_STRING.match?(value)
+    rescue Encoding::CompatibilityError
+      BLANK_STRING.match?(value.encode(Encoding::UTF_8))
+    end
   end
 end

data/lib/deep_hash_transformer/element_operation.rb

@@ -5,7 +5,7 @@ class DeepHashTransformer
     class << self
       def camel_case(val)
         pascal_case(val)
-          .sub(/^[A-Z]/, &:downcase)
+          .sub(/\A[[:upper:]]/, &:downcase)
       end
 
       def dasherize(val)

data/lib/deep_hash_transformer/version.rb

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

data/lib/deep_hash_transformer.rb

@@ -21,21 +21,22 @@ class DeepHashTransformer
     compact_blank
   ].freeze
 
-  OPS = ELEMENT_OPS + COLLECTION_OPS
+  OPS = (ELEMENT_OPS + COLLECTION_OPS).freeze
 
   def initialize(hash)
     @hash = hash
   end
 
   def tr(*ops)
-    unknown_transformations = ops.map(&:to_s) - OPS.map(&:to_s)
-    if unknown_transformations.any?
-      raise(
-        ArgumentError, "unknown transformation(s): #{unknown_transformations.join(",")}"
-      )
+    ops = ops.map do |op|
+      name = op.to_sym if op.is_a?(String) || op.is_a?(Symbol)
+      raise ArgumentError, "unknown transformation: #{op.inspect}" unless OPS.include?(name)
+
+      name
     end
 
-    transform_value(hash, ops)
+    key_ops, collection_ops = ops.partition { |op| ELEMENT_OPS.include?(op) }
+    transform_value(hash, key_ops, collection_ops, {}.compare_by_identity)
   end
 
   OPS.each do |operation|
@@ -48,28 +49,36 @@ class DeepHashTransformer
 
   def transform_collection(collection, ops)
     ops.inject(collection) do |c, op|
-      COLLECTION_OPS.include?(op) ? CollectionOperation.public_send(op, c) : c
+      CollectionOperation.public_send(op, c)
     end
   end
 
-  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
+  def transform_value(value, key_ops, collection_ops, ancestors)
+    return value unless value.is_a?(Array) || value.is_a?(Hash)
+
+    raise ArgumentError, "cyclic Hash/Array structure" if ancestors.key?(value)
 
-    transform_collection(collection, ops)
+    ancestors[value] = true
+    begin
+      collection = if value.is_a?(Array)
+        value.map { |e| transform_value(e, key_ops, collection_ops, ancestors) }
+      else
+        result = {}
+        value.each { |k, v| result[transform_key(k, key_ops)] = transform_value(v, key_ops, collection_ops, ancestors) }
+        result
+      end
+
+      transform_collection(collection, collection_ops)
+    ensure
+      ancestors.delete(value)
+    end
   end
 
   def transform_key(key, ops)
-    return key unless [String, Symbol].include?(key.class)
+    return key unless key.is_a?(String) || key.is_a?(Symbol)
 
     ops.inject(key) do |k, op|
-      ELEMENT_OPS.include?(op) ? ElementOperation.public_send(op, k) : k
+      ElementOperation.public_send(op, k)
     end
   end
 end

metadata

@@ -1,40 +1,39 @@
 --- !ruby/object:Gem::Specification
 name: deep_hash_transformer
 version: !ruby/object:Gem::Version
-  version: 2.2.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Martin Spickermann
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-25 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: "    DeepHashTransformer helps to transform keys in deeply nested hash
-  structures\n"
+description: "    Dependency-free key transformations and recursive cleanup for nested
+  hashes and arrays.\n"
 email:
 - spickermann@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - MIT-LICENSE
+- README.md
 - lib/deep_hash_transformer.rb
 - lib/deep_hash_transformer/blank.rb
 - lib/deep_hash_transformer/collection_operation.rb
 - lib/deep_hash_transformer/element_operation.rb
 - lib/deep_hash_transformer/version.rb
-- spec/deep_hash_transformer/blank_spec.rb
-- spec/deep_hash_transformer/collection_operation_spec.rb
-- spec/deep_hash_transformer/element_operation_spec.rb
-- spec/deep_hash_transformer_spec.rb
-- spec/spec_helper.rb
 homepage: https://github.com/spickermann/deep_hash_transformer
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
+  allowed_push_host: https://rubygems.org
+  source_code_uri: https://github.com/spickermann/deep_hash_transformer
+  changelog_uri: https://github.com/spickermann/deep_hash_transformer/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/spickermann/deep_hash_transformer/issues
 rdoc_options: []
 require_paths:
 - lib
@@ -49,8 +48,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key:
+rubygems_version: 4.0.20
 specification_version: 4
-summary: Transforms deeply nested hash structure
+summary: Transforms keys and cleans deeply nested hashes and arrays
 test_files: []

data/spec/deep_hash_transformer/blank_spec.rb

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

data/spec/deep_hash_transformer/collection_operation_spec.rb

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

data/spec/deep_hash_transformer/element_operation_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe DeepHashTransformer::ElementOperation 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::ELEMENT_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,128 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe DeepHashTransformer do
-  subject(:operation) { described_class.new(example) }
-
-  let(:example) { {foo: "bar"} }
-
-  describe "autogenerated methods" do
-    DeepHashTransformer::ELEMENT_OPS.each do |method|
-      describe ".#{method}" do
-        it "delegates to `Operation.#{method}`" do
-          expect(
-            DeepHashTransformer::ElementOperation
-          ).to receive(method).with(:foo).once # rubocop:disable RSpec/MessageSpies
-
-          operation.public_send(method)
-        end
-      end
-    end
-  end
-
-  describe "#tr" do
-    context "with `:snake_case, :symbolize`" do
-      subject { super().tr(:snake_case, :symbolize) }
-
-      let(:example) { {"FooBar" => "baz"} }
-
-      it { is_expected.to eq(foo_bar: "baz") }
-    end
-
-    context "with an unknown transformation" do
-      subject(:unknown_ops) { operation.tr(:unknown) }
-
-      it "raise an exception" do
-        expect { unknown_ops }.to raise_error(ArgumentError, /unknown/)
-      end
-    end
-
-    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 # 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
-
-    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: [""]}}
-      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" => [""]
-          }
-        )
-      end
-    end
-
-    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: [""]}}
-      end
-
-      it do # rubocop:disable RSpec/ExampleLength
-        is_expected.to eq( # rubocop:disable RSpec/ImplicitSubject
-          "a" => {
-            "b" => [:value],
-            "e" => true,
-            "g" => 123
-          }
-        )
-      end
-    end
-
-    context "with deeply nested blank values" do
-      subject { super().tr(:compact_blank) }
-
-      let(:example) do
-        {a: {b: [nil, {c: nil}]}}
-      end
-
-      it { is_expected.to eq({}) }
-    end
-  end
-
-  it "has a version number" do
-    expect(DeepHashTransformer::VERSION).not_to be_nil
-  end
-end

data/spec/spec_helper.rb

@@ -1,36 +0,0 @@
-# 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"
-
-SimpleCov.start do
-  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"
-    end
-
-    formatter SimpleCov::Formatter::MultiFormatter.new [
-      SimpleCov::Formatter::JSONFormatter, SimpleCov::Formatter::LcovFormatter
-    ]
-  end
-
-  add_filter %w[version.rb initializer.rb]
-end
-
-RSpec.configure do |config|
-  # Enable flags like --only-failures and --next-failure
-  config.example_status_persistence_file_path = ".rspec_status"
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-end