hash_miner 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47cc3f1132fb53760a709194961033a327634cda3d5b5f32583cb8ab8af1cc61
-  data.tar.gz: 192a1594d31a7565aaa0d1bfc0835a29b2cdf57326c131bd6756aa58901fc5d8
+  metadata.gz: 914562162950918230de98d58303185f43568f78dfca068bc2f7209f4f96ae2b
+  data.tar.gz: 80e88d5b6d61b41e7aafb12fddf796c9eba40667895fc0cb8e62610e0160e04b
 SHA512:
-  metadata.gz: 2dde32d4292f9f66374cac7c048ec5373537bfc4b988a563202aa824a394a6b7e3b0b6af057eda8e9c481aac93910b9a188714e6e2e77760c57debdd1fd98335
-  data.tar.gz: 05354d5f27da7d4d0a6f0de3c58315929193596f9a08d651e83f352df6b9f3573070016bb8e84fb64eaa2ebf8395e97c4689fbf69d38476044ed991b17297233
+  metadata.gz: 52d4ae8b09bc42cccb5b3fd98180a100074292a98d4b0a0437d62f776e436b69b93c487f15524323995452c1a96b9a214e071bb9735dddfcfff0da251c6b2ed1
+  data.tar.gz: c5af637056ca8c4950846fc497ecac8f34270425f176a2850da0002cebeddbc09c71ed601d381f4e5feb5012bfad84d27db116ce8ab11a3b9413da4e335291f9

data/.rubocop.yml

@@ -21,7 +21,7 @@ Metrics/BlockLength:
   Enabled: false
 
 Metrics/ClassLength:
-  Max: 120
+  Max: 250
 
 Metrics/MethodLength:
   Max: 40

data/README.md

