hashly 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7130cc1a7db063eb80ad86fb00490d0cd5e37324
-  data.tar.gz: 7ff720049720f1c1be26fe1bf1b2a8bf23b31610
+SHA256:
+  metadata.gz: 607087c6024a8f89cabb9f5a09a7c7a5079be000daa607ee6856466f4d6ca035
+  data.tar.gz: 5bb0089b7071bf71552613b29abf26afa5794036673c069013d2683db750e835
 SHA512:
-  metadata.gz: 221f421dc3ce0f67f815280d24b67207aa5b67d931df06215b897db8e4521ca7fe4887a1d7286e635ef981c7d114f2d436df1293fe4ab55c533bc1c9b4f0e066
-  data.tar.gz: d81c99065f2a3c54c5b155efd8d9ffa05770ebfd8bf9e843dd3aac38a641132ec8a1122dbe2b131a0c96bcda66b999d8e330811f73d9fed834785cb149af89d9
+  metadata.gz: 56fdc2ee4b1380646c1c15609db4b348a68ba5ae363f97ca452e76b81225763b5ccbdc0d57d4bb153bf6065a9cfb2b760e565d985cd4bacc5eeaa8e19851309f
+  data.tar.gz: 8ad8c31293c22582e2e3daee146c820bcbe6be6d9841dd7ec156a451b51a6d6d29fa9abba694024d8e3a923d74c28257500ddb5bdeb7d266b063cc4516611d09

data/lib/hashly/hashly.rb

@@ -1,12 +1,6 @@
 module Hashly
   module_function
 
-  def safe_value(hash, *keys)
-    return nil if hash.nil? || hash[keys.first].nil?
-    return hash[keys.first] if keys.length == 1 # return the value if we have reached the final key
-    safe_value(hash[keys.shift], *keys) # recurse until we have reached the final key
-  end
-
   def stringify_all_keys(hash)
     stringified_hash = {}
     hash.each do |k, v|
@@ -54,30 +48,37 @@ module Hashly
   # Returns:
   #   Hash with the merged data.
   # Parameters:
-  #   boolean_or: use a boolean || operator on the base and override if they are not a Hash or Array instead of stomping with the override
+  #   boolean_or: use a boolean || operator on the base and override if they are not a Hash or Array instead of stomping with the override.
   #   left_outer_join_depth: Only merge keys that already exist in the base for the first X levels specified.
-  def deep_merge(base, override, boolean_or: false, left_outer_join_depth: 0)
+  #   modify_by_reference: Hashes will be modified by reference which will modify the actual parameters.
+  #   selected_overrides: Allows for specifying a regex or value(s) that should ONLY be merged into the base Hash.
+  #   excluded_overrides: Allows for specifying a regex or value(s) that should NOT be merged into the base Hash.
+  def deep_merge(base, override, boolean_or: false, left_outer_join_depth: 0, modify_by_reference: false, selected_overrides: [], excluded_overrides: [])
     left_outer_join_depth -= 1 # decrement left_outer_join_depth for recursion
+    return base if reject_value?(override, excluded_overrides)
+    return base unless select_value?(override, selected_overrides)
     if base.nil?
       return nil if left_outer_join_depth >= 0
-      return override.is_a?(::Hash) ? override.dup : override
+      return modify_by_reference || !override.is_a?(::Hash) ? override : override.dup
     end
 
     case override
     when nil
-      base = base.dup if base.is_a?(::Hash) # duplicate hash to avoid modification by reference issues
+      base = base.dup unless modify_by_reference || !base.is_a?(::Hash) # duplicate hash to avoid modification by reference issues
       base # if override doesn't exist, simply return the existing value
     when ::Hash
-      base = base.dup
+      return override unless base.is_a?(::Hash)
+      base = base.dup unless modify_by_reference || !base.is_a?(::Hash)
       override.each do |src_key, src_value|
         next if base[src_key].nil? && left_outer_join_depth >= 0 # if this is a left outer join and the key does not exist in the base, skip it
-        base[src_key] = base[src_key] ? deep_merge(base[src_key], src_value, boolean_or: boolean_or, left_outer_join_depth: left_outer_join_depth) : src_value # Recurse if both are Hash
+        base[src_key] = base[src_key] ? deep_merge(base[src_key], src_value, boolean_or: boolean_or, left_outer_join_depth: left_outer_join_depth, selected_overrides: selected_overrides, excluded_overrides: excluded_overrides) : src_value # Recurse if both are Hash
       end
       base
     when ::Array
