string_pattern 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: da42289c954a52372acd4df016416a501476ae07a272c8f5b06ef7966165183c
+  data.tar.gz: b491b377808a1f0211e3bdfb9812b54f1d0b223f85fa5af1a61f2dd0c510fe71
+SHA512:
+  metadata.gz: 1609036dca1456ff1f3addfe8126c438de9aa70bcd333251531d97f8c05efd71cc2a5d64ed556ae890d62fa53c1037c8c8b196f2864006669e40f7c121472bf2
+  data.tar.gz: dd9463dafbed43c843b0a4397ea1e0feff7c10d5820640f8247b02e3cccf31de6ecdabcf979f3c83c9190a0879d63549f3eceeeff7d08c43389b3ce166b42b05

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Mario Ruiz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,298 @@
+# StringPattern
+
+[![Gem Version](https://badge.fury.io/rb/string_pattern.svg)](https://rubygems.org/gems/string_pattern)
+
+With this gem you can easily generate strings supplying a very simple pattern. 
+Also you can validate if a text fulfill an specific pattern or even generate a string following a pattern and returning wrong length, value... for testing your applications.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'string_pattern'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install string_pattern
+
+## Usage
+
+### What is a string pattern?
+
+A pattern is a string where we supply these elements "a-b:c" where a is min_length, b is max_length (optional) and c is a set of symbol_type
+
+    min_length: minimum length of the string
+	
+    max_length (optional): maximum length of the string. If not provided, the result will be with the min_length provided
+    
+	symbol_type: The type of the string we want.
+        x: from a to z (lowercase)
+		X: A to Z (capital letters)
+		L: A to Z and a to z
+		T: National characters defined on StringPattern.national_chars
+		n or N: for numbers. 0 to 9
+		$: special characters, $%&#...  (includes blank space)
+		_: blank space
+		*: all characters
+		0: empty string will be accepted.  It needs to be at the beginning of the symbol_type string
+		@: It will generate a valid email following the official algorithm. It cannot be used with other symbol_type
+		
+### How to generate a string following a pattern
+
+To generate a string following a pattern you can do it using directly the StringPattern class or the generate method in the class, be aware you can always use also the alias method: gen
+
+```ruby
+require 'string_pattern'
+
+#StringPattern class
+p StringPattern.generate "10:N"
+#>3448910834
+p StringPattern.gen "5:X"
+#>JDDDK
+
+#String class
+p "4:Nx".gen
+#>xaa3
+
+#Symbol class
+p :"10:T".generate
+#>AccBdjklñD
+
+#Array class
+p [:"3:N", "fixed", :"3:N"].gen
+#>334fixed920
+p "(,3:N,) ,3:N,-,2:N,-,2:N".split(',').generate 
+#>(937) 980-65-05
+
+#Kernel
+p gen "3:N"
+#>443
+```
+
+#### Custom characters
+
+Also it's possible to provided the characters we want. To do that we'll use the symbol_type [characters]
+
+If we want to add the character ] we have to write ]]
+
+Examples
+
+```ruby
+# four chars from the ones provided: asDF9
+p "4:[asDF9]".gen    #> aaaa, asFF, 9sFD
+
+# from 2 to 20 chars, capital and lower chars (Xx) and also valid the characters $#6
+p "2-20:[$#6]Xx".gen    #> aaaa, asFF, 66, B$DkKL#9aDD
+ 
+# four chars from these: asDF]9
+p "4:[asDF]]9]".gen    #> aa]a, asFF, 9s]D
+```
+
+#### Required characters or symbol types
+
+We'll use the symbol / to specify which characters or symbols we want to be included on the resulting string as required values /symbols or characters/
+
+If we need to add the character / we'll use //
+
+Examples:
+
+```ruby
+# four characters. optional: capitals and numbers, required: lower
+"4:XN/x/".gen    # aaaa, FF9b, j4em, asdf, ADFt
+
+# from 6 to 15 chars. optional: numbers, capitals and the chars $ and Æ. required the chars: 23abCD
+"6-15:[/23abCD/$Æ]NX".gen    # bCa$D32, 32DJIOKLaCb, b23aD568C
+ 
+# from 4 to 9 chars. optional: numbers and capitals. required: lowers and the characters $ and 5
+"4-9:[/$5/]XN/x/".generate    # aa5$, F5$F9b, j$4em5, a5sdf$, $ADFt5 
+```
+
+#### Excluded characters
+
+If we want to exclude a few characters in the result, we'll use the symbol %characters%
+
+If you need to exclude the character %, you should use %%
+
+Examples: 
+
+```ruby
+# from 2 to 20 characters. optional: Numbers and characters A, B and C. excluded: the characters 8 and 3
+"2-20:[%83%ABC]N".gen    # B49, 22900, 9CAB, 22, 11CB6270C26C4572A50C
+
+# 10 chars. optional: Letters (capital and lower). required: numbers. excluded: the characters 0 and WXYzZ
+"10:L/n/[%0WXYzZ%]".gen    # GoO2ukCt4l, Q1Je2remFL, qPg1T92T2H, 4445556781
+```
+
+#### Not fulfilling a pattern
+
+If we want our resulting string doesn't fulfill the pattern we supply, then we'll use the symbol ! at the beginning
+
+Examples:
+
+```ruby
+"!4:XN/x/".gen    # a$aaa, FF9B, j4DDDem, as, 2345
+
+"!10:N".gen     # 123, 34899Add34, 3434234234234008, AAFj#kd2x
+```
+
+### Generate a string with specific expected errors
+
+Usually for testing purposes you need to generate strings that don't fulfill an specific pattern, then you can supply as a parameter expected_errors (alias: errors)
+
+The possible values you can specify is one or more of these ones: :length, :min_length, :max_length, :value, :required_data, :excluded_data, :string_set_not_allowed
+
+    :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.
+  
+Examples:
+
+```ruby
+"10-20:N".gen errors: [:min_length]
+#> 627, 098262, 3408
+
+"20:N".gen errors: [:length, :value]
+#> |13, tS1b)r-1)<RT65202eTo6bV0g~, 021400323<2ahL0NP86a698063*56076
+
+"10:L/n/".gen errors: [:value]
+#> 1hwIw;v{KQ, mpk*l]!7:!, wocipgZt8@
+```
+
+### Validate if a string is following a pattern
+
+If you need to validate if a specific text is fulfilling the pattern you can use the validate method.
+
+If a string pattern supplied and no other parameters supplied the output will be an array with the errors detected. 
+
+
+Possible output values, empty array (validation without errors detected) or one or more of: :min_length, :max_length, :length, :value, :string_set_not_allowed, :required_data, :excluded_data
+
+In case an array of patterns supplied it will return only true or false
+
+Examples:
+
+```ruby
+#StringPattern class
+StringPattern.validate((text: "This text will be validated", pattern: :"10-20:Xn")
+#> [:max_length, :length, :value, :string_set_not_allowed]
+
+#String class
+"10:N".validate "333444"
+#> [:min_length, :length]
+
+#Symbol class
+:"10:N".validate("333444")
+#> [:min_length, :length]
+
+#Array class
+["5:L","3:xn","4-10:n"].validate "DjkljFFc343444390"
+#> false
+```
+
+If we want to validate a string with a pattern and we are expecting to get specific errors, you can supply the parameter expected_errors (alias: errors) or not_expected_errors (aliases: non_expected_errors, not_errors).
+
+In this case the validate method will return true or false.
+
+Examples: 
+
+```ruby
+"10:N".val "3445", errors: [:min_length]
+#> true
+
+"10:N/[09]/".validate "4434039440", errors: [:value]
+#> false
+
+"10-12:XN/x/".validate "FDDDDDAA343434", errors: [:max_length, :required_data]
+#> true
+```
+
+### Configure
+
+#### SP_ADD_TO_RUBY
+
+This gem adds the methods generate (alias: gen) and validate (alias: val) to the Ruby classes: String, Array and Symbol. 
+
+Also adds the method generate (alias: gen) to Kernel. By default (true) it is always added. 
+
+In case you don't want to be added, just before requiring the library set:
+
+```ruby
+SP_ADD_TO_RUBY = false
+require 'string_pattern'
+```
+
+In case it is set to true (default) then you will be able to use:
+
+```ruby
+require 'string_pattern'
+
+#String object
+"20-30:@".gen 
+#>dkj34MljjJD-df@jfdluul.dfu
+
+"10:L/N/[/-./%d%]".validate("12ds6f--.s") 
+#>[:value, :string_set_not_allowed]
+
+"20-40:@".validate(my_email)
+
+#Kernel
+gen "10:N"
+#>3433409877
+
+#Array object
+"(,3:N,) ,3:N,-,2:N,-,2:N".split(",").generate 
+#>(937) 980-65-05
+
+%w{( 3:N ) 1:_ 3:N - 2:N - 2:N}.gen 
+#>(045) 448-63-09
+
+["1:L", "5-10:LN", "-", "3:N"].gen 
+#>zqWihV-746
+```
+
+#### national_chars
+
+To specify which national characters will be used when using the symbol type: T, you use StringPattern.national_chars, by default is the English alphabet
+
+```ruby
+StringPattern.national_chars = (('a'..'z').to_a + ('A'..'Z').to_a).join + "áéíóúÁÉÍÓÚüÜñÑ"
+"10-20:Tn".gen #>AAñ34Ef99éNOP
+```
+
+#### optimistic
+
+If true it will check on the strings of the array positions supplied if they have the pattern format and assume in that case that is a pattern. If not it will assume the patterns on the array will be supplied as symbols. By default is set to true.
+
+```ruby
+StringPattern.optimistic = false
+["5:X","fixedtext", "3:N"].generate
+#>5:Xfixedtext3:N
+[:"5:X","fixedtext", :"3:N"].generate
+#>AUJKJfixedtext454
+
+StringPattern.optimistic = true
+["5:X","fixedtext", "3:N"].generate
+#>KKDMEfixedtext344
+[:"5:X","fixedtext", :"3:N"].generate
+#>SAAERfixedtext988
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/marioruiz/string_pattern.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/lib/string/pattern/add_to_ruby.rb

@@ -0,0 +1,67 @@
+class Array
+  # It will generate an string following the pattern specified
+  # The positions with string patterns need to be supplied like symbols:
+  # [:"10:N", "fixed", :"10-20:XN/x/"].generate #> "1024320001fixed4OZjNMTnuBibwwj"
+  def generate(expected_errors: [], **synonyms)
+    StringPattern.generate(self, expected_errors: expected_errors, **synonyms)
+  end
+
+  alias_method :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
+end
+
+class String
+  # 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
+
+  # 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
+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
+
+  # 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)
+  end
+
+  alias_method :val, :validate
+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)
+      StringPattern.generate(pattern, expected_errors: expected_errors, **synonyms)
+    else
+      puts " Kernel generate method: class not recognized:#{pattern.class}"
+    end
+  end
+
+  alias_method :gen, :generate
+end
+

data/lib/string_pattern.rb

@@ -0,0 +1,859 @@
+SP_ADD_TO_RUBY = true if !defined?(SP_ADD_TO_RUBY)
+require_relative 'string/pattern/add_to_ruby' if SP_ADD_TO_RUBY
+
+# SP_ADD_TO_RUBY: (TrueFalse, default: true) You need to add this constant value before requiring the library if you want to modify the default.
+#               If true it will add 'generate' and 'validate' methods to the classes: Array, String and Symbol. Also it will add 'generate' method to Kernel
+#               aliases: 'gen' for 'generate' and 'val' for 'validate'
+#               Examples of use:
+#                 "(,3:N,) ,3:N,-,2:N,-,2:N".split(",").generate #>(937) 980-65-05
+#                 %w{( 3:N ) 1:_ 3:N - 2:N - 2:N}.gen #>(045) 448-63-09
+#                 ["1:L", "5-10:LN", "-", "3:N"].gen #>zqWihV-746
+#                 gen("10:N") #>3433409877
+#                 "20-30:@".gen #>dkj34MljjJD-df@jfdluul.dfu
+#                 "10:L/N/[/-./%d%]".validate("12ds6f--.s") #>[:value, :string_set_not_allowed]
+#                 "20-40:@".validate(my_email)
+# national_chars: (Array, default: english alphabet)
+#                 Set of characters that will be used when using T pattern
+# optimistic: (TrueFalse, default: true)
+#             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.
+class StringPattern
+  class << self
+    attr_accessor :national_chars, :optimistic
+  end
+  @national_chars = (('a'..'z').to_a + ('A'..'Z').to_a).join
+  @optimistic = true
+  NUMBER_SET = ('0'..'9').to_a
+  SPECIAL_SET = [' ', '~', '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '-', '_', '+', '=', '{', '}', '[', ']', "'", ';', ':', '?', '>', '<', '`', '|', '/', '"']
+  ALPHA_SET_LOWER = ('a'..'z').to_a
+  ALPHA_SET_CAPITAL = ('A'..'Z').to_a
+
+
+  Pattern = Struct.new(:min_length, :max_length, :symbol_type, :required_data, :excluded_data, :data_provided,
+                       :string_set, :all_characters_set)
+
+  ###############################################
+  # Analyze the pattern supplied and returns an object of Pattern structure including:
+  # min_length, max_length, symbol_type, required_data, excluded_data, data_provided, string_set, all_characters_set
+  ###############################################
+  def StringPattern.analyze(pattern, silent:false)
+    min_length, max_length, symbol_type=pattern.to_s.scan(/(\d+)-(\d+):(.+)/)[0]
+    if min_length.nil?
+      min_length, symbol_type=pattern.to_s.scan(/^!?(\d+):(.+)/)[0]
+      max_length=min_length
+      if min_length.nil?
+        puts "pattern argument not valid on StringPattern.generate: #{pattern.inspect}" unless silent
+        return pattern.to_s
+      end
+    end
+    symbol_type='!'+symbol_type if pattern.to_s[0]=='!'
+    min_length=min_length.to_i
+    max_length=max_length.to_i
+
+    required_data=Array.new
+    excluded_data=Array.new
+    required=false
+    excluded=false
+    data_provided=Array.new
+    a=symbol_type
+    begin_provided=a.index('[')
+    excluded_end_tag=false
+    if begin_provided!=nil
+      c=begin_provided+1
+      until c==a.size or (a[c..c]==']' and a[c..c+1]!=']]')
+        if a[c..c+1]==']]'
+          data_provided.push(']')
+          c=c+2
+        elsif a[c..c+1]=='%%' and !excluded then
+          data_provided.push('%')
+          c=c+2
+        else
+          if a[c..c]=='/' and !excluded
+            if a[c..c+1]=='//'
+              data_provided.push(a[c..c])
+              if required
+                required_data.push([a[c..c]])
+              end
+              c=c+1
+            else
+              if !required
+                required=true
+              else
+                required=false
+              end
+            end
+          else
+            if required
+              required_data.push([a[c..c]])
+            else
+              if a[c..c]=='%'
+                if a[c..c+1]=='%%' and excluded
+                  excluded_data.push([a[c..c]])
+                  c=c+1
+                else
+                  if !excluded
+                    excluded=true
+                  else
+                    excluded=false
+                    excluded_end_tag=true
+                  end
+                end
+              else
+                if excluded
+                  excluded_data.push([a[c..c]])
+                end
+              end
+
+            end
+            if excluded==false and excluded_end_tag==false
+              data_provided.push(a[c..c])
+            end
+            excluded_end_tag=false
+          end
+          c=c+1
+        end
+      end
+      symbol_type=symbol_type[0..begin_provided].to_s + symbol_type[c..symbol_type.size].to_s
+    end
+
+    required=false
+    required_symbol=''
+    symbol_type.split(//).each {|stc|
+      if stc=='/'
+        if !required
+          required=true
+        else
+          required=false
+        end
+      else
+        if required
+          required_symbol+=stc
+        end
+      end
+    }
+    national_set=@national_chars.split(//)
+
+    if !symbol_type['x'].nil?
+      alpha_set=ALPHA_SET_LOWER
+      unless symbol_type['X'].nil?
+        alpha_set = alpha_set + ALPHA_SET_CAPITAL
+      end
+    else
+      if !symbol_type['X'].nil?
+        alpha_set=ALPHA_SET_CAPITAL
+      elsif !symbol_type['L'].nil? then
+        alpha_set = ALPHA_SET_LOWER + ALPHA_SET_CAPITAL
+      else
+        alpha_set = ALPHA_SET_LOWER + ALPHA_SET_CAPITAL
+      end
+    end
+    unless symbol_type['T'].nil?
+      alpha_set=alpha_set+national_set
+    end
+
+    unless required_symbol['x'].nil?
+      required_data.push ALPHA_SET_LOWER
+    end
+    unless required_symbol['X'].nil?
+      required_data.push ALPHA_SET_CAPITAL
+    end
+    unless required_symbol['L'].nil?
+      required_data.push(ALPHA_SET_CAPITAL+ALPHA_SET_LOWER)
+    end
+    unless required_symbol['T'].nil?
+      required_data.push national_set
+    end
+    required_symbol=required_symbol.downcase
+    string_set=Array.new
+    all_characters_set=ALPHA_SET_CAPITAL+ALPHA_SET_LOWER+NUMBER_SET+SPECIAL_SET+data_provided+national_set
+
+    unless symbol_type['_'].nil?
+      if symbol_type['$'].nil?
+        string_set.push(' ')
+      end
+      unless required_symbol['_'].nil?
+        required_data.push([' '])
+      end
+    end
+
+    symbol_type = symbol_type.downcase
+
+    if !symbol_type['x'].nil? or !symbol_type['l'].nil? or !symbol_type['t'].nil?
+      string_set = string_set + alpha_set
+    end
+    unless symbol_type['n'].nil?
+      string_set = string_set + NUMBER_SET
+    end
+    unless symbol_type['$'].nil?
+      string_set = string_set + SPECIAL_SET
+    end
+    unless symbol_type['*'].nil?
+      string_set = string_set+all_characters_set
+    end
+    if data_provided.size!=0
+      string_set = string_set + data_provided
+    end
+    unless required_symbol['n'].nil?
+      required_data.push NUMBER_SET
+    end
+    unless required_symbol['$'].nil?
+      required_data.push SPECIAL_SET
+    end
+    if excluded_data.size>0
+      string_set=string_set-excluded_data.flatten
+    end
+    string_set.uniq!
+    return Pattern.new(min_length, max_length, symbol_type, required_data, excluded_data, data_provided,
+                       string_set, all_characters_set)
+  end
+
+  ###############################################
+  #   Generate a random string based on the pattern supplied
+  #   (if SP_ADD_TO_RUBY==true, by default is true) To simplify its use it is part of the String, Array, Symbol and Kernel Ruby so can be easily used also like this:
+  #     "10-15:Ln/x/".generate    #generate method on String class (alias: gen)
+  #     ['(', :'3:N', ')', :'6-8:N'].generate    #generate method on Array class (alias: gen)
+  #     generate("10-15:Ln/x/")   #generate Ruby Kernel method
+  #     generate(['(', :'3:N', ')', :'6-8:N'])   #generate Ruby Kernel method
+  #     "(,3:N,) ,3:N,-,2:N,-,2:N".split(",").generate #>(937) #generate method on Array class (alias: gen)
+  #     %w{( 3:N ) 1:_ 3:N - 2:N - 2:N}.gen #generate method on Array class, using alias gen method
+  #   Input:
+  #     pattern: array or string of different patterns. A pattern is a string with this info:
+  #       "length:symbol_type" or "min_length-max_length:symbol_type"
+  #		In case an array supplied, the positions using a string pattern should be supplied as symbols if StringPattern.optimistic==false
+  #
+  #   These are the possible string patterns you will be able to supply:
+  #     If at the beginning we supply the character ! the resulting string won't fulfill the pattern. This character need to be the first character of the pattern.
+  #     min_length -- minimum length of the string
+  #     max_length (optional) -- maximum length of the string. If not provided the result will be with the min_length provided
+  #     symbol_type -- the type of the string we want.
+  #                   you can use a combination of any ot these:
+  #                     x for alpha in lowercase
+  #                     X for alpha in capital letters
+  #                     L for all kind of alpha in capital and lower letters
+  #                     T For the national characters defined on StringPattern.national_chars
+  #                     n for number
+  #                     $ for special characters (includes space)
+  #                     _ for space
+  #                     * all characters
+  #                     [characters] the characters we want. If we want to add also the ] character you have to write: ]]. If we want to add also the % character you have to write: %%
+  #                     %characters% the characters we don't want on the resulting string. %% to exclude the character %
+  #                     /symbols or characters/ If we want these characters to be included on the resulting string. If we want to add also the / character you have to write: //
+  #                   We can supply 0 to allow empty strings, this character need to be at the beginning
+  #                   If you want to include the character " use \"
+  #                   If you want to include the character \ use \\
+  #                   If you want to include the character [ use \[
+  #                   Another uses: @ for email
+  #   Examples:
+  #    [:"6:X", :"3-8:_N"]
+  #       # it will return a string starting with 6 capital letters and then a string containing numbers and space from 3 to 8 characters, for example: "LDJKKD34 555"
+  #    [:"6-15:L_N", "fixed text", :"3:N"]
+  #       # it will return a string of 6-15 characters containing Letters-spaces-numbers, then the text: 'fixed text' and at the end a string of 3 characters containing numbers, for example: ["L_N",6,15],"fixed text",["N",3] "3 Am399 afixed text882"
+  #    "10-20:LN[=#]"
+  #       # it will return a string of 10-20 characters containing Letters and/or numbers and/or the characters = and #, for example: eiyweQFWeL#do4Vl
+  #     "30:TN_[#=]/x/"
+  #       # it will return a string of 30 characters containing national characters defined on StringPattern.national_chars and/or numbers and/or spaces and/or the characters # = and it is necessary the resultant string includes lower alpha chars. For example: HaEdQTzJ3=OtXMh1mAPqv7NCy=upLy
+  #     "10:N[%0%]"
+  #       # 10 characters length containing numbers and excluding the character 0, for example: 3523497757
+  #     "10:N[%0%/AB/]"
+  #       # 10 characters length containing numbers and excluding the character 0 and necessary to contain the characters A B, for example: 3AA4AA57BB
+  #     "!10:N[%0%/AB/]"
+  #       # it will generate a string that doesn't fulfill the pattern supplied, examples:
+  #       # a6oMQ4JK9g
+  #       # /Y<N6Aa[ae
+  #       # 3444439A34B32
+  #     "10:N[%0%/AB/]", errors: [:length]
+  #       # it will generate a string following the pattern and with the errors supplied, in this case, length, example: AB44
+  #   Output:
+  #     the generated string
+  ###############################################
+  def StringPattern.generate(pattern, expected_errors: [], **synonyms)
+    string=''
+
+    expected_errors=synonyms[:errors] if synonyms.keys.include?(:errors)
+
+    if expected_errors.kind_of?(Symbol)
+      expected_errors=[expected_errors]
+    end
+
+    if pattern.kind_of?(Array)
+      pattern.each {|pat|
+        if pat.kind_of?(Symbol)
+          if pat.to_s.scan(/^!?\d+-?\d*:.+/).size>0
+            string<<StringPattern.generate(pat.to_s, expected_errors: expected_errors)
+          else
+            string<<pat.to_s
+          end
+        elsif pat.kind_of?(String) then
+          if @optimistic and pat.to_s.scan(/^!?\d+-?\d*:.+/).size>0
+            string<<StringPattern.generate(pat.to_s, expected_errors: expected_errors)
+          else
+            string<<pat
+          end
+        else
+          puts "StringPattern.generate: it seems you supplied wrong array of patterns: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
+          return ''
+        end
+      }
+      return string
+    elsif pattern.kind_of?(String) or pattern.kind_of?(Symbol)
+      patt=StringPattern.analyze(pattern)
+      min_length=patt.min_length
+      max_length=patt.max_length
+      symbol_type=patt.symbol_type
+
+      required_data=patt.required_data
+      excluded_data=patt.excluded_data
+      string_set=patt.string_set
+      all_characters_set=patt.all_characters_set
+
+      required_chars=Array.new
+      required_data.each {|rd|
+        required_chars<<rd if rd.size==1
+      }
+      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 ''
+      end
+
+      string_set_not_allowed=all_characters_set-string_set
+
+    else
+      puts "pattern argument not valid on StringPattern.generate: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
+      return pattern.to_s
+    end
+
+    allow_empty=false
+    deny_pattern=false
+    if symbol_type[0..0]=='!'
+      deny_pattern=true
+      possible_errors=[:length, :value, :required_data, :excluded_data, :string_set_not_allowed]
+      (rand(possible_errors.size)+1).times {
+        expected_errors<<possible_errors.sample
+      }
+      expected_errors.uniq!
+      if symbol_type[1..1]=='0'
+        allow_empty=true
+      end
+    elsif symbol_type[0..0]=='0' then
+      allow_empty=true
+    end
+    if expected_errors.include?(:min_length) or expected_errors.include?(:length) or
+        expected_errors.include?(:max_length)
+      allow_empty=!allow_empty
+    elsif expected_errors.include?(:value) or
+        expected_errors.include?(:excluded_data) or
+        expected_errors.include?(:required_data) or
+        expected_errors.include?(:string_set_not_allowed) and allow_empty
+      allow_empty=false
+    end
+
+    length=min_length
+    symbol_type_orig=symbol_type
+
+    expected_errors_left=expected_errors.dup
+
+    symbol_type=symbol_type_orig
+
+    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 ''
+      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 ''
+      end
+
+      if string_set_not_allowed.size==0 and expected_errors_left.include?(:string_set_not_allowed)
+        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 ''
+      end
+    end
+
+    if expected_errors_left.include?(:min_length) or
+        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)
+        if min_length>0
+          if allow_empty
+            length=rand(min_length).to_i
+          else
+            length=rand(min_length-1).to_i+1
+          end
+          if required_data.size>length and required_data.size<min_length
+            length=required_data.size
+          end
+          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 ''
+        end
+      elsif expected_errors_left.include?(:max_length) or expected_errors_left.include?(:length)
+        length=max_length+1+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
+        length=0
+      else
+        if max_length==min_length
+          length=min_length
+        else
+          length=min_length + rand(max_length - min_length + 1)
+        end
+      end
+    end
+
+    if deny_pattern
+      if required_data.size==0 and expected_errors_left.include?(:required_data)
+        expected_errors_left.delete(:required_data)
+      end
+
+      if excluded_data.size==0 and expected_errors_left.include?(:excluded_data)
+        expected_errors_left.delete(:excluded_data)
+      end
+
+      if string_set_not_allowed.size==0 and expected_errors_left.include?(:string_set_not_allowed)
+        expected_errors_left.delete(:string_set_not_allowed)
+      end
+
+      if symbol_type=='!@' and expected_errors_left.size==0 and !expected_errors.include?(:length) and
+          (expected_errors.include?(:required_data) or expected_errors.include?(:excluded_data))
+        expected_errors_left.push(:value)
+      end
+
+    end
+
+
+    string = ''
+    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
+        }
+      end
+      if required_data.size>0
+        positions_to_set=(0..(string.size-1)).to_a
+        required_data.each {|rd|
+          if (string.split(//) & rd).size>0
+            rd_to_set=(string.split(//) & rd).sample
+          else
+            rd_to_set=rd.sample
+          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 ''
+            else
+              k=positions_to_set.sample
+              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
+            positions_to_set.delete(k)
+          end
+        }
+      end
+      excluded_data.each {|ed|
+        if (string.split(//) & ed).size>0
+          (string.split(//) & ed).each {|s|
+            string.gsub!(s, string_set.sample)
+          }
+        end
+      }
+
+      if expected_errors_left.include?(:value)
+        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 ''
+        end
+        (rand(string.size)+1).times {
+          string[rand(string.size)]=(all_characters_set-string_set).sample
+        }
+        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
+          chars_to_remove.each {|char_to_remove|
+            string.gsub!(char_to_remove, (string_set-chars_to_remove).sample)
+          }
+        }
+        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
+        }
+        expected_errors_left.delete(:excluded_data)
+      end
+
+      if expected_errors_left.include?(:string_set_not_allowed) and string_set_not_allowed.size>0
+        (rand(string.size)+1).times {
+          string[rand(string.size)]=string_set_not_allowed.sample
+        }
+        expected_errors_left.delete(:string_set_not_allowed)
+      end
+
+    elsif (symbol_type=='@' or symbol_type=='!@') and length>0
+      if min_length>6 and length<6
+        length=6
+      end
+      if deny_pattern and
+          (expected_errors.include?(:required_data) or expected_errors.include?(:excluded_data) or
+              expected_errors.include?(:string_set_not_allowed))
+        expected_errors_left.push(:value)
+        expected_errors.push(:value)
+        expected_errors.uniq!
+        expected_errors_left.uniq!
+      end
+
+      expected_errors_left_orig=expected_errors_left.dup
+      tries=0
+      begin
+        expected_errors_left=expected_errors_left_orig.dup
+        tries+=1
+        string=''
+        alpha_set=ALPHA_SET_LOWER + ALPHA_SET_CAPITAL
+        string_set=alpha_set + NUMBER_SET + ['.'] + ['_'] + ['-']
+        string_set_not_allowed=all_characters_set-string_set
+
+        extension='.'
+        at_sign='@'
+
+        if expected_errors_left.include?(:value)
+          if rand(2)==1
+            extension=(all_characters_set-['.']).sample
+            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
+            }
+            (rand(extension.size)+1).times {
+              extension[rand(extension.size)]=(string_set-alpha_set-['.']).sample
+            }
+            expected_errors_left.delete(:value)
+          else
+            1.upto(rand(3)+2) {|i| extension << alpha_set.sample.downcase
+            }
+          end
+          if rand(2)==1
+            at_sign=(string_set-['@']).sample
+            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
+            }
+          else
+            1.upto(2) {|i| extension << alpha_set.sample.downcase
+            }
+          end
+        end
+        length_e=length-extension.size - 1
+        length1=rand(length_e-1) + 1
+        length2=length_e-length1
+        1.upto(length1) {|i| string << string_set.sample}
+
+        string << at_sign
+
+        domain=''
+        domain_set=alpha_set + NUMBER_SET + ['.'] + ['-']
+        1.upto(length2) {|i| domain << domain_set.sample.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
+          }
+          expected_errors_left.delete(:value)
+        end
+        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
+          }
+          expected_errors_left.delete(:value)
+          expected_errors_left.delete(:string_set_not_allowed)
+        end
+
+        error_regular_expression=false
+
+        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
+              good_result=false
+            else
+              good_result=true
+            end
+          elsif expected_errors_left.size==0 and
+              (expected_errors-[:length, :min_length, :max_length]).size==0
+            good_result=true
+          elsif expected_errors!=[:length]
+            if !error_regular_expression
+              good_result=false
+            elsif expected_errors.include?(:value)
+              good_result=true
+            end
+          end
+        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 ''
+      end
+    end
+
+    return string
+  end
+
+
+  ##############################################
+  # This method is defined to validate if the text_to_validate supplied follows the pattern
+  # It works also with array of patterns but in that case will return only true or false
+  #  input:
+  #     text (String) (synonyms: text_to_validate, validate) --  The text to validate
+  #     pattern -- symbol with this info: "length:symbol_type" or "min_length-max_length:symbol_type"
+  #       min_length -- minimum length of the string
+  #       max_length (optional) -- maximum length of the string. If not provided the result will be with the min_length provided
+  #       symbol_type -- the type of the string we want.
+  #     expected_errors (Array of symbols) (optional) (synonyms: errors) --  :length, :min_length, :max_length, :value, :required_data, :excluded_data, :string_set_not_allowed
+  #     not_expected_errors (Array of symbols) (optional) (synonyms: not_errors, non_expected_errors) --  :length, :min_length, :max_length, :value, :required_data, :excluded_data, :string_set_not_allowed
+  #  example:
+  #     validate(text: "This text will be validated", pattern: :"10-20:Xn", expected_errors: [:value, :max_length])
+  #
+  #   Output:
+  #     if expected_errors and not_expected_errors are not supplied: an array with all detected errors
+  #     if expected_errors or not_expected_errors supplied: true or false
+  #     if array of patterns supplied, it will return true or false
+  ###############################################
+  def StringPattern.validate(text: '', pattern: '', expected_errors: [], not_expected_errors: [], **synonyms)
+    text_to_validate=text
+    text_to_validate=synonyms[:text_to_validate] if synonyms.keys.include?(:text_to_validate)
+    text_to_validate=synonyms[:validate] if synonyms.keys.include?(:validate)
+    expected_errors=synonyms[:errors] if synonyms.keys.include?(:errors)
+    not_expected_errors=synonyms[:not_errors] if synonyms.keys.include?(:not_errors)
+    not_expected_errors=synonyms[:non_expected_errors] if synonyms.keys.include?(:non_expected_errors)
+    #:length, :min_length, :max_length, :value, :required_data, :excluded_data, :string_set_not_allowed
+    if (expected_errors.include?(:min_length) or expected_errors.include?(:max_length)) and !expected_errors.include?(:length)
+      expected_errors.push(:length)
+    end
+    if (not_expected_errors.include?(:min_length) or not_expected_errors.include?(:max_length)) and !not_expected_errors.include?(:length)
+      not_expected_errors.push(:length)
+    end
+    if pattern.kind_of?(Array) and pattern.size==1
+      pattern=pattern[0]
+    elsif pattern.kind_of?(Array) and pattern.size>1 then
+      total_min_length=0
+      total_max_length=0
+      all_errors_collected=Array.new
+      result=true
+      num_patt=0
+      patterns=Array.new
+      pattern.each {|pat|
+        if (pat.kind_of?(String) and (!StringPattern.optimistic or
+            (StringPattern.optimistic and pat.to_s.scan(/(\d+)-(\d+):(.+)/).size==0 and pat.to_s.scan(/^!?(\d+):(.+)/).size==0))) #fixed text
+          symbol_type=''
+          min_length=max_length=pat.length
+        elsif pat.kind_of?(Symbol) or (pat.kind_of?(String) and StringPattern.optimistic and
+            (pat.to_s.scan(/(\d+)-(\d+):(.+)/).size>0 or pat.to_s.scan(/^!?(\d+):(.+)/).size>0))
+          patt=StringPattern.analyze(pat)
+          min_length=patt.min_length
+          max_length=patt.max_length
+          symbol_type=patt.symbol_type
+        else
+          puts "String pattern class not supported (#{pat.class} for #{pat})"
+        end
+
+        patterns.push({pattern: pat, min_length: min_length, max_length: max_length, symbol_type: symbol_type})
+
+        total_min_length+=min_length
+        total_max_length+=max_length
+
+        if num_patt==(pattern.size-1) # i am in the last one
+          if text_to_validate.length<total_min_length
+            all_errors_collected.push(:length)
+            all_errors_collected.push(:min_length)
+          end
+
+          if text_to_validate.length>total_max_length
+            all_errors_collected.push(:length)
+            all_errors_collected.push(:max_length)
+          end
+
+        end
+        num_patt+=1
+
+
+      }
+
+      num_patt=0
+      patterns.each {|patt|
+
+        tmp_result=false
+        (patt[:min_length]..patt[:max_length]).each {|n|
+          res=StringPattern.validate(text: text_to_validate[0..n-1], pattern: patt[:pattern], not_expected_errors: not_expected_errors)
+          if res.kind_of?(Array)
+            all_errors_collected+=res
+          end
+
+          if res.kind_of?(TrueClass) or (res.kind_of?(Array) and res.size==0) #valid
+            #we pass in the next one the rest of the pattern array list: pattern: pattern[num_patt+1..pattern.size]
+            res=StringPattern.validate(text: text_to_validate[n..text_to_validate.length], pattern: pattern[num_patt+1..pattern.size], expected_errors: expected_errors, not_expected_errors: not_expected_errors)
+
+            if res.kind_of?(Array)
+              if ((all_errors_collected + res)-expected_errors).size>0
+                tmp_result=false
+              else
+                all_errors_collected+=res
+                tmp_result=true
+              end
+            elsif res.kind_of?(TrueClass) then
+              tmp_result=true
+            end
+            return true if tmp_result
+          end
+        }
+
+        unless tmp_result
+          return false
+        end
+        num_patt+=1
+      }
+      return result
+    end
+
+    if (pattern.kind_of?(String) and (!StringPattern.optimistic or
+        (StringPattern.optimistic and pattern.to_s.scan(/(\d+)-(\d+):(.+)/).size==0 and pattern.to_s.scan(/^!?(\d+):(.+)/).size==0))) #fixed text
+      symbol_type=''
+      min_length=max_length=pattern.length
+    else #symbol
+      patt=StringPattern.analyze(pattern)
+      min_length=patt.min_length
+      max_length=patt.max_length
+      symbol_type=patt.symbol_type
+
+      required_data=patt.required_data
+      excluded_data=patt.excluded_data
+      string_set=patt.string_set
+      all_characters_set=patt.all_characters_set
+
+      required_chars=Array.new
+      required_data.each {|rd|
+        required_chars<<rd if rd.size==1
+      }
+      if (required_chars.flatten & excluded_data.flatten).size>0
+        puts "pattern argument not valid on StringPattern.validate, a character cannot be required and excluded at the same time: #{pattern.inspect}, expected_errors: #{expected_errors.inspect}"
+        return ''
+      end
+
+    end
+
+    if text_to_validate.nil?
+      return false
+    end
+    detected_errors=Array.new
+
+    if text_to_validate.length<min_length
+      detected_errors.push(:min_length)
+      detected_errors.push(:length)
+    end
+    if text_to_validate.length>max_length
+      detected_errors.push(:max_length)
+      detected_errors.push(:length)
+    end
+
+    if symbol_type=='' #fixed text
+      if pattern.to_s!=text.to_s #not equal
+        detected_errors.push(:value)
+        detected_errors.push(:required_data)
+      end
+    else # pattern supplied
+      if symbol_type!='@'
+        if required_data.size>0
+          required_data.each {|rd|
+            if (text_to_validate.split(//) & rd).size==0
+              detected_errors.push(:value)
+              detected_errors.push(:required_data)
+              break
+            end
+          }
+        end
+        if excluded_data.size>0
+          if (excluded_data & text_to_validate.split(//)).size>0
+            detected_errors.push(:value)
+            detected_errors.push(:excluded_data)
+          end
+        end
+        string_set_not_allowed=all_characters_set-string_set
+        text_to_validate.split(//).each {|st|
+          if string_set_not_allowed.include?(st)
+            detected_errors.push(:value)
+            detected_errors.push(:string_set_not_allowed)
+            break
+          end
+        }
+      else #symbol_type=="@"
+        string=text_to_validate
+        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 error_regular_expression
+          detected_errors.push(:value)
+        end
+
+      end
+    end
+
+    if expected_errors.size==0 and not_expected_errors.size==0
+      return detected_errors
+    else
+      if expected_errors & detected_errors == expected_errors
+        if (not_expected_errors & detected_errors).size > 0
+          return false
+        else
+          return true
+        end
+      else
+        return false
+      end
+    end
+  end
+
+end
+

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: string_pattern
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Mario Ruiz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-21 00:00:00.000000000 Z
+dependencies: []
+description: You can easily generate strings supplying a very simple pattern. Also
+  you can validate if a text fulfill an specific pattern or even generate a string
+  following a pattern and returning wrong length, value... for testing your applications.
+email: marioruizs@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- LICENSE
+- README.md
+- lib/string/pattern/add_to_ruby.rb
+- lib/string_pattern.rb
+homepage: https://github.com/MarioRuiz/string_pattern
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: 'Generates easily random string following a simple pattern. ''10-20:Xn/x/''.generate
+  #>qBstvc6JN8ra'
+test_files: []