nice_hash 1.18.7 → 1.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c8cb3e741e17cf400b34bc3a31ec874fb030466b2f56431f0ec5aa79e37af7f
-  data.tar.gz: f023c96b5a5768bac968765032c782d1d01e9705f778748903fb75a0b91d582e
+  metadata.gz: 718327558f69c77e13b7d19355f990e171eaf199676e8a42ced4bda0c1063827
+  data.tar.gz: d3a086c1262af567acc060fbe6cfb18a6bfbd134b4a1df807e9ee52666f0d4d4
 SHA512:
-  metadata.gz: 448740fdbc4843c705ac79d5d33ba6fcfdf453e7ff76d1a0cf77fa2a648c37ca99d441fcef8378030e2de77a100d907832e216938948c9f3b8ebba3e8ef75b8a
-  data.tar.gz: 6d3acf6139d0612d7d3ae45b5fec8ca19ba66262f9b4f6b71c26e66c4ca1df68f60a7d6f120307e267d06752d3db3fec43265e82004bf1ef9143ec4ea89531ed
+  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)
@@ -22,31 +22,37 @@ To generate the strings following a pattern take a look at the documentation for
 To use nice_hash on Http connections take a look at nice_http gem: https://github.com/MarioRuiz/nice_http
 
 ## Table of contents
-- [Installation](#installation)
-- [Usage](#usage)
-  * [How to access the different keys](#how-to-access-the-different-keys)
-  * [Change all values on the keys we specified](#change-all-values-on-the-keys-we-specified)
-  * [Filtering / Selecting an specific key on the hash and subhashes](#filtering---selecting-an-specific-key-on-the-hash-and-subhashes)
-  * [How to generate the hash with the criteria we want](#how-to-generate-the-hash-with-the-criteria-we-want)
-  * [How to generate the hash with wrong values for the string patterns specified on the hash](#how-to-generate-the-hash-with-wrong-values-for-the-string-patterns-specified-on-the-hash)
-  * [Return the select_fields or the pattern_fields](#return-the-select-fields-or-the-pattern-fields)
-  * [dig and bury Hash methods](#dig-and-bury-hash-methods)
-  * [Validating hashes](#validating-hashes)
-  * [Change only one value at a time and return an Array of Hashes](#change-only-one-value-at-a-time-and-return-an-array-of-hashes)
-  * [Adding other values on run time when calling `generate` method](#adding-other-values-on-run-time-when-calling--generate--method)
-    + [Accessing other values of the hash on run time](#accessing-other-values-of-the-hash-on-run-time)
-  * [Compare the structure of a replica with the supplied structure](#compare-the-structure-of-a-replica-with-the-supplied-structure)
-  * [Other useful methods](#other-useful-methods)
-    + [Time stamp](#time-stamp)
-    + [Random dates](#random-dates)
-    + [Deep copy of a hash](#deep-copy-of-a-hash)
-    + [Nested deletion](#nested-deletion)
-    + [Deep merge of two hashes](#deep-merge-of-two-hashes)
-    + [Boolean class](#boolean-class)
-  * [Other tools integration](#other-tools-integration)
-    + [Tabulo](#tabulo)
-- [Contributing](#contributing)
-- [License](#license)
+- [NiceHash](#nicehash)
+  - [Table of contents](#table-of-contents)
+  - [Installation](#installation)
+  - [Configuration](#configuration)
+  - [Usage](#usage)
+    - [How to access the different keys](#how-to-access-the-different-keys)
+    - [Change all values on the keys we specified](#change-all-values-on-the-keys-we-specified)
+    - [Filtering / Selecting an specific key on the hash and subhashes](#filtering--selecting-an-specific-key-on-the-hash-and-subhashes)
+    - [How to generate the hash with the criteria we want](#how-to-generate-the-hash-with-the-criteria-we-want)
+    - [How to generate the hash with wrong values for the string patterns specified on the hash](#how-to-generate-the-hash-with-wrong-values-for-the-string-patterns-specified-on-the-hash)
+    - [Return the select\_fields or the pattern\_fields](#return-the-select_fields-or-the-pattern_fields)
+    - [dig and bury Hash methods](#dig-and-bury-hash-methods)
+    - [Validating hashes](#validating-hashes)
+    - [Change only one value at a time and return an Array of Hashes](#change-only-one-value-at-a-time-and-return-an-array-of-hashes)
+    - [Adding other values on run time when calling `generate` method](#adding-other-values-on-run-time-when-calling-generate-method)
+      - [Accessing other values of the hash on run time](#accessing-other-values-of-the-hash-on-run-time)
+    - [Compare the structure of a replica with the supplied structure](#compare-the-structure-of-a-replica-with-the-supplied-structure)
+    - [Other useful methods](#other-useful-methods)
+      - [Hash diff](#hash-diff)
+      - [Flatten / unflatten keys](#flatten--unflatten-keys)
+      - [Time stamp](#time-stamp)
+      - [Random dates](#random-dates)
+      - [Deep copy of a hash](#deep-copy-of-a-hash)
+      - [Nested deletion](#nested-deletion)
+      - [Deep merge of two hashes](#deep-merge-of-two-hashes)
+      - [Boolean class](#boolean-class)
+      - [in?(array)](#inarray)
+    - [Other tools integration](#other-tools-integration)
+      - [Tabulo](#tabulo)
+  - [Contributing](#contributing)
+  - [License](#license)
 
 ## Installation
 
@@ -64,9 +70,45 @@ Or install it yourself as:
 
     $ gem install nice_hash
 
+## Configuration
+
+Set these constants **before** `require 'nice_hash'` if you need to change default behavior:
+
+- **`SP_ADD_TO_RUBY`** (default: `true`): When `true`, the gem adds methods to core classes (`Hash`, `Array`, `String`, `Object`, `Date`, `Time`, etc.). Set to `false` to avoid patching core classes and use only `NiceHash` class methods.
+- **`SP_COMPARE_NUMBERS_AS_STRINGS`** (default: `true`): When `true`, `String#==` is overridden so that strings are compared with numbers as strings (e.g. `'300' == 300` and `'' == nil`). Set to `false` if this causes issues with other gems (e.g. some versions of `net/ldap`).
+
+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
+SP_COMPARE_NUMBERS_AS_STRINGS = false
+require '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. 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. All you have to do is to add to a key the value as a Regular expression, for example the key uuid in here will generate a random value like this: "E0BDE5B5-A738-49E6-83C1-9D1FFB313788"
+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**, **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, 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
 my_hash = { 
@@ -371,6 +413,23 @@ new_hash = my_hash.generate(:correct)
 new_hash = my_hash.select_key(:correct).generate
 ```
 
+**Reproducible generation (seed)**  
+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)
+# Same result every time for the same seed
+```
+
+**Generate n hashes at once**  
+Use `generate_n` (alias `gen_n`) to build several different hashes in one call (e.g. for bulk or boundary tests):
+
+```ruby
+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)
+# 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:
 
@@ -838,9 +897,38 @@ Valid patterns:
   - 10.. (from 10 to infinite) Only from Ruby 2.6
 - 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
 
+#### Hash diff
+Compare two hashes and get differences with dot-notation paths (useful for API or test assertions):
+
+```ruby
+expected = { user: { address: { city: "Madrid" } } }
+actual   = { user: { address: { city: "London" } } }
+NiceHash.diff(expected, actual)
+#=> { "user.address.city" => { expected: "Madrid", got: "London" } }
+
+# Or on a hash instance:
+expected.diff(actual)
+```
+
+#### Flatten / unflatten keys
+Convert between nested hashes and flat hashes with dot-notation keys:
+
+```ruby
+h = { user: { address: { city: "Madrid" } } }
+h.flatten_keys
+#=> { "user.address.city" => "Madrid" }
+
+{ "user.address.city" => "Madrid" }.unflatten_keys
+#=> { user: { address: { city: "Madrid" } } }
+```
+
 #### Time stamp
 In case you need the time stamp, we added the method `stamp` to the `Time` class
 

data/lib/nice/hash/add_to_ruby.rb

@@ -166,6 +166,16 @@ class Hash
   #   my_hash.city="Paris"
   #   my_hash.products[1].price.wrong="AAAAA"
   ###########################################################################
+  def respond_to_missing?(method_name, include_private = false)
+    sym = (method_name.to_s[0] == "_" ? method_name.to_s[1..-1].to_sym : method_name)
+    return true if key?(sym) || key?(sym.to_s)
+    if method_name.to_s[-1] == "="
+      setter_key = method_name.to_s.chop
+      return true if key?(setter_key) || key?(setter_key.to_sym)
+    end
+    false
+  end
+
   def method_missing(m, *arguments, &block)
     m = m[1..-1].to_sym if m[0] == "_"
     if key?(m)
@@ -231,6 +241,13 @@ class Hash
     NiceHash.generate(self, select_hash_key, expected_errors: expected_errors, **synonyms)
   end
 
+  ###########################################################################
+  # Generates n different hashes from the same pattern. More info: NiceHash.generate_n
+  ###########################################################################
+  def generate_n(n, select_hash_key = nil, expected_errors: [], **synonyms)
+    NiceHash.generate_n(self, n, 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
@@ -298,6 +315,28 @@ class Hash
     NiceHash.nice_filter(self, keys)
   end
 
+  ###########################################################################
+  # Compares with another hash and returns differences with dot-notation paths.
+  # More info: NiceHash.diff
+  ###########################################################################
+  def diff(other)
+    NiceHash.diff(self, other)
+  end
+
+  ###########################################################################
+  # Flattens the hash to dot-notation keys. More info: NiceHash.flatten_keys
+  ###########################################################################
+  def flatten_keys
+    NiceHash.flatten_keys(self)
+  end
+
+  ###########################################################################
+  # Unflattens a hash with dot-notation keys into nested hash. More info: NiceHash.unflatten_keys
+  ###########################################################################
+  def unflatten_keys
+    NiceHash.unflatten_keys(self)
+  end
+
   ###########################################################################
   # Merging multi-dimensional hashes
   ###########################################################################
@@ -322,6 +361,7 @@ class Hash
   end
 
   alias gen generate
+  alias gen_n generate_n
   alias val validate
   alias patterns pattern_fields
   alias nice_copy deep_copy
@@ -365,6 +405,11 @@ class Array
   #   my_array.city
   #   my_array._name
   ###########################################################################
+  def respond_to_missing?(method_name, include_private = false)
+    sym = (method_name.to_s[0] == "_" ? method_name.to_s[1..-1].to_sym : method_name)
+    any? { |elem| elem.is_a?(Hash) && (elem.key?(sym) || elem.key?(sym.to_s)) }
+  end
+
   def method_missing(m, *arguments, &block)
     m = m[1..-1].to_sym if m[0] == "_"
     array = []

data/lib/nice/hash/deep_clone.rb

@@ -21,6 +21,7 @@ class NiceHash
   #    #>{:user=>{:address=>{:city=>"Madrid", :country=>"Spain"}, :name=>"Peter", :age=>33}, :customer=>true}
   ##################################################
   def self.deep_clone(obj)
+    return obj.clone unless obj.is_a?(Array) || obj.is_a?(Hash)
     obj.clone.tap do |new_obj|
       if new_obj.is_a?(Array)
         new_obj.each_with_index do |val, i|
@@ -30,8 +31,6 @@ class NiceHash
         new_obj.each do |key, val|
           new_obj[key] = deep_clone(val)
         end
-      else
-        new_obj = obj.clone
       end
     end
   end

data/lib/nice/hash/delete_nested.rb

@@ -27,11 +27,16 @@ class NiceHash
     if keys.size == 1
       hash.delete(nested_key.to_sym)
     else
-      last_key = keys[-1]
-      eval("hash.#{keys[0..(keys.size - 2)].join(".")}.delete(:#{last_key})")
+      parent = hash
+      keys[0..-2].each do |k|
+        sym = k.to_sym
+        return hash unless parent.is_a?(Hash) && parent.key?(sym)
+        parent = parent[sym]
+      end
+      parent.delete(keys[-1].to_sym) if parent.is_a?(Hash)
     end
     return hash
   end
 
- 
-end
+
+end

data/lib/nice/hash/diff.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class NiceHash
+  ##################################################
+  # Compares two hashes and returns differences with dot-notation paths.
+  #
+  # @param expected [Hash, Array] Expected structure (hash or array of hashes)
+  # @param actual [Hash, Array] Actual structure to compare
+  # @param prefix [String] Internal: current path prefix for recursion
+  #
+  # @return [Hash] Path => { expected: value, got: value } for each difference
+  #
+  # @example
+  #   expected = { user: { address: { city: "Madrid" } } }
+  #   actual   = { user: { address: { city: "London" } } }
+  #   NiceHash.diff(expected, actual)
+  #   #=> { "user.address.city" => { expected: "Madrid", got: "London" } }
+  ##################################################
+  def self.diff(expected, actual, prefix = "")
+    result = {}
+    exp_keys = expected.is_a?(Hash) ? expected.keys : (expected.is_a?(Array) ? (0...expected.size) : nil)
+    act_keys = actual.is_a?(Hash) ? actual.keys : (actual.is_a?(Array) ? (0...actual.size) : nil)
+
+    if expected.is_a?(Hash) && actual.is_a?(Hash)
+      all_keys = (expected.keys + actual.keys).uniq
+      all_keys.each do |k|
+        path = prefix.empty? ? k.to_s : "#{prefix}.#{k}"
+        exp_v = expected[k]
+        act_v = actual[k]
+        if !expected.key?(k)
+          result[path] = { expected: nil, got: act_v }
+        elsif !actual.key?(k)
+          result[path] = { expected: exp_v, got: nil }
+        elsif exp_v.is_a?(Hash) && act_v.is_a?(Hash)
+          result.merge!(diff(exp_v, act_v, path))
+        elsif exp_v.is_a?(Array) && act_v.is_a?(Array)
+          max_len = [exp_v.size, act_v.size].max
+          max_len.times do |i|
+            result.merge!(diff(exp_v[i], act_v[i], "#{path}[#{i}]"))
+          end
+        elsif exp_v != act_v
+          result[path] = { expected: exp_v, got: act_v }
+        end
+      end
+    elsif expected.is_a?(Array) && actual.is_a?(Array)
+      max_len = [expected.size, actual.size].max
+      max_len.times do |i|
+        result.merge!(diff(expected[i], actual[i], prefix.empty? ? "[#{i}]" : "#{prefix}[#{i}]"))
+      end
+    elsif expected != actual
+      result[prefix] = { expected: expected, got: actual } unless prefix.empty?
+    end
+    result
+  end
+end

data/lib/nice/hash/flatten_keys.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+class NiceHash
+  ##################################################
+  # Flattens a nested hash so keys become dot-notation strings.
+  #
+  # @param hash [Hash] The hash to flatten
+  # @param prefix [String] Internal: current path prefix for recursion
+  #
+  # @return [Hash] Flat hash with string keys like "user.address.city"
+  #
+  # @example
+  #   NiceHash.flatten_keys({ user: { address: { city: "Madrid" } } })
+  #   #=> { "user.address.city" => "Madrid" }
+  ##################################################
+  def self.flatten_keys(hash, prefix = "")
+    return {} unless hash.is_a?(Hash)
+    result = {}
+    hash.each do |k, v|
+      path = prefix.empty? ? k.to_s : "#{prefix}.#{k}"
+      if v.is_a?(Hash)
+        result.merge!(flatten_keys(v, path))
+      else
+        result[path] = v
+      end
+    end
+    result
+  end
+
+  ##################################################
+  # Unflattens a hash with dot-notation keys into a nested hash.
+  #
+  # @param hash [Hash] Flat hash with string keys like "user.address.city"
+  #
+  # @return [Hash] Nested hash
+  #
+  # @example
+  #   NiceHash.unflatten_keys({ "user.address.city" => "Madrid" })
+  #   #=> { user: { address: { city: "Madrid" } } }
+  ##################################################
+  def self.unflatten_keys(hash)
+    return {} unless hash.is_a?(Hash)
+    result = {}
+    hash.each do |key_str, value|
+      keys = key_str.to_s.split(".")
+      keys = keys.map { |k| k.match?(/\A\d+\z/) ? k.to_i : k.to_sym }
+      current = result
+      keys[0..-2].each do |k|
+        current[k] = {} unless current[k].is_a?(Hash)
+        current = current[k]
+      end
+      current[keys[-1]] = value
+    end
+    result
+  end
+end

data/lib/nice/hash/generate.rb

@@ -51,13 +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
+    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|
@@ -70,14 +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)
+            value = NiceHash.generate(value, select_hash_key, expected_errors: expected_errors, _rng: rng, **synonyms)
           end
         end
-        if value.kind_of?(String) or value.kind_of?(Symbol)
+        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, expected_errors: expected_errors)
+            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
@@ -91,20 +115,21 @@ 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}]")
+                v = StringPattern.generate(:"#{v.size}:[#{value.to_s.split("|").join.split(//).uniq.join}]", **sp_opts)
                 hashv[key] = v unless value.to_s.split("|").include?(v)
               end
               unless hashv.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
+                # 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}%]", _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
@@ -115,15 +140,15 @@ 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 
-                hashv[key]<<StringPattern.generate(v, expected_errors: expected_errors)
+              (rng.rand(5)+1).times do
+                hashv[key]<<StringPattern.generate(v, **sp_opts)
               end
               array_pattern = true
             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)
+                hashv[key] = StringPattern.generate(value, **sp_opts)
                 array_pattern = true
                 break
               end
@@ -133,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)
+                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)
+                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
@@ -148,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
@@ -184,31 +209,31 @@ 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
         elsif value.kind_of?(Proc)
           hashv[key] = value.call
         elsif value.kind_of?(Regexp)
-          hashv[key] = value.generate(expected_errors: expected_errors)
+          hashv[key] = value.generate(**sp_opts)
         else
           hashv[key] = value
         end
@@ -225,5 +250,23 @@ class NiceHash
 
     return hashv
   end
-    
-end
+
+  ###########################################################################
+  # Generates n different hashes from the same pattern (useful for bulk or boundary tests).
+  # input:
+  #   pattern_hash: (Hash) Hash we want to use to generate the values
+  #   n: (Integer) Number of hashes to generate
+  #   select_hash_key: (key value) (optional) The key we want to select on the subhashes
+  #   expected_errors: (Array) (optional) (alias: errors) Same as in generate
+  # output: (Array of Hash)
+  # examples:
+  #   hashes = NiceHash.generate_n(my_hash, 5, :correct)
+  #   hashes = my_hash.generate_n(5, :correct)
+  ###########################################################################
+  def NiceHash.generate_n(pattern_hash, n, select_hash_key = nil, 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/set_nested.rb

@@ -28,27 +28,19 @@ class NiceHash
     if keys.size == 1
       hash[nested_key.to_sym] = value unless only_if_exist and !hash.key?(nested_key.to_sym)
     else
-      exist = true
-      if only_if_exist
-        ht = hash.deep_copy
-        keys.each do |k|
-          unless ht.key?(k.to_sym)
-            exist = false
-            break
-          end
-          ht = ht[k.to_sym]
-        end
+      parent = hash
+      keys[0..-2].each do |k|
+        sym = k.to_sym
+        return hash unless parent.is_a?(Hash) && parent.key?(sym)
+        parent = parent[sym]
       end
-      if !only_if_exist or (only_if_exist and exist)
-        if value.is_a?(String)
-          eval("hash.#{nested_key}='#{value}'")
-        else
-          #todo: consider other kind of objects apart of strings
-          eval("hash.#{nested_key}=#{value}")
-        end
+      return hash unless parent.is_a?(Hash)
+      if only_if_exist
+        return hash unless parent.key?(keys[-1].to_sym)
       end
+      parent[keys[-1].to_sym] = value
     end
     return hash
   end
- 
-end
+
+end

data/lib/nice/hash/validate.rb

@@ -59,7 +59,7 @@ class NiceHash
     end
     values = values_hash_to_validate
     if pattern_hash.keys.size == get_all_keys(pattern_hash).size and values.keys.size != get_all_keys(values) and
-      pattern_hash.keys.size == pattern_hash.keys.flatten.size # dont't set_values for the case of same_value 
+      pattern_hash.keys.size == pattern_hash.keys.flatten.size # dont't set_values for the case of same_value
       # all patterns on patterns_hash are described on first level, so no same structure than values
       pattern_hash = values.set_values(pattern_hash)
     end
@@ -83,7 +83,15 @@ class NiceHash
         end
 
         if values.keys.include?(key)
-          if value.kind_of?(String) or value.kind_of?(Symbol)
+          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])
               results[key] = res if res.size > 0
@@ -117,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
@@ -133,7 +139,7 @@ class NiceHash
                     results[key] << res
                   end
                   if results[key].flatten.size == 0
-                    results.delete(key) 
+                    results.delete(key)
                   end
                 else
                   res = StringPattern.validate(pattern: value, text: values[key])
@@ -213,5 +219,5 @@ class NiceHash
     return results
   end
 
-    
-end
+
+end

data/lib/nice_hash.rb

@@ -5,6 +5,8 @@ require_relative "nice/hash/add_to_ruby" if SP_ADD_TO_RUBY
 require_relative "nice/hash/change_one_by_one"
 require_relative "nice/hash/compare_structure"
 require_relative "nice/hash/delete_nested"
+require_relative "nice/hash/diff"
+require_relative "nice/hash/flatten_keys"
 require_relative "nice/hash/generate"
 require_relative "nice/hash/get_all_keys"
 require_relative "nice/hash/get_values"

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: nice_hash
 version: !ruby/object:Gem::Version
-  version: 1.18.7
+  version: 1.20.0
 platform: ruby
 authors:
 - Mario Ruiz
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-19 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: string_pattern
@@ -16,20 +15,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: 2.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: 2.5.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -71,6 +70,8 @@ files:
 - lib/nice/hash/compare_structure.rb
 - lib/nice/hash/deep_clone.rb
 - lib/nice/hash/delete_nested.rb
+- lib/nice/hash/diff.rb
+- lib/nice/hash/flatten_keys.rb
 - lib/nice/hash/generate.rb
 - lib/nice/hash/get_all_keys.rb
 - lib/nice/hash/get_values.rb
@@ -95,15 +96,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 4.0.6
 specification_version: 4
 summary: NiceHash creates hashes following certain patterns so your testing will be
   much easier. Parse and filter JSON. Perfect to be used in test data factories