nice_hash 1.15.2 → 1.15.3

data/lib/nice/hash/nice_filter.rb

@@ -0,0 +1,53 @@
+class NiceHash
+ 
+  ##################################################
+  #  Filter the hash supplied and returns only the specified keys
+  #
+  #  @param hash [Hash] The hash we want to filter
+  #  @param keys [Array] [Symbol] Array of symbols or symbol. Nested keys can be used: 'uno.dos.tres'
+  #
+  #  @return [Hash]
+  #
+  #  @example
+  #  my_hash = { user: {
+  #                      address: {
+  #                             city: 'Madrid',
+  #                             country: 'Spain'
+  #                          },
+  #                      name: 'Peter',
+  #                      age: 33,
+  #                      customers: [{name: 'Peter', currency: 'Euro'}, {name:'John', currency: 'Euro'}]
+  #                    },
+  #              customer: true
+  #  }
+  #    NiceHash.nice_filter(my_hash, [:'user.address.city', :'customer', :'user.customers.name'])
+  #    #> {:user => {:address => {:city => "Madrid"}, :customers => [{:name => "Peter"}, {:name => "John"}]}, :customer => true}
+  ##################################################
+  def self.nice_filter(hash, keys)
+    result = {}
+    keys = [keys] unless keys.is_a?(Array)
+    keys.each do |k|
+      kn = k.to_s.split('.')
+      if hash.is_a?(Hash) and hash.key?(k)
+          if hash[k].is_a?(Hash)
+              result[k] = {} unless result.key?(k)
+          else
+              result[k] = hash[k]
+          end
+      elsif hash.is_a?(Hash) and hash.key?(kn.first.to_sym)
+          keys_nested = []
+          keys.grep(/^#{kn.first}\./).each do |k2|
+            keys_nested << k2.to_s.gsub(/^#{kn.first}\./,'').to_sym
+          end
+          result[kn.first.to_sym] = nice_filter(hash[kn.first.to_sym], keys_nested)
+      elsif hash.is_a?(Array)
+          result = []
+          hash.each do |a|
+              res = nice_filter(a, keys)
+              result << res unless res.empty?
+          end
+      end
+    end
+    return result
+  end
+end

data/lib/nice/hash/pattern_fields.rb

@@ -0,0 +1,89 @@
+class NiceHash
+
+  ###########################################################################
+  # It will return an array of the keys where we are using string patterns.
+  #
+  # input:
+  #   pattern_hash: (Hash) Hash we want to get the pattern_fields
+  #   select_hash_key: (key value) (optional) The key we want to select on the subhashes
+  # output: (Array)
+  #   Array of the kind: [ [key], [key, subkey, subkey]  ]
+  #   Each value of the array can be used as parameter for the methods: dig, bury
+  # examples:
+  #   NiceHash.pattern_fields(my_hash)
+  #   #> [
+  #       [:address, :correct],
+  #       [:products, 0, :name],
+  #       [:products, 0, :price, :correct],
+  #       [:products, 1, :name],
+  #       [:products, 1, :price, :correct]
+  #      ]
+  #   NiceHash.pattern_fields(my_hash, :correct)
+  #   #> [
+  #       [:address],
+  #       [:products, 0, :name],
+  #       [:products, 0, :price],
+  #       [:products, 1, :name],
+  #       [:products, 1, :price]
+  #      ]
+  # Using it directly on Hash class, pattern_fields(*select_hash_key) (alias: patterns):
+  #   my_hash.pattern_fields
+  #   my_hash.pattern_fields(:correct)
+  #   my_hash.patterns(:correct)
+  ###########################################################################
+  def NiceHash.pattern_fields(pattern_hash, *select_hash_key)
+    pattern_fields = Array.new
+
+    if pattern_hash.kind_of?(Hash) and pattern_hash.size > 0
+      pattern_hash.each { |key, value|
+        key = [key]
+        if value.kind_of?(Hash)
+          if select_hash_key.size == 1 and value.keys.include?(select_hash_key[0])
+            value = value[select_hash_key[0]]
+          else
+            res = NiceHash.pattern_fields(value, *select_hash_key)
+            if res.size > 0
+              res.each { |r|
+                pattern_fields << (r.unshift(key)).flatten
+              }
+            end
+            next
+          end
+        end
+        if value.kind_of?(String)
+          if StringPattern.optimistic and value.to_s.scan(/^!?\d+-?\d*:.+/).size > 0
+            pattern_fields << key
+          end
+        elsif value.kind_of?(Symbol)
+          if value.to_s.scan(/^!?\d+-?\d*:.+/).size > 0
+            pattern_fields << key
+          end
+        elsif value.kind_of?(Array)
+          array_pattern = false
+          value.each { |v|
+            if (v.kind_of?(String) or v.kind_of?(Symbol)) and StringPattern.analyze(v, silent: true).kind_of?(StringPattern::Pattern)
+              pattern_fields << key
+              array_pattern = true
+              break
+            end
+          }
+          unless array_pattern
+            i = 0
+            value.each { |v|
+              res = NiceHash.pattern_fields(v, *select_hash_key)
+              if res.size > 0
+                res.each { |r|
+                  pattern_fields << (r.unshift(i).unshift(key)).flatten
+                }
+              end
+              i += 1
+            }
+          end
+        end
+      }
+    end
+
+    return pattern_fields
+  end
+    
+end

data/lib/nice/hash/select_fields.rb

@@ -0,0 +1,75 @@
+class NiceHash
+
+  ###########################################################################
+  # It will return an array of the keys where we are using select values of the kind: "value1|value2|value3".
+  #
+  # input:
+  #   pattern_hash: (Hash) Hash we want to get the select_fields
+  #   select_hash_key: (key value) (optional) The key we want to select on the subhashes
+  # output: (Array)
+  #   Array of the kind: [ [key], [key, subkey, subkey]  ]
+  #   Each value of the array can be used as parameter for the methods: dig, bury
+  # examples:
+  #   NiceHash.select_fields(my_hash)
+  #   #> [[:city, :correct]]
+  #   NiceHash.select_fields(my_hash, :correct)
+  #   #> [[:city]]
+  # Using it directly on Hash class, select_fields(*select_hash_key):
+  #   my_hash.select_fields
+  #   my_hash.select_fields(:correct)
+  ###########################################################################
+  def NiceHash.select_fields(pattern_hash, *select_hash_key)
+    select_fields = Array.new
+
+    if pattern_hash.kind_of?(Hash) and pattern_hash.size > 0
+      pattern_hash.each { |key, value|
+        key = [key]
+        if value.kind_of?(Hash)
+          if select_hash_key.size == 1 and value.keys.include?(select_hash_key[0])
+            value = value[select_hash_key[0]]
+          else
+            res = NiceHash.select_fields(value, *select_hash_key)
+            if res.size > 0
+              res.each { |r|
+                select_fields << (r.unshift(key)).flatten
+              }
+            end
+            next
+          end
+        end
+        if value.kind_of?(String)
+          if StringPattern.optimistic and value.to_s.scan(/^([\w\s\-]+\|)+[\w\s\-]+$/).size > 0
+            select_fields << key
+          end
+        elsif value.kind_of?(Symbol)
+          if value.to_s.scan(/^([\w\s\-]+\|)+[\w\s\-]+$/).size > 0
+            select_fields << key
+          end
+        elsif value.kind_of?(Array)
+          array_pattern = false
+          value.each { |v|
+            if (v.kind_of?(String) or v.kind_of?(Symbol)) and StringPattern.analyze(v, silent: true).kind_of?(StringPattern::Pattern)
+              array_pattern = true
+              break
+            end
+          }
+          unless array_pattern
+            i = 0
+            value.each { |v|
+              res = NiceHash.select_fields(v, *select_hash_key)
+              if res.size > 0
+                res.each { |r|
+                  select_fields << (r.unshift(i).unshift(key)).flatten
+                }
+              end
+              i += 1
+            }
+          end
+        end
+      }
+    end
+
+    return select_fields
+  end
+    
+end

data/lib/nice/hash/select_key.rb

@@ -0,0 +1,56 @@
+class NiceHash
+      ###########################################################################
+  # It will filter the hash by the key specified on select_hash_key.
+  # In case a subhash specified on a value it will be selected only the value of the key specified on select_hash_key
+  #
+  # input:
+  #   pattern_hash: (Hash) Hash we want to select specific keys
+  #   select_hash_key: (key value) The key we want to select on the subhashes
+  # output: (Hash)
+  #   The same hash but in case a subhash specified on a value it will be selected only the value of the key specified on select_hash_key
+  # example:
+  #   new_hash = NiceHash.select_key(my_hash, :wrong)
+  #   #> {:name=>"Peter", :address=>"\#$$$$$", :city=>"Germany", :products=> [{:name=>:"10:Ln", :price=>"-20"}, {:name=>:"10:Ln", :price=>"-20"}]}
+  # Using it directly on Hash class, select_key(select_hash_key):
+  #   new_hash = my_hash.select_key(:wrong)
+  ###########################################################################
+  def NiceHash.select_key(pattern_hash, select_hash_key)
+    hashv = Hash.new()
+
+    if pattern_hash.kind_of?(Hash) and pattern_hash.size > 0
+      pattern_hash.each { |key, value|
+        if value.kind_of?(Hash)
+          if value.keys.include?(select_hash_key)
+            value = value[select_hash_key]
+          else
+            value = NiceHash.select_key(value, select_hash_key)
+          end
+        end
+        if value.kind_of?(Array)
+          array_pattern = false
+          value.each { |v|
+            if (v.kind_of?(String) or v.kind_of?(Symbol)) and StringPattern.analyze(v, silent: true).kind_of?(StringPattern::Pattern)
+              hashv[key] = value
+              array_pattern = true
+              break
+            end
+          }
+          unless array_pattern
+            value_ret = Array.new
+            value.each { |v|
+              ret = NiceHash.select_key(v, select_hash_key)
+              value_ret << ret
+            }
+            hashv[key] = value_ret
+          end
+        else
+          hashv[key] = value
+        end
+      }
+    else
+      return pattern_hash
+    end
+    return hashv
+  end
+
+end

data/lib/nice/hash/set_nested.rb

@@ -0,0 +1,54 @@
+class NiceHash
+  ##################################################
+  #  sets the supplied value on the supplied nested key
+  #
+  #  @param hash [Hash] The hash we want
+  #  @param nested_key [Hash] [String] String with the nested key: 'uno.dos.tres' or a hash { uno: {dos: :tres} }
+  #  @param value [] value to set
+  #
+  #  @return [Hash]
+  #
+  #  @example
+  #  my_hash = { user: {
+  #                      address: {
+  #                             city: 'Madrid',
+  #                             country: 'Spain'
+  #                          },
+  #                      name: 'Peter',
+  #                      age: 33
+  #                    },
+  #              customer: true
+  #  }
+  #    NiceHash.set_nested(my_hash, 'user.address.city', 'Barcelona')
+  #    #>{:user=>{:address=>{:city=>'Barcelona', :country=>"Spain"}, :name=>"Peter", :age=>33}, :customer=>true}
+  ##################################################
+  def self.set_nested(hash, nested_key, value, only_if_exist = false)
+    nested_key = transtring(nested_key)
+    keys = nested_key.split(".")
+    if keys.size == 1
+      hash[nested_key.to_sym] = value unless only_if_exist and !hash.key?(nested_key.to_sym)
+    else
+      exist = true
+      if only_if_exist
+        ht = hash.deep_copy
+        keys.each do |k|
+          unless ht.key?(k.to_sym)
+            exist = false
+            break
+          end
+          ht = ht[k.to_sym]
+        end
+      end
+      if !only_if_exist or (only_if_exist and exist)
+        if value.is_a?(String)
+          eval("hash.#{nested_key}='#{value}'")
+        else
+          #todo: consider other kind of objects apart of strings
+          eval("hash.#{nested_key}=#{value}")
+        end
+      end
+    end
+    return hash
+  end
+ 
+end

data/lib/nice/hash/set_values.rb

@@ -0,0 +1,99 @@
+class NiceHash
+  ###########################################################################
+  # It will search for the keys supplied and it will set the value specified
+  #
+  # input:
+  #   hash_array: (Hash/Array) Hash/Array we want to search on
+  #   hash_values: (Hash) Hash that contains the keys and values to set
+  # output: (Hash/Array)
+  #   The same hash/array but with the values we specifed changed
+  # example:
+  #   new_hash = NiceHash.set_values(my_hash, {city: 'London', price: '1000'})
+  #   #> {:name=>"Peter", :address=>"\#$$$$$", :city=>"London", :products=> [{:name=>:"10:Ln", :price=>"1000"}, {:name=>:"10:Ln", :price=>"1000"}]}
+  # Using it directly on Hash class, set_values(hash_values):
+  #   new_hash = my_hash.set_values({city: 'London', price: '1000'})
+  # Setting specific nested keys
+  #   new_hash = my_hash.set_values({'data.lab.products.price': 75, 'data.lab.beep': false})
+  ###########################################################################
+  def NiceHash.set_values(hash_array, hash_values)
+    hashv = Hash.new()
+    if hash_array.is_a?(Hash) and hash_array.size > 0
+      #for the case same_values on hash_values
+      #fex: ({pwd1: 'aaaa', pwd2: 'bbbbb', uno: 1}).set_values({[:pwd1, :pwd2]=>:'1-10:n'})
+      # should return : {[:pwd1, :pwd2]=>:'1-10:n', uno: 1}
+      #todo: it doesn't work for all cases, just simple one
+      if hash_values.is_a?(Hash) and hash_values.keys.flatten.size != hash_values.keys.size
+        hash_values.each do |k,v|
+          if k.is_a?(Array)
+            k.each do |kvk|
+              if hash_array.key?(kvk)
+                  hash_array[kvk] = hash_values[k]
+              end
+            end
+          end
+        end
+
+      end
+      hash_array.each do |k, v|
+        #for the case of using same_values: [:pwd1, :pwd2] => :'10:N' and supply hash_values: pwd1: 'a', pwd2: 'b'
+        #instead of [:pwd1,:pwd2]=>'a'
+        same_values_key_done = false
+        if k.is_a?(Array) 
+          #todo: we are treating here only a simple case, consider to add also nested keys, array of values...
+          k.each do |kvk|
+            if hash_values.keys.include?(kvk)
+              hashv[k] = hash_values[kvk]
+              same_values_key_done = true
+            end
+          end
+        end
+        unless same_values_key_done
+          if hash_values.keys.include?(k)
+            hashv[k] = hash_values[k]
+          elsif v.is_a?(Array)
+            if hash_values.has_rkey?('\.') # the kind of 'uno.dos.tres'
+              new_hash_values = {}
+              hash_values.each do |kk,vv|
+                if kk.to_s.match?(/^#{k}\./)
+                  kk = kk.to_s.gsub(/^#{k}\./, '').to_sym
+                  new_hash_values[kk] = vv
+                end
+              end
+              hashv[k] = NiceHash.set_values(v, new_hash_values)
+            else
+              hashv[k] = NiceHash.set_values(v, hash_values)
+            end
+          elsif v.is_a?(Hash)
+            if hash_values.has_rkey?('\.') # the kind of 'uno.dos.tres'
+              new_hash_values = {}
+              hash_values.each do |kk,vv|
+                if kk.to_s.match?(/^#{k}\./)
+                  kk = kk.to_s.gsub(/^#{k}\./, '').to_sym
+                  new_hash_values[kk] = vv
+                end
+              end
+              hashv[k] = NiceHash.set_values(v, new_hash_values)
+            else
+              hashv[k] = NiceHash.set_values(v, hash_values)
+            end
+          else
+            hashv[k] = v
+          end
+        end
+      end
+      hash_values.each do |k, v|
+        hashv = NiceHash.set_nested(hashv, k, v, true) if k.is_a?(Hash)
+      end
+      return hashv
+    elsif hash_array.is_a?(Array) and hash_array.size > 0
+      hashv = Array.new
+      hash_array.each do |r|
+        hashv << NiceHash.set_values(r, hash_values)
+      end
+      return hashv
+    else
+      return hash_array
+    end
+  end
+    
+end

data/lib/nice/hash/transtring.rb

@@ -0,0 +1,32 @@
+class NiceHash
+   ##################################################
+  #  Translate a hash of hashes into a string separted by .
+  #
+  #  @param hash [Hash] The hash we want to translate
+  #
+  #  @return [String]
+  #
+  #  @example
+  #    my_hash =  { uno: {dos: :tres} }
+  #    NiceHash.transtring(my_hash)
+  #    #>"uno.dos.tres"
+  ##################################################
+  def self.transtring(hash)
+    keys = []
+    if hash.is_a?(Hash)
+      hash.each do |k, v|
+        if v.is_a?(Hash)
+          keys << k
+          keys << transtring(v)
+        else
+          keys << k
+          keys << v
+        end
+      end
+    else
+      keys << hash
+    end
+    return keys.join(".")
+  end
+
+end