string_pattern 2.3.0 → 2.5.0

data/lib/string/pattern/generate.rb

@@ -64,6 +64,11 @@ class StringPattern
   #     the generated string
   ###############################################
   def StringPattern.generate(pattern, expected_errors: [], **synonyms)
+    rng = synonyms.delete(:_rng)
+    if rng.nil?
+      base = synonyms.key?(:seed) ? Random.new(synonyms[:seed]) : Random.new
+      rng = StringPattern::RandomSource.new(base)
+    end
     tries = 0
     begin
       good_result = true
@@ -79,30 +84,32 @@ class StringPattern
       if pattern.kind_of?(Array)
         pattern.each { |pat|
           if pat.kind_of?(Array) # for the case it is one of the values
-            pat = pat.sample
+            pat = pat.sample(random: rng)
           end
 
           if pat.kind_of?(Symbol)
             if pat.to_s.scan(/^!?\d+-?\d*:.+/).size > 0
-              string << StringPattern.generate(pat.to_s, expected_errors: expected_errors)
+              string << StringPattern.generate(pat.to_s, expected_errors: expected_errors, _rng: rng)
             else
               string << pat.to_s
             end
           elsif pat.kind_of?(String)
             if @optimistic and pat.to_s.scan(/^!?\d+-?\d*:.+/).size > 0
-              string << StringPattern.generate(pat.to_s, expected_errors: expected_errors)
+              string << StringPattern.generate(pat.to_s, expected_errors: expected_errors, _rng: rng)
             else
               string << pat
             end
           else
-            puts "StringPattern.generate: it seems you supplied wrong array of patterns: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
-            return ""
+            return StringPattern.fail_generation("StringPattern.generate: it seems you supplied wrong array of patterns: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}", StringPattern::InvalidPatternError)
           end
         }
         return string
       elsif pattern.kind_of?(String) or pattern.kind_of?(Symbol)
         patt = StringPattern.analyze(pattern).clone
-        return "" unless patt.kind_of?(Struct)
+        unless patt.kind_of?(Struct)
+          raise StringPattern::InvalidPatternError, "pattern argument not valid on StringPattern.generate: #{pattern.inspect}" if @raise_on_error
+          return ""
+        end
 
         min_length = patt.min_length.clone
         max_length = patt.max_length.clone
@@ -120,17 +127,18 @@ class StringPattern
           }
           unless excluded_data.size == 0
             if (required_chars.flatten & excluded_data.flatten).size > 0
-              puts "pattern argument not valid on StringPattern.generate, a character cannot be required and excluded at the same time: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
-              return ""
+              return StringPattern.fail_generation("pattern argument not valid on StringPattern.generate, a character cannot be required and excluded at the same time: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}", StringPattern::InvalidPatternError)
             end
           end
         end
 
         string_set_not_allowed = Array.new
       elsif pattern.kind_of?(Regexp)
-        return generate(pattern.to_sp, expected_errors: expected_errors)
+        return generate(pattern.to_sp, expected_errors: expected_errors, _rng: rng)
       else
-        puts "pattern argument not valid on StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
+        message = "pattern argument not valid on StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
+        raise StringPattern::InvalidPatternError, message if @raise_on_error
+        StringPattern.log_message(message)
         return pattern.to_s
       end
 
@@ -139,8 +147,8 @@ class StringPattern
       if symbol_type[0..0] == "!"
         deny_pattern = true
         possible_errors = [:length, :value, :string_set_not_allowed]
