nice_hash 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a55c7666de081ceed78de43ec3817b7dadee88a43778db3c95276717697be39
-  data.tar.gz: b44dcdf7403cc64651333533e67ca21ec580d13eca9328a6da4529023290e730
+  metadata.gz: b547b217f676c7ddc188941e8ca40a075e96296719f2105b20dd6c3dda055195
+  data.tar.gz: dd9de32c94ecc5b6c2088f8f2a7816693b3030ddc3a4f545467c98944240eb19
 SHA512:
-  metadata.gz: fcbd50ee4edaf0ebf8031f3cc507abf67994968b2cb06475f32d6d5ac08d744872f2a7ecd1134eb8212de770a59b122728382cd24b1ceb81ec9b90ee7a57ebb8
-  data.tar.gz: 559c22fde98d99ae59287e1b3be892481772950e92ad3bdb3fc4116e8b89c407862c4e14b25deb2d86060279e895a21c0694e5d39a55edd61777ec3ca4b5b55f
+  metadata.gz: 1d4fdfc2239e82ccb4549b6f2e793fe1a85347c849f2fea3dbe7c0ae7b1296c6abdaa2b6192a026f5b0a8dc1884e505edeca23c62b97f9d9bcaa7c2461426f49
+  data.tar.gz: 179e667f98084f40178e3308c991d61247b8a6538fe58a80b88c3f561a250b4dbbc94d6d80877cef52a046f8baebc17f8c93e696acb3b5334a053aaf8f161f9b

data/README.md

@@ -8,6 +8,8 @@ You can easily generates all the hashes you want following the criteria you spec
 
 Many other features coming to Hash class like the methods 'bury' or select_key, access the keys like methods: my_hash.my_key.other_key. You will be able to generate thousands of different hashes just declaring one and test easily APIs based on JSON for example.
 
+You can also parse and filter a json string very easily.
+
 To generate the strings following a pattern take a look at the documentation for string_pattern gem: https://github.com/MarioRuiz/string_pattern
 
 ## Installation
@@ -103,6 +105,16 @@ In case you want one pattern to be generated with unique values, so never repeat
 
 ```
 
+Also if you have a JSON string you want to parse it and get the values of certain keys you can use the json method we added to nice_hash:
+
+```ruby
+    my_json_string="{\"id\":344,\"customer\":{\"name\":\"Peter Smith\",\"phone\":334334333},\"tickets\":[{\"idt\":345,\"name\":\"myFavor1\"},{\"idt\":3123},{\"idt\":3145,\"name\":\"Special ticket\"}]}"
+    puts my_json_string.json(:idt)
+    #> [345, 3123, 3145]
+
+    puts my_json_string.json(:idt, :name)
+    #> {:name=>["Peter Smith", ["myFavor1", "Special ticket"]], :idt=>[345, 3123, 3145]}
+```
 
 ### How to access the different keys
 
@@ -137,6 +149,15 @@ By using the string_pattern gem you can generate single strings following the sp
     puts my_hash._zip._correct.gen # gen is an alias for generate method #>84584
 ```
 
+If you want to search for all the values of one or more keys use get_values method:
+
+```ruby
+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"]}
+```
+
 ### Filtering / Selecting an specific key on the hash and subhashes
 
 In case you supply different possibilities to be used like for example on fields: owner, zip, city and mobilePhone, and you one to use a concrete one, use the method select_key

data/lib/nice/hash/add_to_ruby.rb

@@ -1,5 +1,49 @@
-class Array
+class String
+  ###########################################################################
+  #  In case the string is a json it will return the keys specified. the keys need to be provided as symbols
+  #  input:
+  #    keys:
+  #       1 value with key or an array of keys
+  #         In case the key supplied doesn't exist in the hash then it will be returned nil for that one
+  #  output:
+  #    if keys given: a hash of (keys, values) or the value, if the key is found more than once in the json string, then it will be return a hash op arrays
+  #    if no keys given, an empty hash
+  ###########################################################################
+  def json(*keys)
+    require 'json'
+    feed_symbols = JSON.parse(self, symbolize_names: true)
+    result = {}
+    if !keys.empty?
+      result_tmp = if keys[0].is_a?(Symbol)
+                     NiceHash.get_values(feed_symbols, keys)
+                   else
+                     {}
+                   end
+
+      if result_tmp.size == 1
+        result = if result_tmp.values.is_a?(Array) && (result_tmp.values.size == 1)
+                   result_tmp.values[0]
+                 else
+                   result_tmp.values
+                 end
+      else
+        result_tmp.each do |key, value|
+          result[key] = if (value.is_a?(Array) || value.is_a?(Hash)) && (value.size == 1)
+                          value[0]
+                        else
+                          value
+                        end
+        end
+      end
+
+    else
+      result = feed_symbols
+    end
+    result
+  end
+end
 
+class Array
   ###########################################################################
   # Stores a value on the location indicated
   # input:
@@ -10,14 +54,28 @@ class Array
   #   my_array.bury([2, 1, :original],"the value to set") #array of array of hash
   ###########################################################################
   def bury(where, value)
-    me=self
-    where[0..-2].each {|key|
-      me=me[key]
-    }
-    me[where[-1]]=value
+    me = self
+    where[0..-2].each do |key|
+      me = me[key]
+    end
+    me[where[-1]] = value
   end
-end
 
+  ###########################################################################
+  #  In case of an array of json strings will return the keys specified. The keys need to be provided as symbols
+  #  input:
+  #    keys:
+  #       1 value with key or an array of keys
+  #         In case the key supplied doesn't exist in the hash then it will be return nil for that one
+  #  output:
+  #    if keys given: a hash of (keys, values) or the value, if the key is found more than once in the json string, then it will be return a hash of arrays
+  #    if no keys given, an empty hash
+  ###########################################################################
+  def json(*keys)
+    json_string = "[#{join(',')}]"
+    json_string.json(*keys)
+  end
+end
 
 class Hash
   ###########################################################################
@@ -33,13 +91,11 @@ class Hash
   #   my_hash.products[1].price.wrong="AAAAA"
   ###########################################################################
   def method_missing(m, *arguments, &block)
-    if m[0]=='_'
-      m=m[1..-1].to_sym
-    end
-    if self.keys.include?(m)
+    m = m[1..-1].to_sym if m[0] == '_'
+    if key?(m)
       self[m]
-    elsif m.to_s[-1]=="="
-      self[m.to_s.chop.to_sym]=arguments[0]
+    elsif m.to_s[-1] == '='
+      self[m.to_s.chop.to_sym] = arguments[0]
     else
       super
     end
@@ -55,15 +111,15 @@ class Hash
   #   my_hash.bury([:original, 1, :doom],"the value to set") #hash of array of hash
   ###########################################################################
   def bury(where, value)
-    me=self
-    where[0..-2].each {|key|
-      me=me[key]
-    }
-    key=where[-1]
-    key=[key] unless where[-1].kind_of?(Array) # for the case same value for different keys, for example pwd1, pwd2, pwd3
-    key.each {|k|
-      me[k]=value
-    }
+    me = self
+    where[0..-2].each do |key|
+      me = me[key]
+    end
+    key = where[-1]
+    key = [key] unless where[-1].is_a?(Array) # for the case same value for different keys, for example pwd1, pwd2, pwd3
+    key.each do |k|
+      me[k] = value
+    end
   end
 
   ###########################################################################
@@ -82,7 +138,7 @@ class Hash
   # More info: NiceHash.generate
   # alias: gen
   ###########################################################################
-  def generate(select_hash_key=nil, expected_errors: [], **synonyms)
+  def generate(select_hash_key = nil, expected_errors: [], **synonyms)
     NiceHash.generate(self, select_hash_key, expected_errors: expected_errors, **synonyms)
   end
 
@@ -91,7 +147,7 @@ class Hash
   # More info: NiceHash.validate
   # alias: val
   ###########################################################################
-  def validate(select_hash_key=nil, values_hash_to_validate)
+  def validate(select_hash_key = nil, values_hash_to_validate)
     NiceHash.validate([self, select_hash_key], values_hash_to_validate, only_patterns: false)
   end
 
@@ -99,7 +155,7 @@ class Hash
   # Validates a given values_hash_to_validate with string patterns
   # More info: NiceHash.validate
   ###########################################################################
-  def validate_patterns(select_hash_key=nil, values_hash_to_validate)
+  def validate_patterns(select_hash_key = nil, values_hash_to_validate)
     NiceHash.validate([self, select_hash_key], values_hash_to_validate, only_patterns: true)
   end
 
@@ -119,9 +175,15 @@ class Hash
     NiceHash.select_fields(self, *select_hash_key)
   end
 
+  ###########################################################################
+  # Get values of the keys supplied from the Hash structure.
+  # More info: NiceHash.get_values
+  ###########################################################################
+  def get_values(*keys)
+    NiceHash.get_values(self, keys)
+  end
 
-  alias_method :gen, :generate
-  alias_method :val, :validate
-  alias_method :patterns, :pattern_fields
-
+  alias gen generate
+  alias val validate
+  alias patterns pattern_fields
 end

data/lib/nice_hash.rb

@@ -579,4 +579,132 @@ class NiceHash
     return array
   end
 
+
+  ##################################################
+    # Get values from the Hash structure (array of Hashes allowed)
+    #   In case the key supplied doesn't exist in the hash then it will be return nil for that one
+    # input:
+    #   hash: a simple hash or a hash containing arrays. Example:
+    #    example={"id"=>344,
+    #              "customer"=>{
+    #                  "name"=>"Peter Smith",
+    #                  "phone"=>334334333
+    #              },
+    #              "tickets"=>[
+    #                {"idt"=>345,"name"=>"myFavor1"},
+    #                {"idt"=>3123},
+    #                {"idt"=>3145,"name"=>"Special ticket"}
+    #              ]
+    #            }
+    #   keys: one key (string) or an array of keys
+    # 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]}
+    #
+    ####################################################
+    def NiceHash.get_values(hash,keys)
+      if keys.kind_of?(String) or keys.kind_of?(Symbol) then
+        keys=[keys]
+      end
+      result=Hash.new()
+      number_of_results=Hash.new()
+      keys.each {|key|
+        number_of_results[key]=0
+      }
+      if hash.kind_of?(Array) then
+        hash.each {|tmp|
+          if tmp.kind_of?(Array) or tmp.kind_of?(Hash) then
+            n_result=get_values(tmp, keys)
+            if n_result!=:error then
+              n_result.each {|n_key, n_value|
+                if result.has_key?(n_key) then
+                  if !result[n_key].kind_of?(Array) or
+                      (result[n_key].kind_of?(Array) and number_of_results[n_key] < result[n_key].size) then
+                    if result[n_key].kind_of?(Hash) or result[n_key].kind_of?(Array) then
+                      res_tx=result[n_key].dup()
+                    else
+                      res_tx=result[n_key]
+                    end
+                    result[n_key]=Array.new()
+                    result[n_key].push(res_tx)
+                    result[n_key].push(n_value)
+                  else
+                    result[n_key].push(n_value)
+                  end
+                else
+                  result[n_key]=n_value
+                end
+                number_of_results[n_key]+=1
+              }
+            end
+          end
+        }
+      elsif hash.kind_of?(Hash) then
+        hash.each {|key, value|
+          #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) then
+            #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)
+
+            if result.has_key?(key) then
+              if !result[key].kind_of?(Array) or
+                  (result[key].kind_of?(Array) and number_of_results[key] < result[key].size) then
+                if result[key].kind_of?(Hash) or result[key].kind_of?(Array) then
+                  res_tx=result[key].dup()
+                else
+                  res_tx=result[key]
+                end
+                result[key]=Array.new()
+                result[key].push(res_tx)
+                result[key].push(value)
+              else
+                result[key].push(value)
+              end
+            else
+              result[key]=value
+            end
+            number_of_results[key]+=1
+          end
+          if value.kind_of?(Array) or value.kind_of?(Hash) then
+            n_result=get_values(value, keys)
+            if n_result!=:error then
+              n_result.each {|n_key, n_value|
+                if result.has_key?(n_key) then
+                  if !result[n_key].kind_of?(Array) or
+                      (result[n_key].kind_of?(Array) and number_of_results[n_key] < result[n_key].size) then
+                    if result[n_key].kind_of?(Hash) or result[n_key].kind_of?(Array) then
+                      res_tx=result[n_key].dup()
+                    else
+                      res_tx=result[n_key]
+                    end
+                    result[n_key]=Array.new()
+                    result[n_key].push(res_tx)
+                    result[n_key].push(n_value)
+                  else
+                    result[n_key].push(n_value)
+                  end
+                else
+                  result[n_key]=n_value
+                end
+                number_of_results[n_key]+=1
+              }
+            end
+          end
+        }
+      else
+        return :error
+      end
+      if result.kind_of?(Hash) and caller[0]["get_values"].nil? then #no error or anything weird
+        (keys-result.keys).each {|k| #in case some keys don't exist in the hash
+          result[k]=nil
+        }
+      end
+      return result
+    end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nice_hash
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Mario Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-08 00:00:00.000000000 Z
+date: 2018-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: string_pattern
@@ -19,7 +19,7 @@ dependencies:
         version: '1.4'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.4.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: '1.4'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.4.1
 description: 'You can easily generates all the hashes you want following the criteria
   you specify. Many other features coming to Hash class like the methods ''bury''
   or select_key, access the keys like methods: my_hash.my_key.other_key. You will
@@ -71,5 +71,5 @@ rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: NiceHash creates hashes following certain patterns so your testing will be
-  much easier.
+  much easier. Parse and filter JSON.
 test_files: []