nice_hash 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fb7ee5f4b573f8086229554d2faa0b453a3151b0d1079de3506a91576e6e1fdb
+  data.tar.gz: 682b00b149237da2b21c039ad405583389cde10b9a8a7051ecf86212d762f8ca
+SHA512:
+  metadata.gz: 507dc1d466f6fa6a34708a716f778b33d1c77608ad11ad8f58c853e47de41c9f8023f3ec486412c8c655691bee689bfc495bd3cbabb2aed4a1eb82ea6e57fd08
+  data.tar.gz: 3cfb95b45dd3931f02d91d572a568f032be4fcec3d0386541b75a6fe2ab106f9532348148f557b564c5ccc1d81a8254692fec066cf0c667b1d1124f605280113

data/.yardopts

@@ -0,0 +1,5 @@
+--readme README.md
+--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'

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Mario Ruiz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,515 @@
+# NiceHash
+
+[![Gem Version](https://badge.fury.io/rb/nice_hash.svg)](https://rubygems.org/gems/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. 
+
+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.
+
+To generate the strings following a pattern take a look at the documentation for string_pattern gem: https://github.com/MarioRuiz/string_pattern
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'nice_hash'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nice_hash
+
+## Usage
+
+Remember!! To generate the strings following a pattern take a look at the documentation for string_pattern gem: https://github.com/MarioRuiz/string_pattern
+
+This is he Hash we will be using on our examples:
+
+```ruby
+
+require 'nice_hash'
+
+my_hash={
+    loginame: :"5-10:/xn/", 
+    [:pwd1, :pwd2, :pwd3] => :"5-10:L/n/",
+    name: :"10-20:T_/x/",
+    draws: [
+        {
+            drawId: :"5:N",
+            drawName: :"10:Ln",
+            type: :"Weekely|Daily",
+            owner: {
+                default: 'admin',
+                correct: :"20:L"
+            }
+        },
+        {
+            drawId: :"5:N",
+            drawName: :"10:Ln",
+            type: :"Weekely|Daily",
+            owner: {
+                default: 'admin',
+                correct: :"20:L"
+            }
+        }
+    ],
+    zip: {default: '00000', correct: :'5:N'},
+    address: "21 Doom Av",
+    city: {
+            default: "Madrid",
+            correct: "London|Rome"
+    },
+    wagers: ['34AAB', 'dfffDD', '33499A'],
+    country: {default: 'Spain', correct: ["Spain", "Iceland", "Serbia", "Denmark", "Canada", "Italy", "Austria"].join("|")}, #one of these values
+    mobilePhone: {default: '(987)654321', correct: ['(', :'3:N', ')', :'6-8:N']},
+    sex: :"male|female", #any of these values
+    display: true
+}
+```
+
+Explanations of the different fields:
+  
+    loginname: from 5 to 10 characters, mandatory to have lower letters and numbers
+    pwd, pwd2, pwd3: will have the same value. The value from 5 to 10 chars, optional capital and lower letters, necessary to contain numbers
+    name: from 10 to 20 chars. Optional national characters and space, necessary lower letters.
+    drawId: 5 numbers
+    drawName: 10 letters and/or numbers
+    type: 'Weekely' or 'Daily'
+    owner: correct: 20 letters
+    zip: correct: 5 numbers
+    city: correct: 'London' or 'Rome'
+    country: correct: one of these values "Spain", "Iceland", "Serbia", "Denmark", "Canada", "Italy", "Austria"
+    mobilePhone: correct: a sting pattern with one of the next: "(nnn) nnnnnn", "(nnn) nnnnnnn", "(nnn) nnnnnnnn"
+    sex: 'male' or 'female'
+
+So in case you want to assign to a key a string pattern value like for example in loginame, you need to specify the string pattern as a symbol :"5-10:/xn/"
+
+You can also supply an array of strings and string patterns, like on mobilePhone.correct: ['(', :'3:N', ')', :'6-8:N']}
+
+Also you can specify to select one of the values you want by separating them with |, like for example on sex field: "male|female"
+
+### How to access the different keys
+
+You can access the keys of the hash like always, but now we added to the Hash class the posibility of accessing it using:
+
+```ruby
+    puts my_hash[:address] # like usually is done
+    puts my_hash.address
+    my_hash.address = '99 Danish Street' #assignment
+    puts my_hash.loginame
+    puts my_hash.mobilePhone.correct
+    puts my_hash.draws[1].owner.correct
+```
+Also another way to access the different keys is by adding first underscore. 
+By doing it this way we are avoiding the cases where already exists a method with the same name on Hash class, for example: zip, display, default, select... 
+
+```ruby
+    puts my_hash._address
+    my_hash._address = '99 Danish Street' #assignment
+    my_hash._display = false #assignment
+    puts my_hash._loginame
+    puts my_hash._mobilePhone._correct
+    puts my_hash._draws[1]._owner._correct
+    puts my_hash._zip.correct #you can mix both also
+```
+
+By using the string_pattern gem you can generate single strings following the specific pattern on the field:
+
+```ruby
+    puts my_hash.loginame.generate #>s93owuvkh
+    puts my_hash.mobilePhone.correct.generate #>(039)5669558
+    puts my_hash._zip._correct.gen # gen is an alias for generate method #>84584
+```
+
+### 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
+
+```ruby
+    #using NiceHash class
+    new_hash = NiceHash.select_key(my_hash, :correct)
+    #using select_key method on Hash class
+    new_hash = my_hash.select_key(:correct)
+    default_hash = my_hash.select_key(:default)
+```
+
+On this example new_hash will contain: 
+
+```ruby
+{
+    loginame: :"5-10:/xn/", 
+    [:pwd1, :pwd2, :pwd3] => :"5-10:L/n/",
+    name: :"10-20:T_/x/",
+    draws: [
+        {
+            drawId: :"5:N",
+            drawName: :"10:Ln",
+            type: :"Weekely|Daily",
+            owner: :"20:L"
+        },
+        {
+            drawId: :"5:N",
+            drawName: :"10:Ln",
+            type: :"Weekely|Daily",
+            owner: :"20:L"
+        }
+    ],
+    zip: :'5:N',
+    address: "21 Doom Av",
+    city: "London|Rome",
+    wagers: ['34AAB', 'dfffDD', '33499A'],
+    country: ["Spain", "Iceland", "Serbia", "Denmark", "Canada", "Italy", "Austria"].join("|"), #one of these values
+    mobilePhone: ['(', :'3:N', ')', :'6-8:N'],
+    sex: :"male|female", #any of these values
+    display: 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.
+
+Remember you can filter/select by a hash key
+
+Using the NiceHash class:
+```ruby
+#without filtering
+new_hash = NiceHash.generate(my_hash)
+#filtering by a key passing the key on parameters
+new_hash = NiceHash.generate(my_hash, :correct)
+```
+
+Using Hash class (you can use the alias 'gen' for 'generate'): 
+```ruby
+#without filtering
+new_hash = my_hash.generate
+#filtering by a key passing the key on parameters
+new_hash = my_hash.generate(:correct)
+#filtering by a key using select_key method
+new_hash = my_hash.select_key(:correct).generate
+```
+
+
+In case of filtering by :correct new_hash would have a value like this for example:
+
+```ruby
+{:loginame=>"s45x029o",
+ :pwd1=>"E6hz9YS7",
+ :pwd2=>"E6hz9YS7",
+ :pwd3=>"E6hz9YS7",
+ :name=>"OyTQNfEyPOzVYMxPym",
+ :draws=>
+  [{:drawId=>"54591",
+    :drawName=>"cr5Q7pq4G8",
+    :type=>"Weekely",
+    :owner=>"nKEasYWInPGJxxElBZUB"},
+   {:drawId=>"73307",
+    :drawName=>"FnHPM4CsRC",
+    :type=>"Weekely",
+    :owner=>"cNGpHDhDLcxSFbOGqvNy"}],
+ :zip=>"47537",
+ :address=>"21 Doom Av",
+ :city=>"London",
+ :wagers=>["34AAB", "dfffDD", "33499A"],
+ :country=>"Denmark",
+ :mobilePhone=>"(707)8782080",
+ :sex=>"male",
+ :display=>true}
+```
+
+In case no filtering you will get all the values for all keys
+
+### How to generate the hash with wrong values for the string patterns specified on the hash
+
+We can generate wrong values passing the keyword argument: expected_errors (alias: errors)
+
+The possible values you can specify is one or more of these ones: :length, :min_length, :max_length, :value, :required_data, :excluded_data, :string_set_not_allowed
+
+    :length: wrong length, minimum or maximum
+    :min_length: wrong minimum length
+    :max_length: wrong maximum length
+    :value: wrong resultant value
+    :required_data: the output string won't include all necessary required data. It works only if required data supplied on the pattern.
+    :excluded_data: the resultant string will include one or more characters that should be excluded. It works only if excluded data supplied on the pattern.
+    :string_set_not_allowed: it will include one or more characters that are not supposed to be on the string.
+
+Examples:
+
+```ruby
+wrong_values = my_hash.generate(:correct, expected_errors: [:value])
+
+wrong_max_length = my_hash.generate(:correct, errors: :max_length)
+
+wrong_min_length = my_hash.generate(:correct, expected_errors: :min_length)
+
+wrong_min_length = my_hash.select_key(:correct).generate(errors: :min_length)
+
+valid_values = my_hash.generate(:correct)
+```
+
+On this example wrong_min_length will contain something like:
+
+```ruby
+{:loginame=>"0u",
+ :pwd1=>"4XDx",
+ :pwd2=>"4XDx",
+ :pwd3=>"4XDx",
+ :name=>"bU",
+ :draws=>
+  [{:drawId=>"", :drawName=>"P03AgdMqV", :type=>"Dail", :owner=>"dYzLRMCnVc"},
+   {:drawId=>"", :drawName=>"qw", :type=>"Dail", :owner=>"zkHhTEzM"}],
+ :zip=>"7168",
+ :address=>"21 Doom Av",
+ :city=>"Rom",
+ :wagers=>["34AAB", "dfffDD", "33499A"],
+ :country=>"Spai",
+ :mobilePhone=>"(237)17640431",
+ :sex=>"mal",
+ :display=>true}
+```
+
+### Return the select_fields or the pattern_fields
+
+If you need a list of select fields or pattern fields that exist on your hash you can use the methods: select_fields and pattern_fields
+
+It will return an array with all the fields found. On every entry of the array you will see keys to the field.
+
+```ruby
+all_select_fields = my_hash.select_fields
+select_fields_on_correct = my_hash.select_fields(:correct)
+
+all_pattern_fields = my_hash.pattern_fields
+pattern_fields_on_correct = my_hash.pattern_fields(:correct)
+```
+
+all_select_fields contains: 
+
+```ruby
+[[:draws, 0, :type],
+ [:draws, 1, :type],
+ [:city, :correct],
+ [:country, :correct],
+ [:sex]]
+```
+
+select_fields_on_correct contains: 
+
+```ruby
+[[:draws, 0, :type], 
+ [:draws, 1, :type], 
+ [:city], 
+ [:country], 
+ [:sex]]
+```
+
+all_pattern_fields contains: 
+
+```ruby
+[[:loginame],
+ [[:pwd1, :pwd2, :pwd3]],
+ [:name],
+ [:draws, 0, :drawId],
+ [:draws, 0, :drawName],
+ [:draws, 0, :owner, :correct],
+ [:draws, 1, :drawId],
+ [:draws, 1, :drawName],
+ [:draws, 1, :owner, :correct],
+ [:zip, :correct],
+ [:mobilePhone, :correct]]
+```
+
+pattern_fields_on_correct contains: 
+
+```ruby
+[[:loginame],
+ [[:pwd1, :pwd2, :pwd3]],
+ [:name],
+ [:draws, 0, :drawId],
+ [:draws, 0, :drawName],
+ [:draws, 0, :owner],
+ [:draws, 1, :drawId],
+ [:draws, 1, :drawName],
+ [:draws, 1, :owner],
+ [:zip],
+ [:mobilePhone]]
+```
+
+
+#### dig and bury Hash methods
+In case you want to access the values on a hash structure by using the key array location, you can use the 'dig' method on the Hash class:
+
+```ruby
+min_length_error = my_hash.generate :correct, errors: :min_length
+
+patterns = my_hash.pattern_fields :correct
+
+patterns.each{|key|
+  if key[0].kind_of?(Array) # same values, like in pwd1, pwd2 and pwd3
+    puts "#{key} same values"
+    value = min_length_error.dig(key[0][0])
+  else
+    value = min_length_error.dig(*key)
+  end
+  
+  pattern = my_hash.select_key(:correct).dig(*key)
+  puts "the value: '#{value}' was generated from the key: #{key} with pattern: #{pattern}"
+}
+```
+
+This returns something like: 
+
+```
+the value: '5z' was generated from the key: [:loginame] with pattern: 5-10:/xn/
+[[:pwd1, :pwd2, :pwd3]] same values
+the value: '5' was generated from the key: [[:pwd1, :pwd2, :pwd3]] with pattern: 5-10:L/n/
+the value: 'KshiYAmp' was generated from the key: [:name] with pattern: 10-20:T_/x/
+the value: '722' was generated from the key: [:draws, 0, :drawId] with pattern: 5:N
+the value: '4' was generated from the key: [:draws, 0, :drawName] with pattern: 10:Ln
+the value: 'jhVZkII' was generated from the key: [:draws, 0, :owner] with pattern: 20:L
+the value: '260' was generated from the key: [:draws, 1, :drawId] with pattern: 5:N
+the value: 'ssty8hlnJ' was generated from the key: [:draws, 1, :drawName] with pattern: 10:Ln
+the value: 'zPvcwOyyXvWSgNHsuv' was generated from the key: [:draws, 1, :owner] with pattern: 20:L
+the value: '242' was generated from the key: [:zip] with pattern: 5:N
+the value: '(91)7606' was generated from the key: [:mobilePhone] with pattern: ["(", :"3:N", ")", :"6-8:N"]
+```
+
+Ruby Hash class doesn't have a method to allocate a value using the key array location so we added to Hash class a method for that purpose, the 'bury' method.
+
+```ruby
+default_values = my_hash.generate :default
+
+default_values.bury([:draws, 0, :drawName], "FirstDraw")
+```
+
+After using the bury method default_values will contain:
+
+```ruby
+{:loginame=>"i0v2jy",
+ :pwd1=>"x33exx",
+ :pwd2=>"x33exx",
+ :pwd3=>"x33exx",
+ :name=>"HdmsjLxlEgYIFY",
+ :draws=>
+  [{:drawId=>"12318",
+    :drawName=>"FirstDraw",
+    :type=>"Weekely",
+    :owner=>"admin"},
+   {:drawId=>"18947",
+    :drawName=>"LPgf2ZQvkG",
+    :type=>"Weekely",
+    :owner=>"admin"}],
+ :zip=>"00000",
+ :address=>"21 Doom Av",
+ :city=>"Madrid",
+ :wagers=>["34AAB", "dfffDD", "33499A"],
+ :country=>"Spain",
+ :mobilePhone=>"(987)654321",
+ :sex=>"male",
+ :display=>true}
+```
+
+### Validating hashes
+
+If you have a Hash that should follow the patterns you specified (in this example declared on my_hash) and you want to validate, then use the 'validate' method.
+
+This is particulary useful to test REST APIs responses in JSON
+
+If we have a hash with these values:
+
+```ruby
+{:loginame=>"rdewvqur",
+ :pwd1=>"d3ulo",
+ :pwd2=>"d3ulo",
+ :pwd3=>"d3ulo",
+ :name=>"LTqVKxxFCTqpkdjFkxU",
+ :draws=>
+  [{:drawId=>"54a43",
+    :drawName=>"h3F24yjMWp",
+    :type=>"Daily",
+    :owner=>"abIZMRxTDsWjQcpdspZt"},
+   {:drawId=>"13010",
+    :drawName=>"NurCEAtE1M",
+    :type=>"Daily",
+    :owner=>"vSVoqtSzHkbvRNyJoYGz"}],
+ :zip=>"30222",
+ :address=>"21 Doom Av",
+ :city=>"New York",
+ :wagers=>["34AAB", "dfffDD", "33499A"],
+ :country=>"Iceland",
+ :mobilePhone=>"(441)97037845",
+ :sex=>"male",
+ :display=>true}
+```
+
+To validate those values taking in consideration was is stated on my_hash:
+
+```ruby
+results_all_fields = my_hash.validate :correct, values
+
+results_pattern_fields = my_hash.validate_patterns :correct, values
+```
+
+results_all_fields will contain all the validation errors:
+
+```ruby
+{:loginame=>[:value, :required_data],
+ :draws=>[{:drawId=>[:value, :string_set_not_allowed]}],
+ :city=>false}
+```
+
+and results_pattern_fields will contain only the validation errors for the fields containing patterns:
+
+```ruby
+{:loginame=>[:value, :required_data],
+ :draws=>[{:drawId=>[:value, :string_set_not_allowed]}]}
+```
+
+The possible validation values returned:
+
+    :length: wrong length, minimum or maximum
+    :min_length: wrong minimum length
+    :max_length: wrong maximum length
+    :value: wrong resultant value
+    :required_data: the output string won't include all necessary required data. It works only if required data supplied on the pattern.
+    :excluded_data: the resultant string will include one or more characters that should be excluded. It works only if excluded data supplied on the pattern.
+    :string_set_not_allowed: it will include one or more characters that are not supposed to be on the string.
+
+
+### Change only one value at a time and return an Array of Hashes
+
+Let's guess we need to test a typical registration REST service and the service has many fields with many validations but we want to test it one field at a time.
+
+Then the best thing you can do is to use the method NiceHash.change_one_by_one.
+
+
+```ruby
+
+wrong_min_length_hash = my_hash.generate(:correct, errors: :min_length)
+
+array_of_hashes = NiceHash.change_one_by_one([my_hash, :correct], wrong_min_length_hash)
+
+array_of_hashes.each {|hash_with_one_wrong_field|
+  #Here your code to send through http the JSON data stored in hash_with_one_wrong_field
+  
+  #if you want to know which field is the one that is wrong:
+  res = my_hash.validate(:correct, hash_with_one_wrong_field)
+}
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/marioruiz/nice_hash.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+

data/lib/nice/hash/add_to_ruby.rb

@@ -0,0 +1,127 @@
+class Array
+
+  ###########################################################################
+  # Stores a value on the location indicated
+  # input:
+  #   where: (Array)
+  #   value
+  # examples:
+  #   my_array.bury([3, 0], "doom") # array of 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
+  end
+end
+
+
+class Hash
+  ###########################################################################
+  # Returns the value of the key specified in case doesn't exist a Hash method with the same name
+  # The keys can be accessed also adding underscore to avoid problems with existent methods
+  # Also set values in case = supplied
+  # examples:
+  #   my_hash.address.correct
+  #   my_hash._address._correct
+  #   my_hash.city
+  #   my_hash._city
+  #   my_hash.city="Paris"
+  #   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)
+      self[m]
+    elsif m.to_s[-1]=="="
+      self[m.to_s.chop.to_sym]=arguments[0]
+    else
+      super
+    end
+  end
+
+  ###########################################################################
+  # Stores a value on the location indicated
+  # input:
+  #   where: (Array)
+  #   value
+  # examples:
+  #   my_hash.bury([:bip, :doom], "doom") # hash of 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
+    }
+  end
+
+  ###########################################################################
+  # 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
+  # More info: NiceHash.select_key
+  ###########################################################################
+  def select_key(select_hash_key)
+    NiceHash.select_key(self, select_hash_key)
+  end
+
+  ###########################################################################
+  # It will generate a new hash with the values generated from the string patterns and select fields specified.
+  # In case supplied select_hash_key and a subhash specified on a value it will be selected only the value of the key specified on select_hash_key
+  # If expected_errors specified the values will be generated with the specified errors.
+  # More info: NiceHash.generate
+  # alias: gen
+  ###########################################################################
+  def generate(select_hash_key=nil, expected_errors: [], **synonyms)
+    NiceHash.generate(self, select_hash_key, expected_errors: expected_errors, **synonyms)
+  end
+
+  ###########################################################################
+  # Validates a given values_hash_to_validate with string patterns and select fields
+  # More info: NiceHash.validate
+  # alias: val
+  ###########################################################################
+  def validate(select_hash_key=nil, values_hash_to_validate)
+    NiceHash.validate([self, select_hash_key], values_hash_to_validate, only_patterns: false)
+  end
+
+  ###########################################################################
+  # 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)
+    NiceHash.validate([self, select_hash_key], values_hash_to_validate, only_patterns: true)
+  end
+
+  ###########################################################################
+  # It will return an array of the keys where we are using string patterns.
+  # More info: NiceHash.pattern_fields
+  ###########################################################################
+  def pattern_fields(*select_hash_key)
+    NiceHash.pattern_fields(self, *select_hash_key)
+  end
+
+  ###########################################################################
+  # It will return an array of the keys where we are using select values of the kind: "value1|value2|value3".
+  # More info: NiceHash.select_fields
+  ###########################################################################
+  def select_fields(*select_hash_key)
+    NiceHash.select_fields(self, *select_hash_key)
+  end
+
+
+  alias_method :gen, :generate
+  alias_method :val, :validate
+  alias_method :patterns, :pattern_fields
+
+end