@@ -64,6 +64,9 @@ nasty_hash.deep_update(key: :pretty, value: :super_duper, error_on_uniqueness: f
 nasty_hash.deep_update(key: :huh, value: :where_am_i) # => throws KeyNotFoundError
 nasty_hash.deep_update(key: :pretty, value: :super_duper, error_on_missing: false) # => {:my=>{:pretty=>[{:nasty=>:hash}, nil], :is=>{:pretty=>:nasty}}, :huh=>:where_am_i}
 
+# Pass through parent flag for scoping
+nasty_hash.deep_update(key: :pretty, value: :super_duper, error_on_uniqueness: false, parent: :is) # => {:my=>{:pretty=>[{:nasty=>:hash}, nil], :is=>{:pretty=>:super_duper}}}
+
 ```
 ---
 #### deep_remove
@@ -80,6 +83,9 @@ nasty_hash.deep_remove(key: :nasty) # => {:my=>{:pretty=>[{}, nil], :is=>{:prett
 # Errors on uniqueness
 nasty_hash.deep_remove(key: :pretty) # => throws KeyNotUniqueError
 nasty_hash.deep_remove(key: :pretty, error_on_uniqueness: false) # => {:my=>{:is=>{}}}
+
+# Pass through parent flag for scoping
+nasty_hash.deep_remove(key: :pretty, error_on_uniqueness: false, parent: :is) # => { my: { pretty: [{ nasty: :hash }, nil], is: { } } }
 ```
 ---
 #### deep_find
@@ -93,6 +99,9 @@ nasty_hash = { my: { pretty: [{ nasty: :hash }, nil], is: { pretty: :nasty } } }
 
 nasty_hash.deep_find(key: :nasty) # => [:hash]
 nasty_hash.deep_find(key: :pretty) # => [{:nasty=>:hash}, nil, :nasty]
+
+# Pass through parent flag for scoping
+nasty_hash.deep_find(key: :pretty, parent: :is) # => [:nasty]
 ```
 ---
 #### deep_compact
@@ -131,6 +140,26 @@ nasty_hash.deep_contains?(key: :nasty) # => true
 nasty_hash.deep_contains?(key: :super_nasty) # => false
 ```
 
+### Scoping
+HashMiner supports partial updating of a hash based on the parent key.
+
+Supported methods: 
+- `deep_find`
+- `deep_update`
+- `deep_remove`
+
+Pass through a `parent` key to any of these methods as either an `Array`|`String`|`Symbol` 
+
+```ruby
+require 'hash_miner'
+
+nasty_hash = { my: { pretty: [{ nasty: :hash }, nil], is: { pretty: :nasty } } }
+
+nasty_hash.deep_find(key: :pretty, parent: :is) # => [:nasty]
+nasty_hash.deep_find(key: :pretty, parent: [:is]) # => [:nasty]
+nasty_hash.deep_find(key: :pretty, parent: [:my, :is]) # => [{:nasty=>:hash}, nil, :nasty]
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/hash_miner/hash.rb

@@ -50,21 +50,14 @@ class Hash
   #
   # @param key [String, Symbol]
   # @param hash [Hash]
+  # @param parent [String, Symbol, Array]
   #
   # @return [Array] with all values that match the key
-  def deep_find(key:, hash: self)
+  def deep_find(key:, hash: self, parent: nil)
     return nil unless hash.is_a? Hash
     return nil unless hash.deep_contains?(key: key)
 
-    hash.filter_map do |k, v|
-      if k.eql? key
-        v
-      elsif v.is_a?(Hash)
-        deep_find(hash: v, key: key)
-      elsif v.is_a?(Array)
-        [v.filter_map { |i| deep_find(hash: i, key: key) }]
-      end
-    end.flatten
+    parent ? deep_find_parent_logic(hash: self, key: key, parent: parent) : deep_find_logic(hash: self, key: key)
   end
 
   # Removed nil/empty from Hash
@@ -95,9 +88,10 @@ class Hash
   # @param value [String] the value to be set
   # @param error_on_missing [Boolean] error if key missing
   # @param error_on_uniqueness [Boolean] error if key not unique
+  # @param parent [String, Symbol, Array] the parent key for the key you want to update
   #
   # @return [Hash] the object with specified key updated.
-  def deep_update(key:, value:, error_on_missing: true, error_on_uniqueness: true)
+  def deep_update(key:, value:, error_on_missing: true, error_on_uniqueness: true, parent: nil)
     return self unless is_a? Hash
 
     if error_on_uniqueness && (deep_count(key: key) > 1)
@@ -117,15 +111,42 @@ class Hash
       return hash
     end
 
-    to_h do |k, v|
+    if parent
+      deep_update_parent_flow(hash: self, key: key, value: value, parent: parent)
+    else
+      deep_update_logic(hash: self, key: key, value: value)
+    end
+  end
+
+  # Removes specified key from nested hash.
+  #
+  # @param key [String] the key to remove.
+  # @param error_on_uniqueness [Boolean] error if key not unique
+  # @param parent [String, Symbol, Array] the parent key for the key you want to update
+  #
+  # @return [Hash] the object with specified key removed.
+  def deep_remove(key:, error_on_uniqueness: true, parent: nil)
+    return self unless is_a? Hash
+
+    if error_on_uniqueness && (deep_count(key: key) > 1)
+      raise KeyNotUniqueError, "Key: '#{key}' not unique | Pass 'error_on_uniqueness: false' if you do not care"
+    end
+
+    parent ? deep_remove_logic_parent(hash: self, key: key, parent: parent) : deep_remove_logic(hash: self, key: key)
+  end
+
+  private
+
+  def deep_update_logic(hash:, key:, value:)
+    hash.to_h do |k, v|
       if k.eql?(key)
         [k, value]
       elsif v.is_a?(Hash) && v.deep_contains?(key: key)
-        [k, v.deep_update(key: key, value: value, error_on_missing: error_on_missing, error_on_uniqueness: error_on_uniqueness)]
+        [k, deep_update_logic(key: key, value: value, hash: v)]
       elsif v.is_a?(Array)
         [k, v.map do |item|
           if item.is_a?(Hash) && item.deep_contains?(key: key)
-            item.deep_update(key: key, value: value, error_on_missing: error_on_missing, error_on_uniqueness: error_on_uniqueness)
+            deep_update_logic(key: key, value: value, hash: item)
           else
             item
           end
@@ -136,28 +157,50 @@ class Hash
     end
   end
 
-  # Removes specified key from nested hash.
-  #
-  # @param key [String] the key to remove.
-  #
-  # @return [Hash] the object with specified key removed.
-  def deep_remove(key:, error_on_uniqueness: true)
-    return self unless is_a? Hash
-
-    if error_on_uniqueness && (deep_count(key: key) > 1)
-      raise KeyNotUniqueError, "Key: '#{key}' not unique | Pass 'error_on_uniqueness: false' if you do not care"
+  def deep_update_parent_flow(hash:, key:, value:, parent:)
+    hash.to_h do |k, v|
+      if (parent.is_a?(Array) && parent.include?(k)) || parent.eql?(k)
+        case v
+        when Hash
+          [k, deep_update_logic(hash: v, key: key, value: value)]
+        when Array
+          [k, v.map do |item|
+            if item.is_a?(Hash) && item.deep_contains?(key: key)
+              deep_update_logic(key: key, value: value, hash: item)
+            else
+              item
+            end
+          end]
+        else
+          [k, v]
+        end
+      elsif v.is_a?(Hash) && v.deep_contains?(key: key)
+        [k, deep_update_parent_flow(hash: v, key: key, value: value, parent: parent)]
+      elsif v.is_a?(Array)
+        [k, v.map do |item|
+          if item.is_a?(Hash) && item.deep_contains?(key: key)
+            deep_update_parent_flow(hash: item, key: key, value: value, parent: parent)
+          else
+            item
+          end
+        end]
+      else
+        [k, v]
+      end
     end
+  end
 
+  def deep_remove_logic(hash:, key:)
     # filter_map removes nil from Array
-    filter_map do |k, v|
+    hash.filter_map do |k, v|
       if k.eql? key
         nil
-      elsif v.is_a?(Hash)
-        [k, v.deep_remove(key: key, error_on_uniqueness: error_on_uniqueness)]
+      elsif v.is_a?(Hash) && v.deep_contains?(key: key)
+        [k, deep_remove_logic(key: key, hash: v)]
       elsif v.is_a?(Array)
         [k, v.map do |item|
           if item.is_a?(Hash) && item.deep_contains?(key: key)
-            item.deep_remove(key: key, error_on_uniqueness: error_on_uniqueness)
+            deep_remove_logic(key: key, hash: item)
           else
             item
           end
@@ -167,4 +210,72 @@ class Hash
       end
     end.to_h
   end
+
+  def deep_remove_logic_parent(hash:, key:, parent:)
+    hash.filter_map do |k, v|
+      if (parent.is_a?(Array) && parent.include?(k)) || parent.eql?(k)
+        case v
+        when Hash
+          [k, deep_remove_logic(key: key, hash: v)]
+        when Array
+          [k, v.map do |item|
+            if item.is_a?(Hash) && item.deep_contains?(key: key)
+              deep_remove_logic(key: key, hash: item)
+            else
+              item
+            end
+          end]
+        else
+          [k, v]
+        end
+      elsif v.is_a?(Hash) && v.deep_contains?(key: key)
+        [k, deep_remove_logic_parent(hash: v, key: key, parent: parent)]
+      elsif v.is_a?(Array)
+        [k, v.map do |item|
+          if item.is_a?(Hash) && item.deep_contains?(key: key)
+            deep_remove_logic_parent(hash: item, key: key, parent: parent)
+          else
+            item
+          end
+        end]
+      else
+        [k, v]
+      end
+    end.to_h
+  end
+
+  def deep_find_logic(hash:, key:)
+    hash.filter_map do |k, v|
+      if k.eql? key
+        v
+      elsif v.is_a?(Hash)
+        deep_find_logic(hash: v, key: key)
+      elsif v.is_a?(Array)
+        [v.filter_map do |item|
+          deep_find_logic(hash: i, key: key) if item.is_a?(Hash) && item.deep_contains?(key: key)
+        end]
+      end
+    end.flatten
+  end
+
+  def deep_find_parent_logic(hash:, key:, parent:)
+    hash.filter_map do |k, v|
+      if (parent.is_a?(Array) && parent.include?(k)) || parent.eql?(k)
+        case v
+        when Hash
+          deep_find_logic(key: key, hash: v)
+        when Array
+          [v.filter_map do |item|
+            deep_find_logic(key: key, hash: item) if item.is_a?(Hash) && item.deep_contains?(key: key)
+          end]
+        end
+      elsif v.is_a?(Hash) && v.deep_contains?(key: key)
+        deep_find_parent_logic(hash: v, key: key, parent: parent)
+      elsif v.is_a?(Array)
+        [v.filter_map do |item|
+          deep_find_parent_logic(hash: item, key: key, parent: parent) if item.is_a?(Hash) && item.deep_contains?(key: key)
+        end]
+      end
+    end.flatten
+  end
 end

data/lib/hash_miner/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HashMiner
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/lib/hash_miner.rb

@@ -7,8 +7,10 @@ require_relative 'hash_miner/errors'
 require 'pry'
 require 'logger'
 
+# HashMiner gem
 module HashMiner
   class Error < StandardError; end
 
   LOG = Logger.new($stdout)
+  LOG.formatter = proc { |severity, datetime, _progname, msg| "[#{datetime}  #{severity}  HashMiner] -- #{msg}\n" }
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hash_miner
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - alexo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-07-05 00:00:00.000000000 Z
+date: 2022-07-15 00:00:00.000000000 Z
 dependencies: []
 description: Additional Hash methods to help navigate the tricky world of nested Hashes.
 email: