deeply_enumerable 1.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f9655518ad0bb3d8c2d3eb6616c2d9862e439d4b0ab4b45be6752b18628ecb1
-  data.tar.gz: 280db3869191e9c9fb318baed1b99b6ebc3f90ff24c16993523fe47eceff26fb
+  metadata.gz: c47df8d3946c3b010f0af6c185ebd93a0bcf7cbb4007ddbd89d3105496dcb78c
+  data.tar.gz: 9c8e54ca07f94145a0efd58b5f3dab64760d4d58244b12cb520946ee0d206ee1
 SHA512:
-  metadata.gz: 6939a317d815e1c0d6cfdc65f75f506cb549978b8338ef4f604086cb5efe7b4959d3ab3112691d068fa8f28082cb6753d3ae9177c5909ec56e0dd537c9c557b5
-  data.tar.gz: 3d07a34bb72ed5c3f37ce106daf0c30eef47d46af22e29e3278cfcefbbafdd607db395abbb38b4b34531aceaef9af8c46a29d37587b170703dc4aafb17edafd6
+  metadata.gz: e413f4cb0fac8f72c728126fb62e0f5ade142add7aede779c25de83051e41c9d38d6ff84f9b093ef472c5edb789db02d4f82dc77582d621265faaa63d5d01a40
+  data.tar.gz: 9008c5e856de8a746c6be66664c59e02af8c948377bc55fde22a99628c63753e8a8601f07de1ec127eaf327f3ee28c090ca0410d363c8af1dece5a3c82b3469c

data/CHANGELOG.md

@@ -0,0 +1,80 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [2.0.0] - 2026-06-17
+
+This is a **major, breaking release**. The argument-based `#deep_compact` API has
+been replaced with four clearly-named methods, and "blank" now matches Rails'
+`#compact_blank` semantics.
+
+### Breaking
+
+- **`#deep_compact` changed meaning.** In v1, bare `deep_compact` defaulted to the
+  *most aggressive* behavior. In v2 it removes **only `nil`** (matching Ruby's
+  `#compact`). If you relied on the old default, switch to `#deep_compact_blank`.
+- **The boolean arguments are gone.** `deep_compact(remove_emptied_elements,
+  remove_empty_elements)` is replaced by four dedicated methods (see Added).
+- **"Blank" now means `blank?`, not just empty.** The `_blank` family now also
+  removes `false` and blank strings (`""`, `" "`), in addition to `nil` and empty
+  collections — matching Rails' `#compact_blank`.
+- **A Hash's `default`/`default_proc` is no longer preserved through compaction.**
+  v1 mutated a `dup` (which carried the proc); v2 builds a fresh `Hash`, which has
+  none. This matches `Hash#reject` and Rails' `#compact_blank`, but can silently
+  break code relying on auto-vivification after compaction (e.g. an accumulator
+  `Hash.new { |h, k| h[k] = [] }`). Apply the default proc to the compacted
+  *result* rather than before compacting.
+
+### Added
+
+- Four named compaction methods, each with an in-place `!` variant, available as
+  instance methods, class methods, and (via `require: "base_extensions"`) directly
+  on core `Hash`/`Array`:
+  - `#deep_compact` — removes `nil` only.
+  - `#deep_compact_existing_blank` — removes `nil` and values that are already
+    blank; keeps collections that only become blank through compaction.
+  - `#deep_compact_blanked` — removes `nil` and collections emptied by compaction;
+    keeps values that were already blank.
+  - `#deep_compact_blank` — removes every blank value.
+- GitHub Actions CI running RSpec on Ruby 3.3, 3.4, and 4.0.
+- A real, comprehensive test suite (43 examples) replacing the previous
+  placeholder specs.
+
+### Changed
+
+- Rewrote the internals around a single recursive engine, with doc comments
+  linking each method to the Ruby/Rails source it mirrors. Blankness is determined
+  by an internal equivalent of ActiveSupport's `Object#blank?`, so the gem still
+  has **no ActiveSupport dependency**.
+- `base_extensions` now mixes into `Hash`/`Array` the same way ActiveSupport does
+  (reopening the class).
+- `rake` now runs the RSpec suite (`rake` / `rake spec`); dropped the unused
+  Minitest and RDoc tasks.
+- Expanded the README with a semantics table, worked examples, and an
+  "Upgrading from v1" guide.
+
+### Fixed
+
+- Fixed a latent bug in `#reverse_deep_merge!` (`ebuild` → `rebuild`) that was
+  hidden by placeholder specs.
+
+### Upgrading from v1
+
+| v1 call | v2 equivalent |
+| --- | --- |
+| `deep_compact` / `deep_compact(true, true)` | `deep_compact_blank` |
+| `deep_compact(true, false)` | `deep_compact_blanked` |
+| `deep_compact(false, true)` | `deep_compact_existing_blank` |
+| `deep_compact(false, false)` | `deep_compact` |
+
+## [1.0.0] - 2023-01-18
+
+- Initial release: recursive `#deep_compact` (with `remove_emptied_elements` /
+  `remove_empty_elements` flags) and `#reverse_deep_merge` for nested `Hash` and
+  `Array` objects.
+
+[2.0.0]: https://github.com/chaunce/deeply_enumerable/compare/1.0.0...2.0.0
+[1.0.0]: https://github.com/chaunce/deeply_enumerable/releases/tag/1.0.0

data/README.md

@@ -1,37 +1,110 @@
 # DeeplyEnumerable
-Extend Enumerable objects with recursive methods
+Extend `Enumerable` objects with recursive versions of common operations.
+
+`DeeplyEnumerable` walks a nested structure of `Hash` and `Array` objects and
+applies an operation at every level. Nested `Enumerable` objects are converted
+into `DeeplyEnumerable` types during the operation so the recursion can continue
+all the way down.
+
+## Compaction
+Ruby's `#compact` removes `nil`. Rails' `#compact_blank` removes anything that is
+`blank?` (`nil`, `false`, `""`, `" "`, `[]`, `{}`). `DeeplyEnumerable` provides
+recursive versions of both, plus two methods in between for finer control over
+*which* blanks are removed:
+
+| Method | Removes | Keeps |
+| --- | --- | --- |
+| `#deep_compact` | `nil` only | every other value, including `""`, `false`, `[]`, `{}` |
+| `#deep_compact_existing_blank` | `nil` and values that are **already** blank | collections that only become blank through compaction |
+| `#deep_compact_blanked` | `nil` and collections **emptied** by compaction | values that were already blank |
+| `#deep_compact_blank` | every blank value | nothing blank |
+
+The distinction between "existing" and "emptied" blanks matters once nesting is
+involved. Consider `{ a: { b: nil }, c: [] }`:
+
+* `a` holds `{ b: nil }`, which is *not* blank until its `nil` is removed — an
+  **emptied** blank.
+* `c` holds `[]`, which is blank in the input — an **existing** blank.
 
-## Usage
-Provides the following methods
 ```ruby
-$ DeeplyEnumerable::Hash#reverse_deep_merge(DeeplyEnumerable::Hash)
-$ DeeplyEnumerable::Hash#reverse_deep_merge!(DeeplyEnumerable::Hash)
-$ DeeplyEnumerable::Hash#deep_compact
-$ DeeplyEnumerable::Hash#deep_compact!
+source = { a: :b, c: nil, d: { e: nil, f: [] }, g: [1, nil], h: {}, i: "", j: [nil] }
 
-$ DeeplyEnumerable::Array#deep_compact
-$ DeeplyEnumerable::Array#deep_compact!
+DeeplyEnumerable::Hash.deep_compact(source)
+# => { a: :b, d: { f: [] }, g: [1], h: {}, i: "", j: [] }   # only nils removed
+
+DeeplyEnumerable::Hash.deep_compact_existing_blank(source)
+# => { a: :b, d: {}, g: [1], j: [] }                        # pre-existing [], {} and "" removed; emptied kept
+
+DeeplyEnumerable::Hash.deep_compact_blanked(source)
+# => { a: :b, d: { f: [] }, g: [1], h: {}, i: "" }          # emptied collections removed; pre-existing blanks kept
+
+DeeplyEnumerable::Hash.deep_compact_blank(source)
+# => { a: :b, g: [1] }                                      # every blank removed
 ```
 
-Nested `Enumerable` objects will be converted into `DeeplyEnumerable` type objects during merge or compact operations to allow recursive method calls
+Each method has an in-place `!` variant (`#deep_compact!`, `#deep_compact_blank!`,
+etc.) that mutates the receiver and returns it, mirroring `#compact!`.
 
-Class methods may be used for base ruby enumerable objects, such as `Hash` or `Array` objects
+## Merging
 ```ruby
-$ DeeplyEnumerable::Hash.deep_compact(Hash)
-$ DeeplyEnumerable::Array.deep_compact(Array)
+DeeplyEnumerable::Hash#reverse_deep_merge(other_hash)   # recursively fill in only the missing keys
+DeeplyEnumerable::Hash#reverse_deep_merge!(other_hash)  # in place
 ```
+`#deep_reverse_merge` / `#deep_reverse_merge!` are aliases.
+
+## Usage
+Call a class method to operate on a plain `Hash` or `Array`. The result is the
+matching `DeeplyEnumerable` type (`Hash` returns a `DeeplyEnumerable::Hash`,
+`Array` returns a `DeeplyEnumerable::Array`):
+```ruby
+DeeplyEnumerable::Hash.deep_compact_blank({ a: 1, b: nil, c: { d: nil } })
+# => { a: 1 }
+
+DeeplyEnumerable::Array.deep_compact([1, nil, [2, nil]])
+# => [1, [2]]
+```
+
+Or extend the base `Hash` and `Array` classes (see *Installation*) and call the
+methods directly:
+```ruby
+{ a: 1, b: nil }.deep_compact_blank   # => { a: 1 }
+[1, nil, [nil]].deep_compact          # => [1, []]
+```
+
+## Upgrading from v1
+v2 replaces the boolean arguments of `#deep_compact` with four named methods.
+Map your old calls as follows:
+
+| v1 call | v2 equivalent |
+| --- | --- |
+| `deep_compact` / `deep_compact(true, true)` | `deep_compact_blank` |
+| `deep_compact(true, false)` | `deep_compact_blanked` |
+| `deep_compact(false, true)` | `deep_compact_existing_blank` |
+| `deep_compact(false, false)` | `deep_compact` |
+
+⚠️ **`#deep_compact` changed meaning.** In v1, bare `deep_compact` defaulted to
+the *most aggressive* behavior. In v2, `#deep_compact` removes **only nils**
+(matching Ruby's `#compact`). If you relied on the old default, switch to
+`#deep_compact_blank`.
+
+⚠️ **Blank now means `blank?`, not just empty.** v1 only ever removed `nil` and
+empty collections (`[]`, `{}`). The v2 `_blank` family also removes `false` and
+blank strings (`""`, `" "`), matching Rails' `#compact_blank`. Blankness is
+determined by an internal equivalent of ActiveSupport's `Object#blank?`, so the
+gem still has **no ActiveSupport dependency**.
 
-These methos will retrun a `DeeplyEnumerable` type object matching the object passed, e.g: `Array` will return a `DeeplyEnumerable::Array`
+⚠️ **`default`/`default_proc` is not preserved.** v2 returns a freshly-built
+`Hash`, so a default value or proc does not survive compaction (matching
+`Hash#reject` and Rails' `#compact_blank`). v1 happened to keep it because it
+mutated a `dup`. If you rely on auto-vivification, apply the default proc to the
+compacted *result* rather than before compacting:
 
-You may also extend base classes if you `require: "base_extensions"` as described in *Installation*
 ```ruby
-$ Hash#reverse_deep_merge(DeeplyEnumerable::Hash)
-$ Hash#reverse_deep_merge!(DeeplyEnumerable::Hash)
-$ Hash#deep_compact
-$ Hash#deep_compact!
+# Fragile — the proc is dropped by compaction:
+Hash.new { |h, k| h[k] = [] }.merge(value).deep_compact_blank
 
-$ Array#deep_compact
-$ Array#deep_compact!
+# Robust — compact first, then land the data in the proc-bearing Hash:
+Hash.new { |h, k| h[k] = [] }.merge(value.deep_compact_blank)
 ```
 
 ## Installation
@@ -40,14 +113,14 @@ Add this line to your application's Gemfile:
 gem "deeply_enumerable"
 ```
 
-or this line to extend the base `Enumerable` classes:
+or this line to mix the methods into the base `Hash` and `Array` classes:
 ```ruby
 gem "deeply_enumerable", require: "base_extensions"
 ```
 
 And then execute:
 ```bash
-$ bundle
+$ bundle install
 ```
 
 Or install it yourself as:

data/Rakefile

@@ -1,33 +1,6 @@
-begin
-  require "bundler/setup"
-rescue LoadError
-  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
-end
-
-require "rdoc/task"
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = "rdoc"
-  rdoc.title    = "DeeplyEnumerable"
-  rdoc.options << "--line-numbers"
-  rdoc.rdoc_files.include("README.md")
-  rdoc.rdoc_files.include("lib/**/*.rb")
-end
-
-
-
-
-
-
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 
-require "rake/testtask"
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.pattern = "test/**/*_test.rb"
-  t.verbose = false
-end
-
+RSpec::Core::RakeTask.new(:spec)
 
-task default: :test
+task default: :spec

data/lib/base_extensions.rb

@@ -1,4 +1,11 @@
 require "deeply_enumerable"
 
-Hash.send(:include, DeeplyEnumerable::HashExtension)
-Array.send(:include, DeeplyEnumerable::ArrayExtension)
+# Mirror the way Rails (ActiveSupport) mixes its enumerable extensions into the
+# core classes: reopen each class and include the corresponding module.
+class Hash
+  include DeeplyEnumerable::HashExtension
+end
+
+class Array
+  include DeeplyEnumerable::ArrayExtension
+end

data/lib/deeply_enumerable/array.rb

@@ -8,31 +8,63 @@ module DeeplyEnumerable
       end
     end
 
-    def deep_compact!(remove_emptied_elements = true, remove_empty_elements = remove_emptied_elements)
-      each.with_index do |value, index|
-        next if unenumerable_object?(value)
-
-        value = rebuild(value) unless value.respond_to?(:reverse_deep_merge)
-        compact_method = %i[deep_compact! deep_compact compact! compact].detect{ |m| value.respond_to?(m) }
-        next unless compact_method
-
-        original_empty = value.respond_to?(:empty?) ? value.empty? : value.respond_to?(:none?) ? value.none? : false
-        compact_value = value.send(*[compact_method].concat(value.method(compact_method).parameters.collect { |_,param| binding.local_variable_get(param) } ).compact) || value
-        compact_empty = compact_value.respond_to?(:empty?) ? compact_value.empty? : compact_value.respond_to?(:none?) ? compact_value.none? : false
-
-        if (original_empty && remove_empty_elements) || (!original_empty && compact_empty && remove_emptied_elements)
-          self.delete_at(index)
-        else
-          self[index] = compact_value
-        end
-      end
-      compact!
+    # Recursively removes nil elements, leaving every other element (including
+    # already-blank ones such as "", [] and {}) untouched. This is the
+    # recursive counterpart of Ruby's Array#compact.
+    # https://docs.ruby-lang.org/en/master/Array.html#method-i-compact
+    def deep_compact
+      deep_compact_each(false, false)
+    end
+
+    # In-place variant of #deep_compact, mirroring Array#compact!.
+    def deep_compact!
+      replace(deep_compact)
+    end
+
+    # Recursively removes nils and elements that are already blank, but keeps
+    # collections that only become blank as a result of compaction.
+    def deep_compact_existing_blank
+      deep_compact_each(false, true)
+    end
+
+    # In-place variant of #deep_compact_existing_blank.
+    def deep_compact_existing_blank!
+      replace(deep_compact_existing_blank)
+    end
 
-      self
+    # Recursively removes nils and collections that became blank through
+    # compaction, but keeps elements that were already blank.
+    def deep_compact_blanked
+      deep_compact_each(true, false)
     end
 
-    def deep_compact(remove_emptied_elements = true, remove_empty_elements = remove_emptied_elements)
-      dup.deep_compact!(remove_emptied_elements, remove_empty_elements)
+    # In-place variant of #deep_compact_blanked.
+    def deep_compact_blanked!
+      replace(deep_compact_blanked)
+    end
+
+    # Recursively removes every blank element (nil, false, "", " ", [], {}).
+    # This is the recursive counterpart of Rails' Array#compact_blank.
+    # https://github.com/rails/rails/blob/main/activesupport/lib/active_support/core_ext/enumerable.rb
+    def deep_compact_blank
+      deep_compact_each(true, true)
+    end
+
+    # In-place variant of #deep_compact_blank, mirroring Array#compact_blank!.
+    def deep_compact_blank!
+      replace(deep_compact_blank)
+    end
+
+    private
+
+    # Shared engine for the deep_compact family: rebuilds an array of the same
+    # class, recursively compacting each element and discarding the ones that
+    # should be removed for the given combination of flags.
+    def deep_compact_each(remove_emptied_elements, remove_empty_elements)
+      each_with_object(self.class.new) do |element, result|
+        keep, element = deep_compact_element(element, remove_emptied_elements, remove_empty_elements)
+        result.push(element) if keep
+      end
     end
   end
 

data/lib/deeply_enumerable/enumerable.rb

@@ -1,7 +1,13 @@
 module DeeplyEnumerable
   module Enumerable
+    # Collection-like objects that should be treated as opaque elements rather
+    # than recursed into during deep operations.
     UNENUMERABLE = ["ActiveRecord::Relation", "Range"]
 
+    # Whitespace-only strings are considered blank, mirroring ActiveSupport.
+    # https://github.com/rails/rails/blob/main/activesupport/lib/active_support/core_ext/object/blank.rb
+    BLANK_RE = /\A[[:space:]]*\z/
+
     def self.included(klass)
       klass.extend(ClassMethods)
     end
@@ -24,9 +30,28 @@ module DeeplyEnumerable
         new.tap { |deeply_enumerable_object| object.each { |value| deeply_enumerable_object.push(rebuild(value)) } }
       end
 
-      def deep_compact(object, remove_emptied_elements = true, remove_empty_elements = remove_emptied_elements)
-        check_object_class(object)
-        deep_rebuild(object).deep_compact(remove_emptied_elements, remove_empty_elements)
+      # Recursively removes nil values.
+      # Mirrors Ruby's Array#compact / Hash#compact.
+      def deep_compact(object)
+        deep_rebuild(object).deep_compact
+      end
+
+      # Recursively removes nils and values that are already blank, while
+      # keeping collections that only become blank as a result of compaction.
+      def deep_compact_existing_blank(object)
+        deep_rebuild(object).deep_compact_existing_blank
+      end
+
+      # Recursively removes nils and collections that became blank through
+      # compaction, while keeping values that were already blank.
+      def deep_compact_blanked(object)
+        deep_rebuild(object).deep_compact_blanked
+      end
+
+      # Recursively removes every blank value.
+      # Mirrors Rails' Enumerable#compact_blank.
+      def deep_compact_blank(object)
+        deep_rebuild(object).deep_compact_blank
       end
 
       def unenumerable
@@ -47,5 +72,42 @@ module DeeplyEnumerable
     def unenumerable_object?(object)
       self.class.unenumerable.any? { |unenumerable_klass| object.is_a?(unenumerable_klass) }
     end
+
+    private
+
+    # Decides what to do with a single element during deep compaction and
+    # returns [keep?, element], where +element+ may be a rebuilt/compacted
+    # copy.
+    #
+    # nil is always dropped. Nested enumerables are compacted recursively, then
+    # dropped if they were already blank (+remove_empty_elements+) or only
+    # became blank through compaction (+remove_emptied_elements+).
+    # Non-enumerable elements are dropped only when already blank and
+    # +remove_empty_elements+ is set.
+    def deep_compact_element(element, remove_emptied_elements, remove_empty_elements)
+      return [false, element] if element.nil?
+
+      element = rebuild(element) unless unenumerable_object?(element) || element.respond_to?(:deep_compact_each, true)
+
+      if !unenumerable_object?(element) && element.respond_to?(:deep_compact_each, true)
+        blank_before = deeply_blank?(element)
+        element = element.send(:deep_compact_each, remove_emptied_elements, remove_empty_elements)
+        keep = !((blank_before && remove_empty_elements) ||
+                 (!blank_before && remove_emptied_elements && deeply_blank?(element)))
+        [keep, element]
+      else
+        [!(remove_empty_elements && deeply_blank?(element)), element]
+      end
+    end
+
+    # Internal equivalent of ActiveSupport's Object#blank? (with
+    # String#blank?), implemented here so the gem needs no ActiveSupport
+    # dependency.
+    # https://github.com/rails/rails/blob/main/activesupport/lib/active_support/core_ext/object/blank.rb
+    def deeply_blank?(value)
+      return value.match?(BLANK_RE) if value.is_a?(::String)
+
+      value.respond_to?(:empty?) ? !!value.empty? : !value
+    end
   end
 end

data/lib/deeply_enumerable/hash.rb

@@ -13,7 +13,7 @@ module DeeplyEnumerable
         this_value = self[current_key]
 
         self[current_key] = if this_value.is_a?(::Hash) && other_value.is_a?(::Hash)
-          this_value = ebuild(this_value) unless this_value.respond_to?(:reverse_deep_merge)
+          this_value = rebuild(this_value) unless this_value.respond_to?(:reverse_deep_merge)
           this_value.reverse_deep_merge(other_value)
         else
           key?(current_key) ? this_value : other_value
@@ -29,27 +29,63 @@ module DeeplyEnumerable
     end
     alias_method :deep_reverse_merge, :reverse_deep_merge
 
-    def deep_compact!(remove_emptied_elements = true, remove_empty_elements = remove_emptied_elements)
-      each do |key, value|
-        next if unenumerable_object?(value)
+    # Recursively removes nil values, leaving every other value (including
+    # already-blank ones such as "", [] and {}) untouched. This is the
+    # recursive counterpart of Ruby's Hash#compact.
+    # https://docs.ruby-lang.org/en/master/Hash.html#method-i-compact
+    def deep_compact
+      deep_compact_each(false, false)
+    end
 
-        value = rebuild(value) unless value.respond_to?(:reverse_deep_merge)
-        compact_method = %i[deep_compact! deep_compact compact! compact].detect{ |m| value.respond_to?(m) }
-        next unless compact_method
+    # In-place variant of #deep_compact, mirroring Hash#compact!.
+    def deep_compact!
+      replace(deep_compact)
+    end
 
-        original_empty = value.respond_to?(:empty?) ? value.empty? : value.respond_to?(:none?) ? value.none? : false rescue false
-        compact_value = value.send(*[compact_method].concat(value.method(compact_method).parameters.collect { |_,param| binding.local_variable_get(param) } ).compact) || value
-        compact_empty = compact_value.respond_to?(:empty?) ? compact_value.empty? : compact_value.respond_to?(:none?) ? compact_value.none? : false
+    # Recursively removes nils and values that are already blank, but keeps
+    # collections that only become blank as a result of compaction.
+    def deep_compact_existing_blank
+      deep_compact_each(false, true)
+    end
 
-        self[key] = (original_empty && remove_empty_elements) || (!original_empty && compact_empty && remove_emptied_elements) ? nil : compact_value
-      end
-      compact!
+    # In-place variant of #deep_compact_existing_blank.
+    def deep_compact_existing_blank!
+      replace(deep_compact_existing_blank)
+    end
 
-      self
+    # Recursively removes nils and collections that became blank through
+    # compaction, but keeps values that were already blank.
+    def deep_compact_blanked
+      deep_compact_each(true, false)
+    end
+
+    # In-place variant of #deep_compact_blanked.
+    def deep_compact_blanked!
+      replace(deep_compact_blanked)
     end
 
-    def deep_compact(remove_emptied_elements = true, remove_empty_elements = remove_emptied_elements)
-      dup.deep_compact!(remove_emptied_elements, remove_empty_elements)
+    # Recursively removes every blank value (nil, false, "", " ", [], {}). This
+    # is the recursive counterpart of Rails' Hash#compact_blank.
+    # https://github.com/rails/rails/blob/main/activesupport/lib/active_support/core_ext/hash/keys.rb
+    def deep_compact_blank
+      deep_compact_each(true, true)
+    end
+
+    # In-place variant of #deep_compact_blank, mirroring Hash#compact_blank!.
+    def deep_compact_blank!
+      replace(deep_compact_blank)
+    end
+
+    private
+
+    # Shared engine for the deep_compact family: rebuilds a hash of the same
+    # class, recursively compacting each value and discarding the keys whose
+    # value should be removed for the given combination of flags.
+    def deep_compact_each(remove_emptied_elements, remove_empty_elements)
+      each_with_object(self.class.new) do |(key, value), result|
+        keep, value = deep_compact_element(value, remove_emptied_elements, remove_empty_elements)
+        result[key] = value if keep
+      end
     end
   end
 
@@ -70,5 +106,3 @@ module DeeplyEnumerable
     end
   end
 end
-
-

data/lib/deeply_enumerable/version.rb

@@ -1,3 +1,3 @@
 module DeeplyEnumerable
-  VERSION = "1.0.0"
+  VERSION = "2.0.1"
 end

metadata

@@ -1,15 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: deeply_enumerable
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - chaunce
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-19 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: 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: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -24,13 +37,14 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: recusrive support for enumerable operations
+description: recursive support for enumerable operations
 email:
 - chaunce.slc@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - MIT-LICENSE
 - README.md
 - Rakefile
@@ -43,8 +57,9 @@ files:
 homepage: https://github.com/chaunce/deeply_enumerable
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  source_code_uri: https://github.com/chaunce/deeply_enumerable
+  changelog_uri: https://github.com/chaunce/deeply_enumerable/blob/master/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -59,8 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.3
-signing_key:
+rubygems_version: 4.0.6
 specification_version: 4
-summary: recusrive support for enumerable operations
+summary: recursive support for enumerable operations
 test_files: []