string_pattern 1.6.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d4c76309330e0ce36e6f110971791053f1c932a92246d30454342c58df5ca82
-  data.tar.gz: dd885204b85c12ce3d734187649270b5e38a6f89b7b8789a8ed5d76fb5492b80
+  metadata.gz: 70bf11f69ccc9fe41a84e7314f88fb12e98d9639f9619869504b455e132bd5b5
+  data.tar.gz: 3ad181fe7fabbcafe4467c76c3cdba59beefc752cf8f773dc6729b6c13d7d642
 SHA512:
-  metadata.gz: f3dc754593a2838186535d4330eefba9e0f560a90c63f3e8981a2883498fbe5e68d325cadecaaa3993fde53e21e5c22a52b10eb3159ba44c7fa6d8c3692b8305
-  data.tar.gz: baee5bb1e9e032b68fb2f19f683e0b0c458d946225c0b000501f0676cde020f56ad26420e0868a7c2eada703e728043a8557b10fa622561c29f0e4aebe633651
+  metadata.gz: '05936978cbd0e45df53493d779c2b031001e591313578e5283348f9bfea78e1f20fa446b013d001b6d1c108d259ed7cdc12d36a8c3910e300bd976a3ab6f4fb7'
+  data.tar.gz: 6983689728bd7437e2937ee8c5c739bf2dea4638dc942de8ebf1451ee5525586246b135ee0a7d9251d09c8834f617d92dc47172afd3f320db9591ae6d749c955

data/README.md

@@ -5,6 +5,8 @@
 With this gem, you can easily generate strings supplying a very simple pattern. 
 Also, you can validate if a text fulfills a specific pattern or even generate a string following a pattern and returning the wrong length, value... for testing your applications.
 
+Also you can use regular expressions (Regexp) to generate strings: `/[a-z0-9]{2,5}\w+/.gen`
+
 To do even more take a look at [nice_hash gem](https://github.com/MarioRuiz/nice_hash)
 
 ## Installation
@@ -102,6 +104,53 @@ The pattern needs to be a symbol object.
 }
 ```
 
+#### Generate strings using Regular Expressions (Regexp)
+
+Take in consideration this feature is not supporting all possibilities for Regular expressions but it is fully functional. If you find any bug or limitation please add it to issues: https://github.com/MarioRuiz/string_pattern/issues
+
+In case you you want to change the default maximum for repetitions when using * or +: `StringPattern.default_infinite = 30` . By default is 10.
+
+If you want to translate a regular expression into an StringPattern use the method we added to Regexp class: `to_sp`
+
+Examples:
+
+```ruby
+/[a-z0-9]{2-5}\w+/.to_sp
+#> ["2-5:nx", "1-10:Ln_"]
+
+#regular expression for UUID v4
+/[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}/.to_sp
+#> ["8:n[ABCDEF]", "-", "4:n[ABCDEF]", "-4", "3:n[ABCDEF]", "-", "1:[89AB]", "3:n[ABCDEF]", "-", "12:n[ABCDEF]"]
+```
+
+If you want to generate a random string following the regular expression, you can do it like a normal string pattern:
+
+```ruby
+
+regexp = /[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}/
+
+# using StringPattern class
+puts StringPattern.generate(regexp)
+
+# using Kernel
+puts generate(regexp)
+
+# using generate method added to Regexp class
+puts regexp.generate
+
+#using the alias 'gen'
+puts regexp.gen 
+
+# output:
+#>7009574B-6F2F-436E-BB7A-EA5FDA6B4E47
+#>5FB1718F-108A-4F62-8170-33C43FD86B1D
+#>05745B6F-93BA-475F-8118-DD56E5EAC4D1
+#>2D6FC189-8D50-45A8-B182-780193838502
+
+```
+
+### String patterns
+
 #### How to generate one or another string
 
 In case you need to specify that the string is generated selecting one or another fixed string or pattern, you can do it by using Array of patterns and in the position you want you can add an array with the possible values
@@ -117,6 +166,7 @@ p ["uno:", :"5:N", ['.red','.green', :'3:L'] ].gen
 # 'uno:34322.red'
 # 'uno:44432.green'
 # 'uno:34322.red'
+# 'uno:28795xAB'
 
 ```
 
@@ -213,6 +263,7 @@ Examples:
 
 "10:L/n/".gen errors: [:value]
 #> 1hwIw;v{KQ, mpk*l]!7:!, wocipgZt8@
+
 ```
 
 ### Validate if a string is following a pattern

data/lib/string/pattern/add_to_ruby.rb

@@ -6,14 +6,14 @@ class Array
     StringPattern.generate(self, expected_errors: expected_errors, **synonyms)
   end
 
-  alias_method :gen, :generate
+  alias gen generate
 
   # it will validate an string following the pattern specified
   def validate(string_to_validate, expected_errors: [], not_expected_errors: [], **synonyms)
     StringPattern.validate(text: string_to_validate, pattern: self, expected_errors: expected_errors, not_expected_errors: not_expected_errors, **synonyms)
   end
 
-  alias_method :val, :validate
+  alias val validate
 end
 
 class String
@@ -22,46 +22,263 @@ class String
     StringPattern.generate(self, expected_errors: expected_errors, **synonyms)
   end
 
-  alias_method :gen, :generate
+  alias gen generate
 
   # it will validate an string following the pattern specified
   def validate(string_to_validate, expected_errors: [], not_expected_errors: [], **synonyms)
     StringPattern.validate(text: string_to_validate, pattern: self, expected_errors: expected_errors, not_expected_errors: not_expected_errors, **synonyms)
   end
 
-  alias_method :val, :validate
+  alias val validate
 end
 
-
 class Symbol
   # it will generate an string following the pattern specified
   def generate(expected_errors: [], **synonyms)
     StringPattern.generate(self, expected_errors: expected_errors, **synonyms)
   end
 
-  alias_method :gen, :generate
+  alias gen generate
 
   # it will validate an string following the pattern specified
   def validate(string_to_validate, expected_errors: [], not_expected_errors: [], **synonyms)
-    StringPattern.validate(text: string_to_validate, pattern: self.to_s, expected_errors: expected_errors, not_expected_errors: not_expected_errors, **synonyms)
+    StringPattern.validate(text: string_to_validate, pattern: to_s, expected_errors: expected_errors, not_expected_errors: not_expected_errors, **synonyms)
   end
 
-  alias_method :val, :validate
+  alias val validate
 end
 
+class Regexp
+
+  # it will generate an string following the pattern specified
+  def generate(expected_errors: [], **synonyms)
+    StringPattern.generate(self, expected_errors: expected_errors, **synonyms)
+  end
+
+  alias gen generate
+
+  # adds method to convert a Regexp to StringPattern
+  # returns an array of string patterns or just one string pattern
+  def to_sp
+    regexp_s = self.to_s 
+    return StringPattern.cache[regexp_s] unless StringPattern.cache[regexp_s].nil?
+    regexp = Regexp.new regexp_s
+    require 'regexp_parser'
+    default_infinite = StringPattern.default_infinite
+    pata = []
+    pats = ''
+    patg = [] # for (aa|bb|cc) group
+    set = false
+    capture = false
+
+    range = ''
+    fixed_text=false
+    last_char = (regexp.to_s.gsub("?-mix:",'').length)-2
+    Regexp::Scanner.scan regexp do |type, token, text, ts, te|
+      if type == :escape
+        if token == :dot
+          token = :literal
+          text = '.'
+        elsif token == :literal and text.size == 2
+          text = text[1]
+        else 
+          puts "Report token not controlled: type: #{type}, token: #{token}, text: '#{text}' [#{ts}..#{te}]"
+        end
+      end
+
+
+      unless set || (token == :interval) || (token == :zero_or_one) ||
+             (token == :zero_or_more) || (token == :one_or_more) || (pats == '')
+        if (pats[0] == '[') && (pats[-1] == ']')
+          pats[0] = ''
+          if (token == :alternation) || !patg.empty?
+            if fixed_text 
+              if patg.size==0
+                patg << (pata.pop + pats.chop)
+              else
+                patg[-1] += pats.chop
+              end
+            else
+              patg << pats.chop
+            end
+          else
+            if fixed_text 
+              pata[-1]+=pats.chop
+            else
+              if pats.size==2
+                pata << pats.chop #jal
+              else
+                pata << "1:[#{pats}" #jal
+              end
+              if last_char==te and type==:literal and token==:literal
+                pata << text
+                pats = ""
+                next
+              end
+            end
+          end
+        else
+          if (token == :alternation) || !patg.empty?
+            patg << "1:#{pats}"
+          else
+            pata << "1:#{pats}"
+          end
+        end
+        pats = ''
+      end
+      fixed_text=false
+
+      case token
+      when :open
+        set = true
+        pats += '['
+      when :close
+        if type == :set
+          set = false
+          if pats[-1] == '['
+            pats.chop!
+          else
+            pats += ']'
+          end
+        elsif type == :group
+          capture = false
+          unless patg.empty?
+            patg << pats if pats.to_s != ''
+            pata << patg
+            patg = []
+            pats = ''
+          end
+        end
+      when :capture
+        capture = true if type == :group
+      when :alternation
+        if type == :meta
+          if pats != ''
+            patg << pats
+            pats = ''
+          elsif patg.empty?
+            # for the case the first element was not added to patg and was on pata fex: (a+|b|c)
+            patg << pata.pop
+            end
+        end
+      when :range
+        range = pats[-1]
+        pats.chop!
+      when :digit
+        pats += 'n'
+      when :nondigit
+        pats += '*[%0123456789%]'
+      when :space
+        pats += '_'
+      when :nonspace
+        pats += '*[% %]'
+      when :word
+        pats += 'Ln_'
+      when :nonword
+        pats += '$'
+      when :word_boundary
+        pats += '$'
+      when :dot
+        pats += '*'
+      when :literal
+        if range == ''
+          if text.size > 1
+            fixed_text=true
+            if !patg.empty?
+              patg << text.chop
+            else
+              pata << text.chop
+            end
+            pats = text[-1]
+          else
+            pats += text
+          end
+        else
+          range = range + '-' + text
+          if range == 'a-z'
+            pats = 'x' + pats
+          elsif range == 'A-Z'
+            pats = 'X' + pats
+          elsif range == '0-9'
+            pats = 'n' + pats
+          else
+            pats += if set
+                      (range[0]..range[2]).to_a.join
+                    else
+                      '[' + (range[0]..range[2]).to_a.join + ']'
+                      end
+
+          end
+          range = ''
+        end
+        pats = '[' + pats + ']' unless set
+      when :interval
+        size = text.sub(',', '-').sub('{', '').sub('}', '')
+        size.chop! if size[-1] == '-'
+        pats = size + ':' + pats
+        if !patg.empty?
+          patg << pats
+        else
+          pata << pats
+        end
+        pats = ''
+      when :zero_or_one
+        pats = '0-1:' + pats
+        if !patg.empty?
+          patg << pats
+        else
+          pata << pats
+        end
+        pats = ''
+      when :zero_or_more
+        pats = "0-#{default_infinite}:" + pats
+        if !patg.empty?
+          patg << pats
+        else
+          pata << pats
+        end
+        pats = ''
+      when :one_or_more
+        pats = "1-#{default_infinite}:" + pats
+        if !patg.empty?
+          patg << pats
+        else
+          pata << pats
+        end
+        pats = ''
+      end
+    end
+    if pats!=""
+      if pata.empty? 
+        if pats[0]=="[" and pats[-1]=="]" #fex: /[12ab]/
+          pata = ["1:#{pats}"]
+        end
+      else
+        pata[-1]+=pats[1] #fex: /allo/
+      end
+    end
+    if pata.size==1 and pata[0].kind_of?(String)
+      res = pata[0]
+    else
+      res = pata
+    end
+    StringPattern.cache[regexp_s] = res
+    return res
+  end
+end
 
 module Kernel
   public
+
   # if string or symbol supplied it will generate a string with the supplied pattern specified on the string
   # if array supplied then it will generate a string with the supplied patterns. If a position contains a pattern supply it as symbol, for example: [:"10:N", "fixed", :"10-20:XN/x/"]
   def generate(pattern, expected_errors: [], **synonyms)
-    if pattern.kind_of?(String) or pattern.kind_of?(Array) or pattern.kind_of?(Symbol)
+    if pattern.is_a?(String) || pattern.is_a?(Array) || pattern.is_a?(Symbol) || pattern.is_a?(Regexp)
       StringPattern.generate(pattern, expected_errors: expected_errors, **synonyms)
     else
       puts " Kernel generate method: class not recognized:#{pattern.class}"
     end
   end
 
-  alias_method :gen, :generate
+  alias gen generate
 end
-

data/lib/string_pattern.rb

@@ -18,15 +18,18 @@ require_relative 'string/pattern/add_to_ruby' if SP_ADD_TO_RUBY
 #             If true it will check on the strings of the array positions if they have the pattern format and assume in that case that is a pattern.
 # dont_repeat: (TrueFalse, default: false)
 #             If you want to generate for example 1000 strings and be sure all those strings are different you can set it to true
+# default_infinite: (Integer, default: 10)
+#             In case using regular expressions the maximum when using * or + for repetitions 
 class StringPattern
   class << self
-    attr_accessor :national_chars, :optimistic, :dont_repeat, :cache, :cache_values
+    attr_accessor :national_chars, :optimistic, :dont_repeat, :cache, :cache_values, :default_infinite
   end
   @national_chars = (('a'..'z').to_a + ('A'..'Z').to_a).join
   @optimistic = true
   @cache = Hash.new()
   @cache_values = Hash.new()
   @dont_repeat = false
+  @default_infinite = 10
   NUMBER_SET = ('0'..'9').to_a
   SPECIAL_SET = [' ', '~', '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '-', '_', '+', '=', '{', '}', '[', ']', "'", ';', ':', '?', '>', '<', '`', '|', '/', '"']
   ALPHA_SET_LOWER = ('a'..'z').to_a
@@ -346,7 +349,8 @@ class StringPattern
           end
         end
         string_set_not_allowed = Array.new
-
+      elsif pattern.kind_of?(Regexp)
+        return generate(pattern.to_sp, expected_errors: expected_errors)
       else
         puts "pattern argument not valid on StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
         return pattern.to_s

metadata

@@ -1,18 +1,39 @@
 --- !ruby/object:Gem::Specification
 name: string_pattern
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Mario Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-08 00:00:00.000000000 Z
-dependencies: []
+date: 2019-01-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: regexp_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
 description: 'You can easily generate strings supplying a very simple pattern. ''10-20:Xn/x/''.generate
-  #>qBstvc6JN8ra. Also, you can validate if a text fulfills a specific pattern or
-  even generate a string following a pattern and returning the wrong length, value...
+  #>qBstvc6JN8ra. Now generate random strings using a regular expression (Regexp):
+  /[a-z0-9]{2,5}w+/.gen . Also, you can validate if a text fulfills a specific pattern
+  or even generate a string following a pattern and returning the wrong length, value...
   for testing your applications.'
 email: marioruizs@gmail.com
 executables: []
@@ -49,6 +70,6 @@ rubyforge_project:
 rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
-summary: 'Generate easily random strings following a simple pattern. ''10-20:Xn/x/''.generate
-  #>qBstvc6JN8ra'
+summary: 'Generate easily random strings following a simple pattern or regular expression.
+  ''10-20:Xn/x/''.generate #>qBstvc6JN8ra'
 test_files: []