data/lib/nice_hash.rb

@@ -0,0 +1,582 @@
+SP_ADD_TO_RUBY = true if !defined?(SP_ADD_TO_RUBY)
+require_relative 'nice/hash/add_to_ruby' if SP_ADD_TO_RUBY
+
+require 'string_pattern'
+
+###########################################################################
+# 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.
+# 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.
+# To generate the strings following a pattern take a look at the documentation for string_pattern gem: https://github.com/MarioRuiz/string_pattern
+# This is the Hash we will be using on the examples declared on the methods source code documentation:
+#   my_hash={
+#     name: 'Peter',
+#     address: {wrong: '#$$$$$', correct: :'10-30:L_'},
+#     city: {wrong: 'Germany', correct: :'Madrid|Barcelona|London|Akureyri'},
+#     products: [
+#       {
+#         name: :'10:Ln',
+#         price: {wrong: '-20', correct: :'1-10:N'}
+#       },
+#       {
+#         name: :'10:Ln',
+#         price: {wrong: '-20', correct: :'1-10:N'}
+#       },
+#     ]
+#   }
+###########################################################################
+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)
+    hash=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)
+              hash[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
+            }
+            hash[key]=value_ret
+          end
+        else
+          hash[key]=value
+        end
+      }
+    else
+      return pattern_hash
+    end
+    return hash
+  end
+
+  ###########################################################################
+  # 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
+
+  ###########################################################################
+  # 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
+
+
+  ###########################################################################
+  # It will generate a new hash with the values generated from the string patterns and select fields specified.
+  # In case supplied select_hash_key and a subhash specified on a value it will be selected only the value of the key specified on select_hash_key
+  # If expected_errors specified the values will be generated with the specified errors.
+  # input:
+  #   pattern_hash: (Hash) Hash we want to use to generate the values
+  #   select_hash_key: (key value) (optional) The key we want to select on the subhashes
+  #   expected_errors: (Array) (optional) (alias: errors) To generate the string patterns with the specified errors.
+  #     The possible values you can specify is one or more of these ones:
+  #       :length: wrong length, minimum or maximum
+  #       :min_length: wrong minimum length
+  #       :max_length: wrong maximum length
+  #       :value: wrong resultant value
+  #       :required_data: the output string won't include all necessary required data. It works only if required data supplied on the pattern.
+  #       :excluded_data: the resultant string will include one or more characters that should be excluded. It works only if excluded data supplied on the pattern.
+  #       :string_set_not_allowed: it will include one or more characters that are not supposed to be on the string.
+  # output: (Hash)
+  #   The Hash with the select_hash_key selected and the values generated from the string patterns and select fields specified.
+  # examples:
+  #   new_hash = NiceHash.generate(my_hash)
+  #   #> {:name=>"Peter",
+  #       :address=>{:wrong=>"\#$$$$$", :correct=>"KZPCzxsWGMLqonesu wbqH"},
+  #       :city=>{:wrong=>"Germany", :correct=>"Barcelona"},
+  #       :products=> [
+  #         {:name=>"gIqkWygmVm", :price=>{:wrong=>"-20", :correct=>"34338330"}},
+  #         {:name=>"CK68VLIcYf", :price=>{:wrong=>"-20", :correct=>"616066520"}}
+  #       ]
+  #      }
+  #   new_hash = NiceHash.generate(my_hash, :correct)
+  #   #> {:name=>"Peter",
+  #       :address=>"juQeAVZjIuWBPsE",
+  #       :city=>"Madrid",
+  #       :products=> [
+  #         {:name=>"G44Ilr0puV", :price=>"477813"},
+  #         {:name=>"v6ojs79LOp", :price=>"74820"}
+  #       ]
+  #      }
+  #   new_hash = NiceHash.generate(my_hash, :correct, expected_errors: [:min_length])
+  #   #> {:name=>"Peter",
+  #       :address=>"ZytjefJ",
+  #       :city=>"Madri",
+  #       :products=>[
+  #         {:name=>"cIBrzeO", :price=>""},
+  #         {:name=>"5", :price=>""}
+  #        ]
+  #       }
+  # Using it directly on Hash class, generate(select_hash_key=nil, expected_errors: []) (alias: gen):
+  #   new_hash = my_hash.generate
+  #   new_hash = my_hash.gen(:correct)
+  #   new_hash = my_hash.generate(:correct, errors: [:min_length])
+  ###########################################################################
+  def NiceHash.generate(pattern_hash, select_hash_key=nil, expected_errors: [], **synonyms)
+    hash=Hash.new()
+    same_values=Hash.new()
+    expected_errors=synonyms[:errors] if synonyms.keys.include?(:errors)
+    if expected_errors.kind_of?(Symbol)
+      expected_errors=[expected_errors]
+    end
+
+    if pattern_hash.kind_of?(Hash) and pattern_hash.size>0
+      pattern_hash.each {|key, value|
+
+        if key.kind_of?(Array)
+          same_values[key[0]]=key.dup
+          same_values[key[0]].shift
+          key=key[0]
+        end
+        if value.kind_of?(Hash)
+          if value.keys.include?(select_hash_key)
+            value=value[select_hash_key]
+          else
+            value=NiceHash.generate(value, select_hash_key, expected_errors: expected_errors)
+          end
+        end
+
+        if value.kind_of?(String) or value.kind_of?(Symbol)
+          if ((StringPattern.optimistic and value.kind_of?(String)) or value.kind_of?(Symbol)) and value.to_s.scan(/^!?\d+-?\d*:.+/).size>0
+            hash[key]=StringPattern.generate(value, expected_errors: expected_errors)
+          elsif ((StringPattern.optimistic and value.kind_of?(String)) or value.kind_of?(Symbol)) and value.to_s.scan(/^([\w\s\-]+\|)+[\w\s\-]+$/).size>0
+            if expected_errors.include?(:min_length) or (expected_errors.include?(:length) and rand.round==0)
+              min=value.to_s.split("|").min {|a, b| a.size <=> b.size}
+              hash[key]=min[0..-2] unless min==""
+            end
+            if !hash.keys.include?(key) and (expected_errors.include?(:max_length) or expected_errors.include?(:length))
+              max=value.to_s.split("|").max {|a, b| a.size <=> b.size}
+              hash[key]=max+max[-1]
+            end
+            if expected_errors.include?(:value) or
+                expected_errors.include?(:string_set_not_allowed) or
+                expected_errors.include?(:required_data)
+              if hash.keys.include?(key)
+                v=hash[key]
+              else
+                v=value.to_s.split("|").sample
+              end
+              unless expected_errors.include?(:string_set_not_allowed)
+                v=StringPattern.generate(:"#{v.size}:[#{value.to_s.split("|").join.split(//).uniq.join}]")
+                hash[key]=v unless value.to_s.split("|").include?(v)
+              end
+              unless hash.keys.include?(key)
+                one_wrong_letter=StringPattern.generate(:"1:LN$[%#{value.to_s.split("|").join.split(//).uniq.join}%]")
+                v[rand(v.size)]=one_wrong_letter
+                hash[key]=v unless value.to_s.split("|").include?(v)
+              end
+            end
+            unless hash.keys.include?(key)
+              hash[key]=value.to_s.split("|").sample
+            end
+          else
+            hash[key]=value
+          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)
+              hash[key]=StringPattern.generate(value, expected_errors: expected_errors)
+              array_pattern=true
+              break
+            end
+          }
+          unless array_pattern
+            value_ret=Array.new
+            value.each {|v|
+              ret=NiceHash.generate(v, select_hash_key, expected_errors: expected_errors)
+              ret=v if ret.kind_of?(Hash) and ret.size==0
+              value_ret<<ret
+            }
+            hash[key]=value_ret
+          end
+        else
+          hash[key]=value
+        end
+
+        if same_values.include?(key)
+          same_values[key].each {|k|
+            hash[k]=hash[key]
+          }
+        end
+
+      }
+    end
+
+    return hash
+  end
+
+
+  ###########################################################################
+  # Validates a given values_hash_to_validate with string patterns and select fields from pattern_hash
+  # input:
+  #   patterns_hash:
+  #     (Hash) Hash where we have defined the patterns to follow.
+  #     (Array) In case of array supplied, the pair: [pattern_hash, select_hash_key]. select_hash_key will filter the hash by that key
+  #   values_hash_to_validate: (Hash) Hash of values to validate
+  #   only_patterns: (TrueFalse) (by default true) If true it will validate only the patterns and not the other fields
+  # output: (Hash)
+  #   A hash with the validation results. It will return only the validation errors so in case no validation errors found, empty hash.
+  #   The keys of the hash will be the keys of the values hash with the validation error.
+  #   The value in case of a pattern, will be an array with one or more of these possibilities:
+  #       :length: wrong length, minimum or maximum
+  #       :min_length: wrong minimum length
+  #       :max_length: wrong maximum length
+  #       :value: wrong resultant value
+  #       :required_data: the output string won't include all necessary required data. It works only if required data supplied on the pattern.
+  #       :excluded_data: the resultant string will include one or more characters that should be excluded. It works only if excluded data supplied on the pattern.
+  #       :string_set_not_allowed: it will include one or more characters that are not supposed to be on the string.
+  #   The value in any other case it will be false if the value is not corresponding to the expected.
+  # examples:
+  #   values_to_validate = {:name=>"Peter",
+  #                         :address=>"fnMuKW",
+  #                         :city=>"Dublin",
+  #                         :products=>[{:name=>"V4", :price=>"344"}, {:name=>"E", :price=>"a"}]
+  #                        }
+  #   results = NiceHash.validate([my_hash, :correct], values_to_validate)
+  #   #> {:address=>[:min_length, :length],
+  #       :products=> [{:name=>[:min_length, :length]},
+  #                    {:name=>[:min_length, :length], :price=>[:value, :string_set_not_allowed]}
+  #                   ]
+  #      }
+  #   results = NiceHash.validate([my_hash, :correct], values_to_validate, only_patterns: false)
+  #   #> {:address=>[:min_length, :length],
+  #       :city=>false,
+  #       :products=> [{:name=>[:min_length, :length]},
+  #                    {:name=>[:min_length, :length], :price=>[:value, :string_set_not_allowed]}
+  #                   ]
+  #      }
+  # Using it directly on Hash class:
+  #   validate(select_hash_key=nil, values_hash_to_validate) (alias: val)
+  #   validate_patterns(select_hash_key=nil, values_hash_to_validate)
+  #
+  #   results = my_hash.validate_patterns(:correct, values_to_validate)
+  #   results = my_hash.validate(:correct, values_to_validate)
+  ###########################################################################
+  def NiceHash.validate(patterns_hash, values_hash_to_validate, only_patterns: true)
+    if patterns_hash.kind_of?(Array)
+      pattern_hash=patterns_hash[0]
+      select_hash_key=patterns_hash[1]
+    elsif patterns_hash.kind_of?(Hash)
+      pattern_hash=patterns_hash
+      select_hash_key=nil
+    else
+      puts "NiceHash.validate wrong pattern_hash supplied #{patterns_hash.inspect}"
+      return {error: :error}
+    end
+    values = values_hash_to_validate
+    results={}
+    same_values={}
+    if pattern_hash.kind_of?(Hash) and pattern_hash.size>0
+      pattern_hash.each {|key, value|
+
+        if key.kind_of?(Array)
+          same_values[key[0]]=key.dup
+          same_values[key[0]].shift
+          key=key[0]
+        end
+        if value.kind_of?(Hash)
+          if !select_hash_key.nil? and value.keys.include?(select_hash_key)
+            value=value[select_hash_key]
+          elsif values.keys.include?(key) and values[key].kind_of?(Hash)
+            res=NiceHash.validate([value, select_hash_key], values[key], only_patterns: only_patterns)
+            results[key]=res if res.size>0
+            next
+          end
+        end
+
+        if values.keys.include?(key)
+          if value.kind_of?(String) or value.kind_of?(Symbol)
+            if ((StringPattern.optimistic and value.kind_of?(String)) or value.kind_of?(Symbol)) and value.to_s.scan(/^!?\d+-?\d*:.+/).size>0
+              res=StringPattern.validate(pattern: value, text: values[key])
+              results[key]=res if res.size>0
+            elsif !only_patterns and ((StringPattern.optimistic and value.kind_of?(String)) or value.kind_of?(Symbol)) and value.to_s.scan(/^([\w\s\-]+\|)+[\w\s\-]+$/).size>0
+              results[key]=false unless value.to_s.split("|").include?(values[key])
+            elsif !only_patterns
+              results[key]=false unless value.to_s==values[key].to_s
+            end
+          elsif value.kind_of?(Array)
+            array_pattern=false
+            complex_data=false
+            value.each {|v|
+              if (v.kind_of?(String) or v.kind_of?(Symbol)) and StringPattern.analyze(v, silent: true).kind_of?(StringPattern::Pattern)
+                res=StringPattern.validate(pattern: value, text: values[key])
+                results[key]=res if res==false
+                array_pattern=true
+                break
+              elsif v.kind_of?(Hash) or v.kind_of?(Array) or v.kind_of?(Struct)
+                complex_data=true
+                break
+              end
+            }
+            unless array_pattern or results.include?(key)
+              i=0
+              value.each {|v|
+                res=NiceHash.validate([v, select_hash_key], values[key][i], only_patterns: only_patterns)
+                if res.size>0
+                  results[key]=Array.new() if !results.keys.include?(key)
+                  results[key][i]=res
+                end
+                i+=1
+              }
+
+            end
+            unless array_pattern or only_patterns or results.include?(key) or complex_data
+              results[key]=false unless value==values[key]
+            end
+
+          else
+            unless only_patterns
+              results[key]=false unless value==values[key]
+            end
+          end
+
+          if same_values.include?(key)
+            same_values[key].each {|k|
+              if values.keys.include?(k)
+                if values[key]!=values[k]
+                  results[k]="Not equal to #{key}"
+                end
+              end
+            }
+          end
+
+        end
+      }
+
+    end
+
+    return results
+  end
+
+  ###########################################################################
+  # Change only one value at a time and return an Array of Hashes
+  # Let's guess we need to test a typical registration REST service and the service has many fields with many validations but we want to test it one field at a time.
+  # This method generates values following the patterns on patterns_hash and generates a new hash for every pattern/select field found on patterns_hash using the value supplied on values_hash
+  # input:
+  #   patterns_hash:
+  #     (Hash) Hash where we have defined the patterns to follow.
+  #     (Array) In case of array supplied, the pair: [pattern_hash, select_hash_key]. select_hash_key will filter the hash by that key
+  #   values_hash: (Hash) Hash of values to use to modify the values generated on patterns_hash
+  # output: (Array of Hashes)
+  # example:
+  #   wrong_min_length_hash = my_hash.generate(:correct, errors: :min_length)
+  #   array_of_hashes = NiceHash.change_one_by_one([my_hash, :correct], wrong_min_length_hash)
+  #   array_of_hashes.each {|hash_with_one_wrong_field|
+  #     #Here your code to send through http the JSON data stored in hash_with_one_wrong_field
+  #     #if you want to know which field is the one that is wrong:
+  #     res = my_hash.validate(:correct, hash_with_one_wrong_field)
+  #   }
+  ###########################################################################
+  def NiceHash.change_one_by_one(patterns_hash, values_hash)
+    if patterns_hash.kind_of?(Array)
+      select_key=patterns_hash[1]
+      pattern_hash=patterns_hash[0]
+    else
+      pattern_hash=patterns_hash
+      select_key=[]
+    end
+    array=Array.new
+    good_values=NiceHash.generate(pattern_hash, select_key)
+    select_keys=pattern_hash.pattern_fields(select_key)+pattern_hash.select_fields(select_key)
+    select_keys.each {|field|
+      new_hash=Marshal.load(Marshal.dump(good_values))
+      # to deal with the case same values... like in pwd1, pwd2, pwd3
+      if field[-1].kind_of?(Array)
+        last_to_set=field[-1]
+      else
+        last_to_set=[field[-1]]
+      end
+      last_to_set.each {|f|
+        keys=field[0..-2]<<f
+        new_hash.bury(keys, values_hash.dig(*keys))
+      }
+      array<<new_hash
+    }
+    return array
+  end
+
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: nice_hash
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Mario Ruiz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: string_pattern
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+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
+  be able to generate thousands of different hashes just declaring one and test easily
+  APIs based on JSON for example.'
+email: marioruizs@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- ".yardopts"
+- LICENSE
+- README.md
+- lib/nice/hash/add_to_ruby.rb
+- lib/nice_hash.rb
+homepage: https://github.com/MarioRuiz/nice_hash
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: NiceHash creates hashes following certain patterns so your testing will be
+  much easier.
+test_files: []