nice_hash 1.19.0 → 1.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7eae7fae66c4ee14c40481157a8cd6e90ec43781b092779a3344c36a7d0d6308
-  data.tar.gz: f3071e0977d3e7e0f0e7ced9699f4823535c1daaa880cbfd7d5693d8329e9513
+  metadata.gz: 718327558f69c77e13b7d19355f990e171eaf199676e8a42ced4bda0c1063827
+  data.tar.gz: d3a086c1262af567acc060fbe6cfb18a6bfbd134b4a1df807e9ee52666f0d4d4
 SHA512:
-  metadata.gz: 72ced814e688ca65212c8812969947ce77f0496c2e7dbc12e2ab9ef9c396db77da473e5c079788206c6fcc24e05d92b1186c85bfe986c634e75e3b7894208b5a
-  data.tar.gz: bce43cdcaa33a6e50a06a364737e3a723156e052b34ba3423574dc4f296743f47c7b089723f72ba2ad617ece70f3ec129617dcf500fc6c5d5cddd8cf8f7bba27
+  metadata.gz: a29e7907b0feca5db0253faa574a1fba185e37ea654881b999ef3f7ea48da52c42294963ad40f19fee657f121dde0ac11f8e41881d1115a7ad89b505d19afc24
+  data.tar.gz: b1eaa9bd0c1f6baf034aaf524222bb584265495c4bb8bf014ceeb5f6404bbe6364db7ce8cf786c4cece3daf670aa2751ca65eea6986c4145930cf5091d065ae3

data/README.md