+      return override unless base.is_a?(::Array)
       base |= override
       base
-    when ::String, ::Integer, ::Time, ::TrueClass, ::FalseClass
+    when ::String, ::Integer, ::Time, ::TrueClass, ::FalseClass, ::Symbol
       boolean_or ? base || override : override
     else
       throw "Implementation for deep merge of type #{override.class} is missing."
@@ -102,8 +103,9 @@ module Hashly
   # For a hash, returns keys found in both hashes where the values don't match.
   # If a key exists in the base, but NOT the comparison, it is NOT considered a difference so that it can be a one way comparison.
   # For an array, returns an array with values found in the comparison array but not in the base array.
-  def deep_diff(base, comparison)
+  def deep_diff(base, comparison, existing_keys_only: false)
     if base.nil? # if base is nil, entire comparison object is different
+      return {} if comparison.nil?
       return comparison.is_a?(Hash) ? comparison.dup : comparison
     end
 
@@ -114,11 +116,13 @@ module Hashly
       differing_values = {}
       base = base.dup
       comparison.each do |src_key, src_value|
-        difference = deep_diff(base[src_key], src_value)
+        next if existing_keys_only && base.is_a?(::Hash) && !base.keys.include?(src_key)
+        difference = deep_diff(base[src_key], src_value, existing_keys_only: existing_keys_only)
         differing_values[src_key] = difference unless difference == :no_diff
       end
       differing_values.reject { |_k, v| v.is_a?(::Hash) && v.empty? }
     when ::Array
+      return comparison unless base.is_a?(::Array)
       difference = comparison - base
       difference.empty? ? :no_diff : difference
     else
@@ -134,6 +138,19 @@ module Hashly
     end
   end
 
+  # Reject hash keys however deep they are. Provide a block and if it evaluates to true for a given key/value pair, it will be rejected.
+  def deep_select(hash, &block)
+    hash.each_with_object({}) do |(k, v), h|
+      if v.is_a?(::Hash)
+        h[k] = deep_select(v, &block)
+        h.delete(k) if h[k].is_a?(::Hash) && h[k].empty?
+        next
+      end
+      next unless yield(k, v) # skip the current key/value pair unless the block given evaluates to true
+      h[k] = v
+    end
+  end
+
   # Deep diff two Hashes
   # Remove any keys in the first hash also contained in the second hash
   # If a key exists in the base, but NOT the comparison, it is kept.
@@ -157,4 +174,42 @@ module Hashly
   def reject_keys_with_nil_values(base)
     deep_reject(base) { |_k, v| v.nil? }
   end
+
+  def safe_value(hash, *keys)
+    return nil if hash.nil? || hash[keys.first].nil?
+    return hash[keys.first] if keys.length == 1 # return the value if we have reached the final key
+    safe_value(hash[keys.shift], *keys) # recurse until we have reached the final key
+  end
+
+  def reject_value?(value, rejected_values)
+    return false if rejected_values == :disabled
+
+    rejected_values = [rejected_values] if rejected_values.is_a?(String) || !rejected_values.is_a?(::Array)
+    rejected_values.each do |rejected_value|
+      case rejected_value
+      when Regexp
+        next if value.is_a?(::Hash) || value.is_a?(::Array) # Don't evaluate regexp on Hash or Array
+        return true if (value.to_s =~ rejected_value) == 0
+      else
+        return true if value == rejected_value
+      end
+    end
+    false
+  end
+
+  def select_value?(value, selected_values)
+    return true if selected_values == :disabled || selected_values.nil? || selected_values.empty?
+
+    selected_values = [selected_values] if selected_values.is_a?(String) || !selected_values.is_a?(::Array)
+    selected_values.each do |selected_value|
+      case selected_value
+      when Regexp
+        next if value.is_a?(::Hash) || value.is_a?(::Array) # Don't evaluate regexp on Hash or Array
+        return true if (value.to_s =~ selected_value) == 0
+      else
+        return true if value == selected_value
+      end
+    end
+    false
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hashly
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Alex Munoz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-27 00:00:00.000000000 Z
+date: 2021-07-26 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -39,8 +39,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Ruby library for ease of merging nested hashes recursively, diffing hashes,