nice_hash 1.15.6 → 1.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d93166bb9591cd912ef6fbd380b25f6af2937c71478abd631e2ffc44b937e19a
-  data.tar.gz: a2db067687093c6ab4d3b193fe1d7575af33f2c0e34f8092f0103064117edd95
+  metadata.gz: 8319335fc75dd3ea181a84bdc8a67adf979b42e2fde45b4b2c1686927b877886
+  data.tar.gz: f0ca1147eb97015392f846a8449dac01c4df5f223336fc69aa7c83b8dd5dbc01
 SHA512:
-  metadata.gz: 363546839964322abe945dc6cacb9ff8a8ae7bf8301e0ec087429b2fd6a503ff417637591e7fb97cb13e792ca2b405efef8ee5585001c750b6f763156244b756
-  data.tar.gz: 0e9e34a219d43ff42cd387e1a48dc0009db5890ed6d09c48330a5ab0089e75588e1cc03c011d550f4fc90a3fd30e2041392b117b26678f6febe3e56cf0eef491
+  metadata.gz: ac548edf37ae74f11a21368c8b5f02d061b33a6fe2749f39f88cb10371e93701fe0ce53e548cf7c67ac968e2fced504fa709716597c0e498e26db0bc29863ee4
+  data.tar.gz: 7fe62a823ffe2b59048225847d83d684792c0097801d72707f4a74e89f138c6a7d61b6181a919964671463754ac7ac990646a8cb3d01f9a2aaaff3317bf8d9ae

data/README.md

@@ -116,7 +116,8 @@ my_hash={
     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|other", #any of these values
-    display: true
+    display: true,
+    user_names: [ :'3-10:L' ]
 }
 ```
 
@@ -138,6 +139,7 @@ Explanations of the different fields:
     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' or 'other'
+    user_names: array of strings from 3 to 10 letters
 
 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/"
 
@@ -303,7 +305,8 @@ On this example new_hash will contain:
     country: ["Spain", "Iceland", "Serbia", "Denmark", "Canada", "Italy", "Austria"].join("|"), #one of these values
     mobilePhone: ['(', :'3:N', ')', :'6-8:N'],
     sex: :"male|female|other", #any of these values
-    display: true
+    display: true,
+    user_names: [ :'3-10:L' ]
 }
 ```
 
@@ -383,7 +386,9 @@ In case of filtering by :correct new_hash would have a value like this for examp
  :country=>"Denmark",
  :mobilePhone=>"(707)8782080",
  :sex=>"male",
- :display=>true}
+ :display=>true,
+ :user_names=>["FFrriNdw", "ACc"]
+}
 ```
 
 In case no filtering you will get all the values for all keys
@@ -438,7 +443,9 @@ On this example wrong_min_length will contain something like:
  :country=>"Spai",
  :mobilePhone=>"(237)17640431",
  :sex=>"mal",
- :display=>true}
+ :display=>true,
+ :user_names=>["FF"]
+ }
 ```
 
 ### Return the select_fields or the pattern_fields
@@ -488,7 +495,8 @@ all_pattern_fields contains:
  [:draws, 1, :drawName],
  [:draws, 1, :owner, :correct],
  [:zip, :correct],
- [:mobilePhone, :correct]]
+ [:mobilePhone, :correct]],
+ [:user_names]
 ```
 
 pattern_fields_on_correct contains: 
@@ -504,7 +512,8 @@ pattern_fields_on_correct contains:
  [:draws, 1, :drawName],
  [:draws, 1, :owner],
  [:zip],
- [:mobilePhone]]
+ [:mobilePhone]],
+ [:user_names]
 ```
 
 
@@ -582,7 +591,9 @@ After using the bury method default_values will contain:
  :country=>"Spain",
  :mobilePhone=>"(987)654321",
  :sex=>"male",
- :display=>true}
+ :display=>true,
+ :user_names=>["FFrriNdw", "ACc"]
+ }
 ```
 
 ### Validating hashes
@@ -620,7 +631,9 @@ values = {
  :country=>"Iceland",
  :mobilePhone=>"(441)97037845",
  :sex=>"male",
- :display=>true}
+ :display=>true,
+ :user_names=>['ddfdsa']
+ }
 ```
 
 To validate those values against the patterns defined on my_hash:
@@ -801,6 +814,8 @@ The last parameter (patterns) allow you to add verification of data values follo
 Valid patterns:
 - a regular expression
 - any string_pattern, more info: string_pattern project: https://github.com/MarioRuiz/string_pattern
+- array of a string_pattern: 
+  - [ :'10-20:L' ]
 - Boolean: specifying Boolean will check if the value is TrueClass or FalseClass
 - ranges: Any kind of numeric ranges, for example: 
   - 10..400
@@ -885,6 +900,17 @@ value.is_a?(Boolean) #> true
 text.is_a?(Boolean) #> false
 
 ```
+
+#### in?(array)
+Added method in? to all objects that accepts array as a parameter.
+
+```ruby
+'uno'.in?(['uno','dos']) #> true
+:uno.in? [:uno, :dos] #> true
+5.in? [1,2,3,4,6] #> false
+
+```
+
 ### Other tools integration
 
 #### Tabulo

data/lib/nice/hash/add_to_ruby.rb

@@ -292,12 +292,12 @@ class Hash
   alias patterns pattern_fields
 end
 
-###########################################################################
-# symbolize hash of arrays and array of hashes
-# Taken from gist https://gist.github.com/Integralist/9503099
-# Thanks to @integralist
-###########################################################################
 class Object
+  ###########################################################################
+  # symbolize hash of arrays and array of hashes
+  # Taken from gist https://gist.github.com/Integralist/9503099
+  # Thanks to @integralist
+  ###########################################################################
   def deep_symbolize_keys
     if is_a? Hash
       return reduce({}) do |memo, (k, v)|
@@ -312,6 +312,14 @@ class Object
     end
     self
   end
+  
+  ###########################################################################
+  # include? but the opposite. Check if the object is included on the array
+  ###########################################################################
+  def in?(array)
+      array.include?(self)
+  end
+  
 end
 
 class Array

data/lib/nice/hash/compare_structure.rb

@@ -23,6 +23,7 @@ class NiceHash
   #    #>true
   ##################################################
   def NiceHash.compare_structure(structure, replica, compare_only_if_exist_key = false, patterns = {})
+    patterns = {} if patterns.nil?
     unless structure.class == replica.class or
             ((structure.is_a?(TrueClass) or structure.is_a?(FalseClass)) and (replica.is_a?(TrueClass) or replica.is_a?(FalseClass)))
       puts "NiceHash.compare_structure: different object type #{structure.class} is not #{replica.class}. expected: #{structure.inspect}. found: #{replica.inspect}."
@@ -30,16 +31,18 @@ class NiceHash
     end
     success = true
     if structure.is_a?(Hash)
+      patterns = {} unless patterns.is_a?(Hash)
       structure.each do |key, value|
         if patterns.key?(key) and replica.key?(key)
           unless (patterns[key].is_a?(Array) and replica[key].is_a?(Array) and replica[key].empty?) or 
+            (compare_only_if_exist_key and replica.key?(key) and replica[key].nil?) or 
             {key => patterns[key]}.validate({key => replica[key]}).empty?
             puts "NiceHash.compare_structure: key :#{key} not following pattern #{patterns[key]}. value: #{replica[key]}"
             success = false
           end
         end
 
-        if compare_only_if_exist_key and replica.key?(key)
+        if compare_only_if_exist_key and replica.key?(key) and !replica[key].nil?
           unless compare_structure(value, replica[key], compare_only_if_exist_key, patterns)
             puts "NiceHash.compare_structure: key :#{key} different."
             success = false

data/lib/nice/hash/generate.rb

@@ -111,13 +111,24 @@ class NiceHash
           end
         elsif value.kind_of?(Array)
           array_pattern = false
-          value.each { |v|
+          if value.size == 1
+            v = value[0]
             if (v.kind_of?(String) or v.kind_of?(Symbol)) and StringPattern.analyze(v, silent: true).kind_of?(StringPattern::Pattern)
-              hashv[key] = StringPattern.generate(value, expected_errors: expected_errors)
+              hashv[key] = []
+              (rand(5)+1).times do 
+                hashv[key]<<StringPattern.generate(v, expected_errors: expected_errors)
+              end
               array_pattern = true
-              break
             end
-          }
+          else
+            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] = StringPattern.generate(value, expected_errors: expected_errors)
+                array_pattern = true
+                break
+              end
+            }
+          end
           unless array_pattern
             value_ret = Array.new
             value.each { |v|

data/lib/nice/hash/validate.rb

@@ -93,10 +93,18 @@ class NiceHash
               results[key] = false unless value.to_s == values[key].to_s
             end
           elsif value.kind_of?(Range)
-            if values[key].class != value.first.class or values[key].class != value.last.class
-              results[key] = false
-            elsif values[key] < value.first or values[key] > value.last
-              results[key] = false
+            if value.size.to_s == 'Infinity'
+              if values[key].class != value.first.class
+                results[key] = false
+              elsif values[key] < value.first
+                results[key] = false
+              end
+            else
+              if values[key].class != value.first.class or values[key].class != value.last.class
+                results[key] = false
+              elsif values[key] < value.first or values[key] > value.last
+                results[key] = false
+              end
             end
           elsif value.kind_of?(Class) and value == DateTime
             if values[key].is_a?(String) and values[key].size == 24
@@ -118,8 +126,19 @@ class NiceHash
             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
+                if value.is_a?(Array) and value.size == 1 and values[key].is_a?(Array)
+                  results[key] ||= []
+                  values[key].each do |vk|
+                    res = StringPattern.validate(pattern: value[0], text: vk)
+                    results[key] << res
+                  end
+                  if results[key].flatten.size == 0
+                    results.delete(key) 
+                  end
+                else
+                  res = StringPattern.validate(pattern: value, text: values[key])
+                  results[key] = res if res == false
+                end
                 array_pattern = true
                 break
               elsif v.kind_of?(Hash) or v.kind_of?(Array) or v.kind_of?(Struct)
@@ -128,7 +147,7 @@ class NiceHash
               end
             }
             unless array_pattern or results.include?(key)
-              if value.size == 1 and values[key].size > 1
+              if value.size == 1 and values[key].is_a?(Array) and values[key].size > 0
                 # for the case value == ['Ford|Newton|Seat'] and values == ['Ford', 'Newton', 'Ford']
                 i = 0
                 if values[key].class == value.class
@@ -155,10 +174,12 @@ class NiceHash
                 value.each { |v|
                   if v.is_a?(Hash)
                     res = NiceHash.validate([v, select_hash_key], values[key][i], only_patterns: only_patterns)
-                  else
+                  elsif v.is_a?(Array)
                     # for the case {cars: ['Ford|Newton|Seat']}
                     res = NiceHash.validate([{ key => v }, select_hash_key], { key => values[key][i] }, only_patterns: only_patterns)
                     array_pattern = true
+                  else
+                    res = []
                   end
                   if res.size > 0
                     results[key] = Array.new() if !results.keys.include?(key)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nice_hash
 version: !ruby/object:Gem::Version
-  version: 1.15.6
+  version: 1.17.0
 platform: ruby
 authors:
 - Mario Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-11 00:00:00.000000000 Z
+date: 2020-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: string_pattern
@@ -19,7 +19,7 @@ dependencies:
         version: '2.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.1
+        version: 2.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,27 +29,27 @@ dependencies:
         version: '2.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.1
+        version: 2.2.2
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.8.0
+        version: 3.9.0
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.8.0
+        version: 3.9.0
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: '3.9'
 description: 'NiceHash creates hashes following certain patterns so your testing will
   be much easier. Parse and filter JSON. You can easily generate all the hashes you
   want following the criteria you specify. Many other features coming to Hash class