@@ -1,7 +1,7 @@
 # NiceHash
 
 [![Gem Version](https://badge.fury.io/rb/nice_hash.svg)](https://rubygems.org/gems/nice_hash)
-[![Build Status](https://travis-ci.com/MarioRuiz/nice_hash.svg?branch=master)](https://github.com/MarioRuiz/nice_hash)
+[![CI](https://github.com/MarioRuiz/nice_hash/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/MarioRuiz/nice_hash/actions/workflows/ci.yml)
 [![Coverage Status](https://coveralls.io/repos/github/MarioRuiz/nice_hash/badge.svg?branch=master)](https://coveralls.io/github/MarioRuiz/nice_hash?branch=master)
 ![Gem](https://img.shields.io/gem/dt/nice_hash)
 ![GitHub commit activity](https://img.shields.io/github/commit-activity/y/MarioRuiz/nice_hash)
@@ -79,6 +79,12 @@ Set these constants **before** `require 'nice_hash'` if you need to change defau
 
 When using **string_pattern** 2.4+, you can also set **`StringPattern.logger`** (e.g. `Logger.new($stderr)`) to redirect generation/validation messages, and **`StringPattern.raise_on_error = true`** to raise on invalid patterns or impossible generation instead of returning empty strings.
 
+**Upgrading to 1.20** (requires string_pattern 2.5):
+
+- Update assertions that pin a value produced with `seed:` in 1.19. The same seed now walks one sequence for patterns, ranges, booleans and selectors, so those strings change. Do not expect `:uuid`, `:iban` or `:luhn` to repeat from `seed:`.
+- If `StringPattern.block_list` contains regular expressions, set `StringPattern.block_list_regexp = true`. Otherwise each entry is a literal.
+- A `Regexp` pattern must match the whole value. Update fixtures that used to pass because `$` matched before a newline.
+
 Example:
 
 ```ruby
@@ -90,13 +96,18 @@ require 'nice_hash'
 
 Remember!! To generate the strings following a pattern take a look at the documentation for string_pattern gem: https://github.com/MarioRuiz/string_pattern. You can also generate Spanish or English words. We added support for generating strings from regular expressions but it is only working for the ´generate´ method, use it with caution since it is still on an early stage of development.
 
-For **UUID v4** you can use the shorthand `:uuid` (requires string_pattern 2.4+):
+For **UUID v4**, **email**, **Spanish IBAN** and a **16-digit Luhn** number you can use these shorthands (string_pattern 2.4+ for `:uuid`, 2.5+ for the others):
 
 ```ruby
-my_hash = { id: :uuid, key: "Wsdf88888", doomId: :"10:N" }
-# id will be like "550e8400-e29b-41d4-a716-446655440000"
+my_hash = { id: :uuid, email: :email, iban: :iban, card: :luhn, doomId: :"10:N" }
+# id:   "550e8400-e29b-41d4-a716-446655440000"
+# email: a generated address
+# iban:  a Spanish IBAN (country is always ES)
+# card:  16 digits with a valid Luhn checksum
 ```
 
+`:uuid`, `:iban` and `:luhn` use their own random generator. `seed:` does not make those three fields repeat.
+
 Or use a Regular expression for custom formats:
 
 ```ruby
@@ -403,7 +414,7 @@ new_hash = my_hash.select_key(:correct).generate
 ```
 
 **Reproducible generation (seed)**  
-With **string_pattern** 2.4+, pass `seed:` to get the same hash every time (useful for tests):
+Pass `seed:` to get the same hash every time, including string patterns, ranges, booleans and selectors. One seed advances through the whole hash, so two fields with the same pattern get different values. `:uuid`, `:iban` and `:luhn` stay outside that sequence.
 
 ```ruby
 new_hash = my_hash.generate(:correct, seed: 42)
@@ -417,7 +428,7 @@ Use `generate_n` (alias `gen_n`) to build several different hashes in one call (
 hashes = NiceHash.generate_n(my_hash, 5, :correct)
 hashes = my_hash.generate_n(5, :correct)   # or my_hash.gen_n(5, :correct)
 # With seed: hashes = my_hash.generate_n(5, :correct, seed: 123)
-# => array of 5 hashes
+# the same seed yields the same 5 hashes, and they differ from each other
 ```
 
 In case of filtering by :correct new_hash would have a value like this for example:
@@ -887,6 +898,9 @@ Valid patterns:
 - DateTime: it will verify if the value is following Time stamp string '2019-06-20T12:01:09.971Z' or if the object is a Time, Date or DateTime class
 - selectors, one of the values. Example: "uno|dos|tres"
 - **:uuid** (string_pattern 2.4+): UUID v4 format
+- **:email** (string_pattern 2.5+): email address
+- **:iban** (string_pattern 2.5+): IBAN, generated as Spanish (`ES`)
+- **:luhn** (string_pattern 2.5+): 16 digits with a valid Luhn checksum
 
 ### Other useful methods
 

data/lib/nice/hash/generate.rb

@@ -51,14 +51,26 @@ class NiceHash
   #   new_hash = my_hash.gen(:correct)
   #   new_hash = my_hash.generate(:correct, errors: [:min_length])
   ###########################################################################
+  # One RNG for the whole hash. string_pattern 2.5 no longer seeds Kernel#rand,
+  # so passing seed: on every StringPattern.generate call would restart the sequence.
+  def self.generation_rng(synonyms)
+    rng = synonyms.delete(:_rng)
+    return rng unless rng.nil?
+
+    seed = synonyms.delete(:seed)
+    base = seed.nil? ? Random.new : Random.new(seed)
+    StringPattern::RandomSource.new(base)
+  end
+
   def NiceHash.generate(pattern_hash, select_hash_key = nil, expected_errors: [], **synonyms)
     hashv = Hash.new()
     same_values = Hash.new()
-    expected_errors = synonyms[:errors] if synonyms.keys.include?(:errors)
+    expected_errors = synonyms.delete(:errors) if synonyms.key?(:errors)
     if expected_errors.kind_of?(Symbol)
       expected_errors = [expected_errors]
     end
-    sp_opts = { expected_errors: expected_errors }.merge(synonyms)
+    rng = generation_rng(synonyms)
+    sp_opts = { expected_errors: expected_errors, _rng: rng }.merge(synonyms)
 
     if pattern_hash.kind_of?(Hash) and pattern_hash.size > 0
       pattern_hash.each { |key, value|
@@ -71,16 +83,25 @@ class NiceHash
           if value.keys.include?(select_hash_key)
             value = value[select_hash_key]
           else
-            value = NiceHash.generate(value, select_hash_key, expected_errors: expected_errors, **synonyms)
+            value = NiceHash.generate(value, select_hash_key, expected_errors: expected_errors, _rng: rng, **synonyms)
           end
         end
         if value == :uuid
+          # SecureRandom is not seeded. UUID values are not reproducible via seed:.
           hashv[key] = expected_errors.empty? ? StringPattern.uuid : (StringPattern.uuid[0..-2] + "X")
+        elsif value == :email
+          hashv[key] = StringPattern.generate("20-40:@", **sp_opts)
+        elsif value == :iban
+          # StringPattern.iban uses its own Random, so it is not reproducible via seed:.
+          hashv[key] = expected_errors.empty? ? StringPattern.iban(country: "ES") : "ES00NOTANIBAN"
+        elsif value == :luhn
+          # StringPattern.luhn uses its own Random, so it is not reproducible via seed:.
+          hashv[key] = expected_errors.empty? ? StringPattern.luhn(length: 16) : "1234567890123456"
         elsif 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
             hashv[key] = StringPattern.generate(value, **sp_opts)
           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)
+            if expected_errors.include?(:min_length) or (expected_errors.include?(:length) and rng.rand.round == 0)
               min = value.to_s.split("|").min { |a, b| a.size <=> b.size }
               hashv[key] = min[0..-2] unless min == ""
             end
@@ -94,7 +115,7 @@ class NiceHash
               if hashv.keys.include?(key)
                 v = hashv[key]
               else
-                v = value.to_s.split("|").sample
+                v = value.to_s.split("|").sample(random: rng)
               end
               unless expected_errors.include?(:string_set_not_allowed)
                 v = StringPattern.generate(:"#{v.size}:[#{value.to_s.split("|").join.split(//).uniq.join}]", **sp_opts)
@@ -102,13 +123,13 @@ class NiceHash
               end
               unless hashv.keys.include?(key)
                 # Need a valid 1-char not in the allowed set (do not pass expected_errors)
-                one_wrong_letter = StringPattern.generate(:"1:LN$[%#{value.to_s.split("|").join.split(//).uniq.join}%]")
-                v[rand(v.size)] = one_wrong_letter
+                one_wrong_letter = StringPattern.generate(:"1:LN$[%#{value.to_s.split("|").join.split(//).uniq.join}%]", _rng: rng)
+                v[rng.rand(v.size)] = one_wrong_letter
                 hashv[key] = v unless value.to_s.split("|").include?(v)
               end
             end
             unless hashv.keys.include?(key)
-              hashv[key] = value.to_s.split("|").sample
+              hashv[key] = value.to_s.split("|").sample(random: rng)
             end
           else
             hashv[key] = value
@@ -119,7 +140,7 @@ class NiceHash
             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] = []
-              (rand(5)+1).times do
+              (rng.rand(5)+1).times do
                 hashv[key]<<StringPattern.generate(v, **sp_opts)
               end
               array_pattern = true
@@ -137,9 +158,9 @@ class NiceHash
             value_ret = Array.new
             value.each { |v|
               if v.is_a?(Hash)
-                ret = NiceHash.generate(v, select_hash_key, expected_errors: expected_errors, **synonyms)
+                ret = NiceHash.generate(v, select_hash_key, expected_errors: expected_errors, _rng: rng, **synonyms)
               else
-                ret = NiceHash.generate({ doit: v }, select_hash_key, expected_errors: expected_errors, **synonyms)
+                ret = NiceHash.generate({ doit: v }, select_hash_key, expected_errors: expected_errors, _rng: rng, **synonyms)
                 ret = ret[:doit] if ret.is_a?(Hash) and ret.key?(:doit)
               end
               ret = v if ret.kind_of?(Hash) and ret.size == 0
@@ -152,28 +173,28 @@ class NiceHash
             if value.size == Float::INFINITY
               value = (value.min..2**64)
             end
-            hashv[key] = rand(value)
+            hashv[key] = rng.rand(value)
           else
             if value.size == Float::INFINITY
               infinite = true
               value = (value.min..2**64)
             else
               infinite = false
-              hashv[key] = rand(value)
+              hashv[key] = rng.rand(value)
             end
             expected_errors.each do |er|
               if er == :min_length
-                hashv[key] = rand((value.first - value.last)..value.first - 1)
+                hashv[key] = rng.rand((value.first - value.last)..value.first - 1)
               elsif er == :max_length and !infinite
-                hashv[key] = rand((value.last + 1)..(value.last * 2))
+                hashv[key] = rng.rand((value.last + 1)..(value.last * 2))
               elsif er == :length
-                if rand.round == 1 or infinite
-                  hashv[key] = rand((value.first - value.last)..value.first - 1)
+                if rng.rand.round == 1 or infinite
+                  hashv[key] = rng.rand((value.first - value.last)..value.first - 1)
                 else
-                  hashv[key] = rand((value.last + 1)..(value.last * 2))
+                  hashv[key] = rng.rand((value.last + 1)..(value.last * 2))
                 end
               elsif er == :value
-                hashv[key] = :"1-10:N/L/".gen
+                hashv[key] = StringPattern.generate(:"1-10:N/L/", _rng: rng)
               end
             end
           end
@@ -188,24 +209,24 @@ class NiceHash
               elsif er == :max_length
                 hashv[key] = hashv[key] + "Z"
               elsif er == :length
-                if rand.round == 1
+                if rng.rand.round == 1
                   hashv[key] = hashv[key].chop
                 else
                   hashv[key] = hashv[key] + "Z"
                 end
               elsif er == :value
-                hashv[key][rand(hashv[key].size - 1)] = "1:L".gen
+                hashv[key][rng.rand(hashv[key].size - 1)] = StringPattern.generate("1:L", _rng: rng)
               end
             end
           end
         elsif value.kind_of?(Module) and value == Boolean
           if expected_errors.empty?
-            hashv[key] = (rand.round == 0)
+            hashv[key] = (rng.rand.round == 0)
           else
-            hashv[key] = (rand.round == 0)
+            hashv[key] = (rng.rand.round == 0)
             expected_errors.each do |er|
               if er == :value
-                hashv[key] = "1-10:L".gen
+                hashv[key] = StringPattern.generate("1-10:L", _rng: rng)
               end
             end
           end
@@ -243,6 +264,9 @@ class NiceHash
   #   hashes = my_hash.generate_n(5, :correct)
   ###########################################################################
   def NiceHash.generate_n(pattern_hash, n, select_hash_key = nil, expected_errors: [], **synonyms)
-    n.times.map { NiceHash.generate(pattern_hash, select_hash_key, expected_errors: expected_errors, **synonyms) }
+    rng = generation_rng(synonyms)
+    n.times.map { NiceHash.generate(pattern_hash, select_hash_key, expected_errors: expected_errors, _rng: rng, **synonyms) }
   end
+
+  private_class_method :generation_rng
 end

data/lib/nice/hash/validate.rb

@@ -85,6 +85,12 @@ class NiceHash
         if values.keys.include?(key)
           if value == :uuid
             results[key] = false unless StringPattern.valid_uuid?(values[key].to_s)
+          elsif value == :email
+            results[key] = false unless StringPattern.valid_email?(values[key].to_s)
+          elsif value == :iban
+            results[key] = false unless StringPattern.valid_iban?(values[key].to_s)
+          elsif value == :luhn
+            results[key] = false unless StringPattern.valid_luhn?(values[key].to_s)
           elsif 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])
@@ -119,10 +125,8 @@ class NiceHash
           elsif value.kind_of?(Module) and value == Boolean
             results[key] = false unless values[key].is_a?(Boolean)
           elsif value.kind_of?(Regexp)
-            rex = Regexp.new("^#{value}$")
-            unless values[key].to_s.match?(rex)
-              results[key] = false
-            end
+            res = StringPattern.validate(text: values[key].to_s, pattern: value)
+            results[key] = false unless res == true || (res.is_a?(Array) && res.empty?)
           elsif value.kind_of?(Array)
             array_pattern = false
             complex_data = false

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nice_hash
 version: !ruby/object:Gem::Version
-  version: 1.19.0
+  version: 1.20.0
 platform: ruby
 authors:
 - Mario Ruiz
@@ -15,20 +15,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '2.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.4.0
+        version: 2.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '2.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.4.0
+        version: 2.5.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement