nice_hash 1.14.0 → 1.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c2618d70584a37e351a02db7c4771aa4feff1264ded1b592d85a392014e7104
-  data.tar.gz: 3ce0ddf1b7dae7709aebb8267ec46d251704d7976184251ce795dbee0abcdc22
+  metadata.gz: 5f7ac29e16ee8ddcaed4f42d365f58c322a0345781ba9579be3b3cb57b067d2e
+  data.tar.gz: b1c38c87b0699cdbc167d8e6acc490475bdd085e5fae02c8b8f716c7e843ac59
 SHA512:
-  metadata.gz: eebb8367920fb12254cf9b73deb46fd0391816a34727039871e8f89f6d70434dee02fc658b496e32169c00ae04a9d71853a2ca78d61d7d931444da524e188b74
-  data.tar.gz: db2d81ad6b7b94ec58aff98ccfb471cd09d9c7c036cdaee4fe75a53ee37649f11b5a85fb2a81fae21398482c975c400b712f8dba934937590b34ff8c286d4427
+  metadata.gz: '0608b70a2dcc0964aa80399d1b03ed40568ad67936ba0260c1bda08a8c6f4d0d90680e1141df051edc5bb60da18353ff5d64b68e285f009e1234e4683aff7409'
+  data.tar.gz: f6b2ce5f4108a92f550b6caad39a0d6e37a3e0c8354ebe6e8464a69db8da1e6290d9d7170ccfcbc0fe465fc000e0c26b30ee3358a36866dcc073138c2951d7e4

data/.yardopts

@@ -2,4 +2,9 @@
 --title 'nice_hash - NiceHash creates hashes following certain patterns so your testing will be much easier. You can easily generates all the hashes you want following the criteria you specify.'
 --charset utf-8
 --markup markdown
-'lib/**/*.rb' - '*.md' - 'LICENSE'
+-
+lib/**/*.rb 
+lib/nice_hash.rb
+lib/nice/hash/add_to_ruby.rb
+*.md
+LICENSE

data/README.md

@@ -175,6 +175,8 @@ new_hash = my_hash.generate
 puts new_hash.get_values(:address) #> {:address=>"21 Doom Av"}
 puts new_hash.get_values(:address, :zip) #> {:zip=>{:default=>"00000", :correct=>"42782"}, :address=>"21 Doom Av"}
 puts new_hash.get_values(:drawId) #> {:drawId=>["84914", "21158"]}
+#using nested keys
+puts new_hash.get_values(:'draws.drawId') #> {:'draws.drawId'=>["84914", "21158"]}
 ```
 
 In case of an array of hashes, you will be able also to access the different keys, for example:
@@ -276,6 +278,29 @@ On this example new_hash will contain:
 }
 ```
 
+Also you can filter the hash you want and return only the speficied keys by using the `nice_filter` method
+
+```ruby
+    my_hash = { user: {
+                        address: {
+                               city: 'Madrid',
+                               country: 'Spain'
+                            },
+                        name: 'Peter',
+                        age: 33,
+                        customers: [{name: 'Peter', currency: 'Euro'}, {name:'John', currency: 'Euro'}]
+                      },
+                customer: true
+    }
+    pp my_hash.nice_filter([:'user.address.city', :'customer', :'user.customers.name'])
+#>  {:user=>
+#>    {:address=>{:city=>"Madrid"},
+#>      :customers=>[{:name=>"Peter"}, {:name=>"John"}]
+#>    },
+#>   :customer=>true
+#>  }
+```
+
 ### How to generate the hash with the criteria we want
 
 You can use the 'generate' method and everytime will be generated a different hash with different values.

data/lib/nice/hash/add_to_ruby.rb

@@ -98,6 +98,16 @@ class Array
     json_string = "[#{join(",")}]"
     json_string.json(*keys)
   end
+
+
+  ###########################################################################
+  # Filter the array of hashes and returns only the specified keys
+  # More info: NiceHash.nice_filter
+  ###########################################################################
+  def nice_filter(keys)
+    NiceHash.nice_filter(self, keys)
+  end
+
 end
 
 require "date"
@@ -263,6 +273,14 @@ class Hash
     !!keys.detect{ |key| key =~ search }
   end
 
+  ###########################################################################
+  # Filter the hash and returns only the specified keys
+  # More info: NiceHash.nice_filter
+  ###########################################################################
+  def nice_filter(keys)
+    NiceHash.nice_filter(self, keys)
+  end
+
   alias gen generate
   alias val validate
   alias patterns pattern_fields

data/lib/nice_hash.rb

@@ -1,4 +1,6 @@
 SP_ADD_TO_RUBY = true if !defined?(SP_ADD_TO_RUBY)
+#todo: add SP_USE_NESTED_KEYS = true
+
 require_relative "nice/hash/add_to_ruby" if SP_ADD_TO_RUBY
 
 require "string_pattern"
@@ -772,19 +774,26 @@ class NiceHash
   #                {"idt"=>3145,"name"=>"Special ticket"}
   #              ]
   #            }
-  #   keys: one key (string) or an array of keys
+  #   keys: one key (string) or an array of keys. key can be a nested key
   # output:
   #   a Hash of Arrays with all values found.
   #       Example of output with example.get_values("id","name")
   #           {"id"=>[334],"name"=>["Peter North"]}
   #       Example of output with example.get_values("idt")
   #           {"idt"=>[345,3123,3145]}
+  #       Example of output with example.get_values(:'tickets.idt')
+  #           {:"tickets.idt"=>[345,3123,3145]}
   #
   ####################################################
   def NiceHash.get_values(hashv, keys)
     if keys.kind_of?(String) or keys.kind_of?(Symbol)
       keys = [keys]
     end
+    if (keys.grep(/\./)).empty?
+      nested = false
+    else
+      nested = true
+    end
     result = Hash.new()
     number_of_results = Hash.new()
     keys.each { |key|
@@ -823,6 +832,7 @@ class NiceHash
         #if keys.include?(key) then
         #added to be able to access the keys with symbols to strings and opposite
         if keys.include?(key) or keys.include?(key.to_s) or keys.include?(key.to_sym)
+          #todo: check on next ruby versions since it will be not necessary to do it
           #added to be able to access the keys with symbols to strings and opposite
           key = key.to_s() if keys.include?(key.to_s)
           key = key.to_sym() if keys.include?(key.to_sym)
@@ -847,7 +857,19 @@ class NiceHash
           number_of_results[key] += 1
         end
         if value.kind_of?(Array) or value.kind_of?(Hash)
-          n_result = get_values(value, keys)
+          if nested
+            keys_nested = []
+            keys.grep(/^#{key}\./).each do |k|
+              keys_nested << k.to_s.gsub(/^#{key}\./,'').to_sym
+            end
+            n_result_tmp = get_values(value, keys_nested)
+            n_result = {}
+            n_result_tmp.each do |k,v|
+              n_result["#{key}.#{k}".to_sym] = v
+            end
+          else
+            n_result = get_values(value, keys)
+          end
           if n_result != :error
             n_result.each { |n_key, n_value|
               if result.has_key?(n_key)
@@ -1090,4 +1112,55 @@ class NiceHash
     end
     return hash
   end
+
+  ##################################################
+  #  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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nice_hash
 version: !ruby/object:Gem::Version
-  version: 1.14.0
+  version: 1.15.0
 platform: ruby
 authors:
 - Mario Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-30 00:00:00.000000000 Z
+date: 2019-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: string_pattern