nice_hash 1.6.0 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11278d36028f833bcc7ef1265fb425112268758fce86f8743033b86923c7545d
-  data.tar.gz: 6dbc2c7f4f37149b3c79dd00b78df5e411c2d4971cda3a61e79408431012c287
+  metadata.gz: 64a7a0508b0a8452ff40d40be3d5d947bdeb17abb33e29bcc21ab85f2d59ccb4
+  data.tar.gz: 17efe9a0977fbec3eb5aca744474791627daac82aac02c7db4cd99f16f9b7540
 SHA512:
-  metadata.gz: f3b417fabc190632e5910e68ecdb1d80192e0bc25889a16546f263ba6421c675431fe7df1e74cf23e91402e78dd13467e082af1dee7c43b776a35a9e779b411d
-  data.tar.gz: 5e5a0aa355c5552b0febe04d611622e0d57e51e68fd93eecc7bef40504548260b62ee0d159448bac5030c48347430be434bd7bda125947c028eb566ef5bcccb7
+  metadata.gz: 721bcb361f65bf07618a17501aa4fa62808cc87a6f824d7219fe69bf408f48d5126d8d94969438014dcfcee0590cb64916cb1858cb9a40b03ba446aa9519aa33
+  data.tar.gz: 686843fbedb61d5380182d0aeb18af8481d7380830cea2a701429c53b025486e606aecf059547cba4ab175fc20c74a4e2642a88d976f469533f36d77b53eca83

data/README.md

@@ -374,7 +374,7 @@ pattern_fields_on_correct contains:
 ```
 
 
-#### dig and bury Hash methods
+### dig and bury Hash methods
 In case you want to access the values on a hash structure by using the key array location, you can use the 'dig' method on the Hash class:
 
 ```ruby
@@ -539,7 +539,7 @@ Take a look at a full example: https://gist.github.com/MarioRuiz/824d7a462b62fd8
 
 ### Adding other values on real time when calling `generate` method
 
-If you need a value to be supplied for your key on real time everytime you call the `generate` method you can use `lambda`
+If you need a value to be supplied for your key on real time every time you call the `generate` method you can use `lambda`
 
 ```ruby
     my_hash = {
@@ -570,8 +570,47 @@ This is the output:
  :other=>"2019-01-02T13:41:05.536"}
 ```
 
+#### Accessing other values of the hash on real time
 
-#### Other useful methods
+If you need for example to access another value of the key to generate a value on real time you can use `NiceHash.values`
+
+Take a look at this example:
+
+```ruby
+
+my_hash = {
+    loginname: :"10:Ln",
+    send_email: :"true|false",
+    email: lambda {
+        if NiceHash.values._send_email=='true'
+            :"30-50:@".gen
+        else
+            ""
+        end
+    }
+}
+
+pp my_hash.gen
+pp my_hash.gen
+pp my_hash.gen
+
+```
+
+This code will generate a hash where `send_email` can be `true` or `false`. In case it is `true` it will generate a value for the key `email` from 30 to 50 characters valid email, in case it is `false` it will contain empty string.
+
+This is a possible output of the previous code:
+
+```ruby
+{:loginname=>"jnazA9iGN3",
+ :send_email=>"true",
+ :email=>"aRR4SsPaA.0ilh_RW0_y.sQL@goxrssgtkp4df.nkc"}
+
+{:loginname=>"2CjT9wLMxq", :send_email=>"false", :email=>""}
+
+{:loginname=>"XlMpgNPlLR", :send_email=>"false", :email=>""}
+```
+
+### Other useful methods
 
 In case you need the time stamp, we added the method `stamp` to the `Time` class
 

data/lib/nice/hash/add_to_ruby.rb

@@ -118,10 +118,10 @@ end
 
 
 class Time
-  # It will return in the format: '%Y-%m-%dT%H:%M:%S.%L'
+  # It will return in the format: '%Y-%m-%dT%H:%M:%S.%LZ'
   # Example: puts Time.now.stamp
   def stamp
-    return self.strftime('%Y-%m-%dT%H:%M:%S.%L')
+    return self.strftime('%Y-%m-%dT%H:%M:%S.%LZ')
   end
 end
 

data/lib/nice_hash.rb

@@ -27,6 +27,10 @@ require 'string_pattern'
 #   }
 ###########################################################################
 class NiceHash
+  class << self
+    attr_reader :values
+  end
+  @values = {}
 
   ###########################################################################
   # It will filter the hash by the key specified on select_hash_key.
@@ -44,7 +48,7 @@ class NiceHash
   #   new_hash = my_hash.select_key(:wrong)
   ###########################################################################
   def NiceHash.select_key(pattern_hash, select_hash_key)
-    hash=Hash.new()
+    hashv=Hash.new()
 
     if pattern_hash.kind_of?(Hash) and pattern_hash.size>0
       pattern_hash.each {|key, value|
@@ -60,7 +64,7 @@ class NiceHash
           array_pattern=false
           value.each {|v|
             if (v.kind_of?(String) or v.kind_of?(Symbol)) and StringPattern.analyze(v, silent: true).kind_of?(StringPattern::Pattern)
-              hash[key]=value
+              hashv[key]=value
               array_pattern=true
               break
             end
@@ -71,16 +75,16 @@ class NiceHash
               ret=NiceHash.select_key(v, select_hash_key)
               value_ret<<ret
             }
-            hash[key]=value_ret
+            hashv[key]=value_ret
           end
         else
-          hash[key]=value
+          hashv[key]=value
         end
       }
     else
       return pattern_hash
     end
-    return hash
+    return hashv
   end
 
   ###########################################################################
@@ -296,7 +300,7 @@ class NiceHash
   #   new_hash = my_hash.generate(:correct, errors: [:min_length])
   ###########################################################################
   def NiceHash.generate(pattern_hash, select_hash_key=nil, expected_errors: [], **synonyms)
-    hash=Hash.new()
+    hashv=Hash.new()
     same_values=Hash.new()
     expected_errors=synonyms[:errors] if synonyms.keys.include?(:errors)
     if expected_errors.kind_of?(Symbol)
@@ -321,45 +325,45 @@ class NiceHash
 
         if value.kind_of?(String) or value.kind_of?(Symbol)
           if ((StringPattern.optimistic and value.kind_of?(String)) or value.kind_of?(Symbol)) and value.to_s.scan(/^!?\d+-?\d*:.+/).size>0
-            hash[key]=StringPattern.generate(value, expected_errors: expected_errors)
+            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}
-              hash[key]=min[0..-2] unless min==""
+              hashv[key]=min[0..-2] unless min==""
             end
-            if !hash.keys.include?(key) and (expected_errors.include?(:max_length) or expected_errors.include?(:length))
+            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}
-              hash[key]=max+max[-1]
+              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 hash.keys.include?(key)
-                v=hash[key]
+              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}]")
-                hash[key]=v unless value.to_s.split("|").include?(v)
+                hashv[key]=v unless value.to_s.split("|").include?(v)
               end
-              unless hash.keys.include?(key)
+              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
-                hash[key]=v unless value.to_s.split("|").include?(v)
+                hashv[key]=v unless value.to_s.split("|").include?(v)
               end
             end
-            unless hash.keys.include?(key)
-              hash[key]=value.to_s.split("|").sample
+            unless hashv.keys.include?(key)
+              hashv[key]=value.to_s.split("|").sample
             end
           else
-            hash[key]=value
+            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)
-              hash[key]=StringPattern.generate(value, expected_errors: expected_errors)
+              hashv[key]=StringPattern.generate(value, expected_errors: expected_errors)
               array_pattern=true
               break
             end
@@ -371,24 +375,26 @@ class NiceHash
               ret=v if ret.kind_of?(Hash) and ret.size==0
               value_ret<<ret
             }
-            hash[key]=value_ret
+            hashv[key]=value_ret
           end
         elsif value.kind_of?(Proc)
-          hash[key]=value.call
+          hashv[key]=value.call
         else
-          hash[key]=value
+          hashv[key]=value
         end
 
         if same_values.include?(key)
           same_values[key].each {|k|
-            hash[k]=hash[key]
+            hashv[k]=hashv[key]
           }
         end
 
+        @values = hashv
+
       }
     end
 
-    return hash
+    return hashv
   end
 
 
@@ -586,7 +592,7 @@ 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 return nil for that one
     # input:
-    #   hash: a simple hash or a hash containing arrays. Example:
+    #   hashv: a simple hash or a hash containing arrays. Example:
     #    example={"id"=>344,
     #              "customer"=>{
     #                  "name"=>"Peter Smith",
@@ -607,7 +613,7 @@ class NiceHash
     #           {"idt"=>[345,3123,3145]}
     #
     ####################################################
-    def NiceHash.get_values(hash,keys)
+    def NiceHash.get_values(hashv,keys)
       if keys.kind_of?(String) or keys.kind_of?(Symbol) then
         keys=[keys]
       end
@@ -616,8 +622,8 @@ class NiceHash
       keys.each {|key|
         number_of_results[key]=0
       }
-      if hash.kind_of?(Array) then
-        hash.each {|tmp|
+      if hashv.kind_of?(Array) then
+        hashv.each {|tmp|
           if tmp.kind_of?(Array) or tmp.kind_of?(Hash) then
             n_result=get_values(tmp, keys)
             if n_result!=:error then
@@ -644,8 +650,8 @@ class NiceHash
             end
           end
         }
-      elsif hash.kind_of?(Hash) then
-        hash.each {|key, value|
+      elsif hashv.kind_of?(Hash) then
+        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) then

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nice_hash
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.1
 platform: ruby
 authors:
 - Mario Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-02 00:00:00.000000000 Z
+date: 2019-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: string_pattern
@@ -52,7 +52,7 @@ homepage: https://github.com/MarioRuiz/nice_hash
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message: Thanks for installing! Visit us on https://github.com/MarioRuiz/nice_hash
 rdoc_options: []
 require_paths:
 - lib