-        (rand(possible_errors.size) + 1).times {
-          expected_errors << possible_errors.sample
+        (rng.rand(possible_errors.size) + 1).times {
+          expected_errors << possible_errors.sample(random: rng)
         }
         expected_errors.uniq!
         if symbol_type[1..1] == "0"
@@ -169,21 +177,18 @@ class StringPattern
 
       unless deny_pattern
         if required_data.size == 0 and expected_errors_left.include?(:required_data)
-          puts "required data not supplied on pattern so it won't be possible to generate a wrong string. StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
-          return ""
+          return StringPattern.fail_generation("required data not supplied on pattern so it won't be possible to generate a wrong string. StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}", StringPattern::GenerationImpossibleError)
         end
 
         if excluded_data.size == 0 and expected_errors_left.include?(:excluded_data)
-          puts "excluded data not supplied on pattern so it won't be possible to generate a wrong string. StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
-          return ""
+          return StringPattern.fail_generation("excluded data not supplied on pattern so it won't be possible to generate a wrong string. StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}", StringPattern::GenerationImpossibleError)
         end
 
         if expected_errors_left.include?(:string_set_not_allowed)
           string_set_not_allowed = all_characters_set - string_set
 
           if string_set_not_allowed.size == 0
-            puts "all characters are allowed so it won't be possible to generate a wrong string. StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
-            return ""
+            return StringPattern.fail_generation("all characters are allowed so it won't be possible to generate a wrong string. StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}", StringPattern::GenerationImpossibleError)
           end
         end
       end
@@ -192,12 +197,12 @@ class StringPattern
          expected_errors_left.include?(:max_length) or
          expected_errors_left.include?(:length)
         if expected_errors_left.include?(:min_length) or
-           (min_length > 0 and expected_errors_left.include?(:length) and rand(2) == 0)
+           (min_length > 0 and expected_errors_left.include?(:length) and rng.rand(2) == 0)
           if min_length > 0
             if allow_empty
-              length = rand(min_length).to_i
+              length = rng.rand(min_length).to_i
             else
-              length = rand(min_length - 1).to_i + 1
+              length = rng.rand(min_length - 1).to_i + 1
             end
             if required_data.size > length and required_data.size < min_length
               length = required_data.size
@@ -205,22 +210,21 @@ class StringPattern
             expected_errors_left.delete(:length)
             expected_errors_left.delete(:min_length)
           else
-            puts "min_length is 0 so it won't be possible to generate a wrong string smaller than 0 characters. StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
-            return ""
+            return StringPattern.fail_generation("min_length is 0 so it won't be possible to generate a wrong string smaller than 0 characters. StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}", StringPattern::GenerationImpossibleError)
           end
         elsif expected_errors_left.include?(:max_length) or expected_errors_left.include?(:length)
-          length = max_length + 1 + rand(max_length).to_i
+          length = max_length + 1 + rng.rand(max_length).to_i
           expected_errors_left.delete(:length)
           expected_errors_left.delete(:max_length)
         end
       else
-        if allow_empty and rand(7) == 1
+        if allow_empty and rng.rand(7) == 1
           length = 0
         else
           if max_length == min_length
             length = min_length
           else
-            length = min_length + rand(max_length - min_length + 1)
+            length = min_length + rng.rand(max_length - min_length + 1)
           end
         end
       end
@@ -251,28 +255,27 @@ class StringPattern
       if symbol_type != "@" and symbol_type != "!@" and length != 0 and string_set.size != 0
         if string_set.size != 0
           1.upto(length) { |i|
-            string << string_set.sample.to_s
+            string << string_set.sample(random: rng).to_s
           }
         end
         if required_data.size > 0
           positions_to_set = (0..(string.size - 1)).to_a
           required_data.each { |rd|
             if (string.chars & rd).size > 0
-              rd_to_set = (string.chars & rd).sample
+              rd_to_set = (string.chars & rd).sample(random: rng)
             else
-              rd_to_set = rd.sample
+              rd_to_set = rd.sample(random: rng)
             end
             if ((0...string.length).find_all { |i| string[i, 1] == rd_to_set }).size == 0
               if positions_to_set.size == 0
-                puts "pattern not valid on StringPattern.generate, not possible to generate a valid string: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
-                return ""
+                return StringPattern.fail_generation("pattern not valid on StringPattern.generate, not possible to generate a valid string: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}", StringPattern::GenerationImpossibleError)
               else
-                k = positions_to_set.sample
+                k = positions_to_set.sample(random: rng)
                 string[k] = rd_to_set
                 positions_to_set.delete(k)
               end
             else
-              k = ((0...string.length).find_all { |i| string[i, 1] == rd_to_set }).sample
+              k = ((0...string.length).find_all { |i| string[i, 1] == rd_to_set }).sample(random: rng)
               positions_to_set.delete(k)
             end
           }
@@ -280,7 +283,7 @@ class StringPattern
         excluded_data.each { |ed|
           if (string.chars & ed).size > 0
             (string.chars & ed).each { |s|
-              string.gsub!(s, string_set.sample)
+              string.gsub!(s, string_set.sample(random: rng))
             }
           end
         }
@@ -289,28 +292,27 @@ class StringPattern
           string_set_not_allowed = all_characters_set - string_set if string_set_not_allowed.size == 0
 
           if string_set_not_allowed.size == 0
-            puts "Not possible to generate a non valid string on StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
-            return ""
+            return StringPattern.fail_generation("Not possible to generate a non valid string on StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}", StringPattern::GenerationImpossibleError)
           end
-          (rand(string.size) + 1).times {
-            string[rand(string.size)] = (all_characters_set - string_set).sample
+          (rng.rand(string.size) + 1).times {
+            string[rng.rand(string.size)] = (all_characters_set - string_set).sample(random: rng)
           }
           expected_errors_left.delete(:value)
         end
 
         if expected_errors_left.include?(:required_data) and required_data.size > 0
-          (rand(required_data.size) + 1).times {
-            chars_to_remove = required_data.sample
+          (rng.rand(required_data.size) + 1).times {
+            chars_to_remove = required_data.sample(random: rng)
             chars_to_remove.each { |char_to_remove|
-              string.gsub!(char_to_remove, (string_set - chars_to_remove).sample)
+              string.gsub!(char_to_remove, (string_set - chars_to_remove).sample(random: rng))
             }
           }
           expected_errors_left.delete(:required_data)
         end
 
         if expected_errors_left.include?(:excluded_data) and excluded_data.size > 0
-          (rand(string.size) + 1).times {
-            string[rand(string.size)] = excluded_data.sample.sample
+          (rng.rand(string.size) + 1).times {
+            string[rng.rand(string.size)] = excluded_data.sample(random: rng).sample(random: rng)
           }
           expected_errors_left.delete(:excluded_data)
         end
@@ -318,67 +320,21 @@ class StringPattern
         if expected_errors_left.include?(:string_set_not_allowed)
           string_set_not_allowed = all_characters_set - string_set if string_set_not_allowed.size == 0
           if string_set_not_allowed.size > 0
-            (rand(string.size) + 1).times {
-              string[rand(string.size)] = string_set_not_allowed.sample
+            (rng.rand(string.size) + 1).times {
+              string[rng.rand(string.size)] = string_set_not_allowed.sample(random: rng)
             }
             expected_errors_left.delete(:string_set_not_allowed)
           end
         end
       elsif (symbol_type == "W" or symbol_type == "P" or symbol_type == "w" or symbol_type == "p") and length > 0
-        words = []
-        words_short = []
-        if symbol_type == "W"
-          if @words_camel.empty?
-            require "pathname"
-            require "json"
-            filename = File.join Pathname(File.dirname(__FILE__)), "../../../data", "english/nouns.json"
-            nouns = JSON.parse(File.read(filename))
-            filename = File.join Pathname(File.dirname(__FILE__)), "../../../data", "english/adjs.json"
-            adjs = JSON.parse(File.read(filename))
-            nouns = nouns.map(&:to_camel_case)
-            adjs = adjs.map(&:to_camel_case)
-            @words_camel = adjs + nouns
-            @words_camel_short = @words_camel.sample(2000)
-          end
-          words = @words_camel
-          words_short = @words_camel_short
-        elsif symbol_type == "w"
-          if @words.empty?
-            require "pathname"
-            require "json"
-            filename = File.join Pathname(File.dirname(__FILE__)), "../../../data", "english/nouns.json"
-            nouns = JSON.parse(File.read(filename))
-            filename = File.join Pathname(File.dirname(__FILE__)), "../../../data", "english/adjs.json"
-            adjs = JSON.parse(File.read(filename))
-            @words = adjs + nouns
-            @words_short = @words.sample(2000)
-          end
-          words = @words
-          words_short = @words_short
-        elsif symbol_type == "P"
-          if @palabras_camel.empty?
-            require "pathname"
-            require "json"
-            filename = File.join Pathname(File.dirname(__FILE__)), "../../../data", "spanish/palabras#{rand(12)}.json"
-            palabras = JSON.parse(File.read(filename))
-            palabras = palabras.map(&:to_camel_case)
-            @palabras_camel = palabras
-            @palabras_camel_short = @palabras_camel.sample(2000)
-          end
-          words = @palabras_camel
-          words_short = @palabras_camel_short
-        elsif symbol_type == "p"
-          if @palabras.empty?
-            require "pathname"
-            require "json"
-            filename = File.join Pathname(File.dirname(__FILE__)), "../../../data", "spanish/palabras#{rand(12)}.json"
-            palabras = JSON.parse(File.read(filename))
-            @palabras = palabras
-            @palabras_short = @palabras.sample(2000)
-          end
-          words = @palabras
-          words_short = @palabras_short
+        if symbol_type == "W" || symbol_type == "w"
+          load_english_words(camel: symbol_type == "W")
+          words = symbol_type == "W" ? @words_camel : @words
+        else
+          load_spanish_words(camel: symbol_type == "P")
+          words = symbol_type == "P" ? @palabras_camel : @palabras
         end
+        words_short = words.sample(2000, random: rng)
 
         wordr = ""
         wordr_array = []
@@ -392,16 +348,16 @@ class StringPattern
           end
           if symbol_type == "w" or symbol_type == "p"
             length = length - 1 if wordr_array.size > 0
-            res = (words_short.select { |word| word.length <= length && word.length != length - 1 && word.length != length - 2 && word.length != length - 3 }).sample.to_s
+            res = (words_short.select { |word| word.length <= length && word.length != length - 1 && word.length != length - 2 && word.length != length - 3 }).sample(random: rng).to_s
             unless res.to_s == ""
               wordr_array << res
               wordr = wordr_array.join(@word_separator)
             end
           else
-            wordr += (words_short.select { |word| word.length <= length && word.length != length - 1 && word.length != length - 2 && word.length != length - 3 }).sample.to_s
+            wordr += (words_short.select { |word| word.length <= length && word.length != length - 1 && word.length != length - 2 && word.length != length - 3 }).sample(random: rng).to_s
           end
           if (tries % 100) == 0
-            words_short = words.sample(2000)
+            words_short = words.sample(2000, random: rng)
           end
         end
         good_result = true
@@ -434,60 +390,60 @@ class StringPattern
           at_sign = "@"
 
           if expected_errors_left.include?(:value)
-            if rand(2) == 1
-              extension = (all_characters_set - ["."]).sample.dup
+            if rng.rand(2) == 1
+              extension = (all_characters_set - ["."]).sample(random: rng).dup
               expected_errors_left.delete(:value)
               expected_errors_left.delete(:required_data)
             end
 
-            if rand(2) == 1
-              1.upto(rand(7)) { |i|
-                extension << alpha_set.sample.downcase
+            if rng.rand(2) == 1
+              1.upto(rng.rand(7)) { |i|
+                extension << alpha_set.sample(random: rng).downcase
               }
 
-              (rand(extension.size) + 1).times {
-                extension[rand(extension.size)] = (string_set - alpha_set - ["."]).sample
+              (rng.rand(extension.size) + 1).times {
+                extension[rng.rand(extension.size)] = (string_set - alpha_set - ["."]).sample(random: rng)
               }
 
               expected_errors_left.delete(:value)
             else
-              1.upto(rand(3) + 2) { |i|
-                extension << alpha_set.sample.downcase
+              1.upto(rng.rand(3) + 2) { |i|
+                extension << alpha_set.sample(random: rng).downcase
               }
             end
 
-            if rand(2) == 1
-              at_sign = (string_set - ["@"]).sample.dup
+            if rng.rand(2) == 1
+              at_sign = (string_set - ["@"]).sample(random: rng).dup
               expected_errors_left.delete(:value)
               expected_errors_left.delete(:required_data)
             end
           else
             if length > 6
-              1.upto(rand(3) + 2) { |i|
-                extension << alpha_set.sample.downcase
+              1.upto(rng.rand(3) + 2) { |i|
+                extension << alpha_set.sample(random: rng).downcase
               }
             else
               1.upto(2) { |i|
-                extension << alpha_set.sample.downcase
+                extension << alpha_set.sample(random: rng).downcase
               }
             end
           end
           length_e = length - extension.size - 1
-          length1 = rand(length_e - 1) + 1
+          length1 = rng.rand(length_e - 1) + 1
           length2 = length_e - length1
-          1.upto(length1) { |i| string << string_set.sample }
+          1.upto(length1) { |i| string << string_set.sample(random: rng) }
 
           string << at_sign
 
           domain = ""
           domain_set = alpha_set + NUMBER_SET.clone + ["."] + ["-"]
           1.upto(length2) { |i|
-            domain << domain_set.sample.downcase
+            domain << domain_set.sample(random: rng).downcase
           }
 
-          if expected_errors.include?(:value) and rand(2) == 1 and domain.size > 0
-            (rand(domain.size) + 1).times {
-              domain[rand(domain.size)] = (all_characters_set - domain_set).sample
+          if expected_errors.include?(:value) and rng.rand(2) == 1 and domain.size > 0
+            (rng.rand(domain.size) + 1).times {
+              domain[rng.rand(domain.size)] = (all_characters_set - domain_set).sample(random: rng)
             }
             expected_errors_left.delete(:value)
           end
@@ -495,31 +451,18 @@ class StringPattern
           string << domain << extension
 
           if expected_errors_left.include?(:value) or expected_errors_left.include?(:string_set_not_allowed)
-            (rand(string.size) + 1).times {
-              string[rand(string.size)] = string_set_not_allowed.sample
+            (rng.rand(string.size) + 1).times {
+              string[rng.rand(string.size)] = string_set_not_allowed.sample(random: rng)
             }
             expected_errors_left.delete(:value)
             expected_errors_left.delete(:string_set_not_allowed)
           end
 
-          error_regular_expression = false
+          error_regular_expression = !StringPattern.valid_email?(string)
 
           if deny_pattern and expected_errors.include?(:length)
             good_result = true #it is already with wrong length
           else
-            # I'm doing this because many times the regular expression checking hangs with these characters
-            wrong = %w(.. __ -- ._ _. .- -. _- -_ @. @_ @- .@ _@ -@ @@)
-            if !(Regexp.union(*wrong) === string) #don't include any or the wrong strings
-              if string.index("@").to_i > 0 and
-                 string[0..(string.index("@") - 1)].scan(/([a-z0-9]+([\+\._\-][a-z0-9]|)*)/i).join == string[0..(string.index("@") - 1)] and
-                 string[(string.index("@") + 1)..-1].scan(/([0-9a-z]+([\.-][a-z0-9]|)*)/i).join == string[string[(string.index("@") + 1)..-1]]
-                error_regular_expression = false
-              else
-                error_regular_expression = true
-              end
-            else
-              error_regular_expression = true
-            end
 
             if expected_errors.size == 0
               if error_regular_expression
@@ -540,8 +483,7 @@ class StringPattern
           end
         end until good_result or tries > 100
         unless good_result
-          puts "Not possible to generate an email on StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
-          return ""
+          return StringPattern.fail_generation("Not possible to generate an email on StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}", StringPattern::GenerationImpossibleError)
         end
       end
       if @dont_repeat
@@ -569,21 +511,67 @@ class StringPattern
         end
       end
       if @block_list_enabled
-        if @block_list.is_a?(Array)
-          @block_list.each do |bl|
-            if string.match?(/#{bl}/i)
-              good_result = false
-              break
+        if @block_list.respond_to?(:call)
+          good_result = false if @block_list.call(string)
+        elsif @block_list.is_a?(Array)
+          if @block_list_regexp
+            @block_list.each do |bl|
+              if string.match?(/#{bl}/i)
+                good_result = false
+                break
+              end
+            end
+          else
+            downcased = string.downcase
+            @block_list.each do |bl|
+              if downcased.include?(bl.to_s.downcase)
+                good_result = false
+                break
+              end
             end
           end
         end
       end
     end until good_result or tries > 10000
     unless good_result
-      puts "Not possible to generate the string on StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
-      puts "Take in consideration if you are using StringPattern.dont_repeat=true that you don't try to generate more strings that are possible to be generated"
-      return ""
+      msg = "Not possible to generate the string on StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
+      msg += "\nTake in consideration if you are using StringPattern.dont_repeat=true that you don't try to generate more strings that are possible to be generated"
+      return StringPattern.fail_generation(msg, StringPattern::GenerationImpossibleError)
     end
     return string
   end
+
+  def self.fail_generation(message, error_class)
+    raise error_class, message if @raise_on_error
+    log_message(message)
+    ""
+  end
+
+  def self.word_data_path(*parts)
+    File.join(__dir__, "..", "..", "..", "data", *parts)
+  end
+
+  def self.load_english_words(camel: false)
+    require "json"
+    if @words.nil? || @words.empty?
+      nouns = JSON.parse(File.read(word_data_path("english", "nouns.json")))
+      adjs = JSON.parse(File.read(word_data_path("english", "adjs.json")))
+      @words = adjs + nouns
+    end
+    if camel && (@words_camel.nil? || @words_camel.empty?)
+      @words_camel = @words.map(&:to_camel_case)
+    end
+  end
+
+  def self.load_spanish_words(camel: false)
+    require "json"
+    if @palabras.nil? || @palabras.empty?
+      @palabras = (0..11).flat_map do |i|
+        JSON.parse(File.read(word_data_path("spanish", "palabras#{i}.json")))
+      end
+    end
+    if camel && (@palabras_camel.nil? || @palabras_camel.empty?)
+      @palabras_camel = @palabras.map(&:to_camel_case)
+    end
+  end
 end