nice_hash 1.15.2 → 1.15.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b3dfa4920ee6ffc492f91f20f01fdad4e22953a681bd5071d7f7f72ecbed4eb
-  data.tar.gz: 357269895379ab1744886a6107493f339820e4a5cf4bd81ddd9ed4f7ecb94de9
+  metadata.gz: 5e1518b1eb83a00333a4051d91aa0b40fb9fe58e4b0b3ad229fcc78b0f86eb56
+  data.tar.gz: 69c215835f068a459dfc0e01605c45c42a5447e4e818eeabfac3f90a746c6012
 SHA512:
-  metadata.gz: acbd759da3e565e4493cd6c6b082e31248124cd93dec40d9572a695d2055ec4c34850c82c19f2e548e8c71c31a0504d6ae4cf0e4b4457d789eb90b299a1d6eee
-  data.tar.gz: 80f5adf41b3c01f6c32aff59ff8410c507e53f937aa794523485699afc8ca796934f72b9cc3ec22ec8797265b62d7c96413b4d9d058b58f136943e47367904ef
+  metadata.gz: f61c5845665e7dcddf367e2850afb0d83b95bef3d39c8931be7bce5f27ffc24d6352b5c13d9a600f0d128fc25b1ff8332a2796943abf7f6fe647c4ac9739830e
+  data.tar.gz: 6f5ae2c245b192ee7ee331bf6d1a990551dd5e57e93997d168e83a3acfa2d471649ca83e06efdc0a3e18f4f948b1a7e594a6bdd5a2de916745bc9339e2228994

data/.yardopts

@@ -5,6 +5,6 @@
 -
 lib/**/*.rb 
 lib/nice_hash.rb
-lib/nice/hash/add_to_ruby.rb
+lib/nice/hash/*.rb
 *.md
 LICENSE

data/lib/nice/hash/change_one_by_one.rb

@@ -0,0 +1,49 @@
+class NiceHash
+  ###########################################################################
+  # 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

data/lib/nice/hash/compare_structure.rb

@@ -0,0 +1,69 @@
+class NiceHash
+  ##################################################
+  #  Analyzes the supplied replica and verifies that the structure follows the one supplied on structure
+  #
+  #  @param structure [Array] [Hash] Contains the structure that should follow the replica. It can be a nested combination of arrays and hashes.
+  #  @param replica [Array] [Hash] Contains the element to be verified on following the supplied structure. It can be a nested combination of arrays and hashes.
+  #  @param compare_only_if_exist_key [Boolean] (Default false) If true, in case an element exist on structure but doesn't exist on replica won't be verified.
+  #  @param patterns [Hash] add verification of data values following the patterns supplied on a one level hash
+  #
+  #  @return [Boolean] true in case replica follows the structure supplied
+  #
+  #  @example
+  #    my_structure = [
+  #      {  name: 'xxx',
+  #         zip: 'yyyy',
+  #         customer: true,
+  #         product_ids: [1]
+  #      }
+  #    ]
+  #    my_replica = [ {name: 'Peter Ben', zip: '1121A', customer: false, product_ids: []},
+  #                   {name: 'John Woop', zip: '74014', customer: true, product_ids: [10,120,301]}]
+  #    NiceHash.compare_structure(my_structure, my_replica)
+  #    #>true
+  ##################################################
+  def NiceHash.compare_structure(structure, replica, compare_only_if_exist_key = false, patterns = {})
+    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}."
+      return false
+    end
+    success = true
+    if structure.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 
+            {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)
+          unless compare_structure(value, replica[key], compare_only_if_exist_key, patterns)
+            puts "NiceHash.compare_structure: key :#{key} different."
+            success = false
+          end
+        elsif compare_only_if_exist_key == false
+          unless replica.key?(key)
+            puts "NiceHash.compare_structure: key :#{key} missing."
+            success = false
+          else
+            unless compare_structure(value, replica[key], compare_only_if_exist_key, patterns)
+              puts "NiceHash.compare_structure: key :#{key} different."
+              success = false
+            end
+          end
+        end
+      end
+    elsif structure.is_a?(Array)
+      # compare all elements of replica with the structure of the first element on structure
+      replica.each do |elem|
+        unless compare_structure(structure[0], elem, compare_only_if_exist_key, patterns)
+          success = false
+        end
+      end
+    end
+    return success
+  end 
+end

data/lib/nice/hash/delete_nested.rb

@@ -0,0 +1,37 @@
+class NiceHash
+  ##################################################
+  #  Deletes the supplied nested key
+  #
+  #  @param hash [Hash] The hash we want
+  #  @param nested_key [Hash] [String] String with the nested key: 'uno.dos.tres' or a hash { uno: {dos: :tres} }
+  #
+  #  @return [Hash]
+  #
+  #  @example
+  #  my_hash = { user: {
+  #                      address: {
+  #                             city: 'Madrid',
+  #                             country: 'Spain'
+  #                          },
+  #                      name: 'Peter',
+  #                      age: 33
+  #                    },
+  #              customer: true
+  #  }
+  #    NiceHash.delete_nested(my_hash, 'user.address.city')
+  #    #>{:user=>{:address=>{:country=>"Spain"}, :name=>"Peter", :age=>33}, :customer=>true}
+  ##################################################
+  def self.delete_nested(hash, nested_key)
+    nested_key = transtring(nested_key)
+    keys = nested_key.split(".")
+    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})")
+    end
+    return hash
+  end
+
+ 
+end

data/lib/nice/hash/generate.rb

@@ -0,0 +1,209 @@
+class NiceHash
+
+  ###########################################################################
+  # 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)
+    hashv = 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
+            hashv[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 }
+              hashv[key] = min[0..-2] unless min == ""
+            end
+            if !hashv.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 }
+              hashv[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 hashv.keys.include?(key)
+                v = hashv[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}]")
+                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
+                hashv[key] = v unless value.to_s.split("|").include?(v)
+              end
+            end
+            unless hashv.keys.include?(key)
+              hashv[key] = value.to_s.split("|").sample
+            end
+          else
+            hashv[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)
+              hashv[key] = StringPattern.generate(value, expected_errors: expected_errors)
+              array_pattern = true
+              break
+            end
+          }
+          unless array_pattern
+            value_ret = Array.new
+            value.each { |v|
+              if v.is_a?(Hash)
+                ret = NiceHash.generate(v, select_hash_key, expected_errors: expected_errors)
+              else
+                ret = NiceHash.generate({ doit: v }, select_hash_key, expected_errors: expected_errors)
+                ret = ret[:doit] if ret.is_a?(Hash) and ret.key?(:doit)
+              end
+              ret = v if ret.kind_of?(Hash) and ret.size == 0
+              value_ret << ret
+            }
+            hashv[key] = value_ret
+          end
+        elsif value.kind_of?(Range)
+          if expected_errors.empty?
+            hashv[key] = rand(value)
+          else
+            hashv[key] = rand(value)
+            expected_errors.each do |er|
+              if er == :min_length
+                hashv[key] = rand((value.first - value.last)..value.first - 1)
+              elsif er == :max_length
+                hashv[key] = rand((value.last + 1)..(value.last * 2))
+              elsif er == :length
+                if rand.round == 1
+                  hashv[key] = rand((value.first - value.last)..value.first - 1)
+                else
+                  hashv[key] = rand((value.last + 1)..(value.last * 2))
+                end
+              elsif er == :value
+                hashv[key] = :"1-10:N/L/".gen
+              end
+            end
+          end
+        elsif value.kind_of?(Class) and value == DateTime
+          if expected_errors.empty?
+            hashv[key] = Time.now.stamp
+          else
+            hashv[key] = Time.now.stamp
+            expected_errors.each do |er|
+              if er == :min_length
+                hashv[key] = hashv[key].chop
+              elsif er == :max_length
+                hashv[key] = hashv[key] + "Z"
+              elsif er == :length
+                if 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
+              end
+            end
+          end
+        elsif value.kind_of?(Module) and value == Boolean
+          if expected_errors.empty?
+            hashv[key] = (rand.round == 0)
+          else
+            hashv[key] = (rand.round == 0)
+            expected_errors.each do |er|
+              if er == :value
+                hashv[key] = "1-10:L".gen
+              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)
+        else
+          hashv[key] = value
+        end
+
+        if same_values.include?(key)
+          same_values[key].each { |k|
+            hashv[k] = hashv[key]
+          }
+        end
+
+        @values = hashv
+      }
+    end
+
+    return hashv
+  end
+    
+end

data/lib/nice/hash/get_all_keys.rb

@@ -0,0 +1,26 @@
+class NiceHash
+  ##################################################
+  #  Get all the keys of a hash
+  #
+  #  @param hash [Hash] The hash
+  #
+  #  @return [Array]
+  #
+  #  @example
+  #    my_hash =  { uno: {dos: {tres: 3}} }
+  #    NiceHash.get_all_keys(my_hash)
+  #    #>[:uno, :dos, :tres]
+  ##################################################
+  def self.get_all_keys(h)
+    h.each_with_object([]) do |(k, v), keys|
+      keys << k
+      keys.concat(get_all_keys(v)) if v.is_a? Hash
+      if v.is_a?(Array)
+        v.each do |vv|
+          keys.concat(get_all_keys(vv)) if vv.is_a? Hash or vv.is_a? Array
+        end
+      end
+    end
+  end
+ 
+end

data/lib/nice/hash/get_values.rb

@@ -0,0 +1,152 @@
+class NiceHash
+
+  ##################################################
+  # Get values from the Hash structure (array of Hashes allowed)
+  #   In case the key supplied doesn't exist in the hash then it will be returned nil for that one
+  # input:
+  #   hashv: a simple hash or a hash containing arrays. Example:
+  #    example={"id"=>344,
+  #              "customer"=>{
+  #                  "name"=>"Peter Smith",
+  #                  "phone"=>334334333
+  #              },
+  #              "tickets"=>[
+  #                {"idt"=>345,"name"=>"myFavor1"},
+  #                {"idt"=>3123},
+  #                {"idt"=>3145,"name"=>"Special ticket"}
+  #              ]
+  #            }
+  #   keys: one key (string) or an array of keys. key can be a nested key
+  # output:
+  #   a Hash of Arrays with all values found.
+  #       Example of output with example.get_values("id","name")
+  #           {"id"=>344, "name"=>["Peter Smith", ["myFavor1", "Special ticket"]]}
+  #       Example of output with example.get_values("idt")
+  #           {"idt"=>[345,3123,3145]}
+  #       Example of output with example.get_values(:'tickets.idt')
+  #           {:"tickets.idt"=>[345,3123,3145]}
+  #
+  ####################################################
+  def NiceHash.get_values(hashv, keys)
+    #todo: check if we should return {"id"=>344, "name"=>["Peter Smith", "myFavor1", "Special ticket"]} instead of
+    # {"id"=>344, "name"=>["Peter Smith", ["myFavor1", "Special ticket"]]}
+    if keys.kind_of?(String) or keys.kind_of?(Symbol)
+      keys = [keys]
+    end
+    if (keys.grep(/\./)).empty?
+      nested = false
+    else
+      nested = true
+    end
+    result = Hash.new()
+    number_of_results = Hash.new()
+    keys.each { |key|
+      number_of_results[key] = 0
+    }
+    if hashv.kind_of?(Array)
+      hashv.each { |tmp|
+        if tmp.kind_of?(Array) or tmp.kind_of?(Hash)
+          n_result = get_values(tmp, keys)
+          if n_result != :error
+            n_result.each { |n_key, n_value|
+              if result.has_key?(n_key)
+                if !result[n_key].kind_of?(Array) or
+                   (result[n_key].kind_of?(Array) and number_of_results[n_key] < result[n_key].size)
+                  if result[n_key].kind_of?(Hash) or result[n_key].kind_of?(Array)
+                    res_tx = result[n_key].dup()
+                  else
+                    res_tx = result[n_key]
+                  end
+                  result[n_key] = Array.new()
+                  result[n_key].push(res_tx)
+                  result[n_key].push(n_value)
+                else
+                  result[n_key].push(n_value)
+                end
+              else
+                result[n_key] = n_value
+              end
+              number_of_results[n_key] += 1
+            }
+          end
+        end
+      }
+    elsif hashv.kind_of?(Hash)
+      hashv.each { |key, value|
+        #if keys.include?(key) then
+        #added to be able to access the keys with symbols to strings and opposite
+        if keys.include?(key) or keys.include?(key.to_s) or keys.include?(key.to_sym)
+          #todo: check on next ruby versions since it will be not necessary to do it
+          #added to be able to access the keys with symbols to strings and opposite
+          key = key.to_s() if keys.include?(key.to_s)
+          key = key.to_sym() if keys.include?(key.to_sym)
+
+          if result.has_key?(key)
+            if !result[key].kind_of?(Array) or
+               (result[key].kind_of?(Array) and number_of_results[key] < result[key].size)
+              if result[key].kind_of?(Hash) or result[key].kind_of?(Array)
+                res_tx = result[key].dup()
+              else
+                res_tx = result[key]
+              end
+              result[key] = Array.new()
+              result[key].push(res_tx)
+              result[key].push(value)
+            else
+              result[key].push(value)
+            end
+          else
+            result[key] = value
+          end
+          number_of_results[key] += 1
+        end
+        if value.kind_of?(Array) or value.kind_of?(Hash)
+          if nested
+            keys_nested = []
+            keys.grep(/^#{key}\./).each do |k|
+              keys_nested << k.to_s.gsub(/^#{key}\./,'').to_sym
+            end
+            n_result_tmp = get_values(value, keys_nested)
+            n_result = {}
+            n_result_tmp.each do |k,v|
+              n_result["#{key}.#{k}".to_sym] = v
+            end
+          else
+            n_result = get_values(value, keys)
+          end
+          if n_result != :error
+            n_result.each { |n_key, n_value|
+              if result.has_key?(n_key)
+                if !result[n_key].kind_of?(Array) or
+                   (result[n_key].kind_of?(Array) and number_of_results[n_key] < result[n_key].size)
+                  if result[n_key].kind_of?(Hash) or result[n_key].kind_of?(Array)
+                    res_tx = result[n_key].dup()
+                  else
+                    res_tx = result[n_key]
+                  end
+                  result[n_key] = Array.new()
+                  result[n_key].push(res_tx)
+                  result[n_key].push(n_value)
+                else
+                  result[n_key].push(n_value)
+                end
+              else
+                result[n_key] = n_value
+              end
+              number_of_results[n_key] += 1
+            }
+          end
+        end
+      }
+    else
+      return :error
+    end
+    if result.kind_of?(Hash) and caller[0]["get_values"].nil? #no error or anything weird
+      (keys - result.keys).each { |k| #in case some keys don't exist in the hash
+        result[k] = nil
+      }
+    end
+    return result
+  end
+ 
+end