class Regexp

Public Instance Methods

gen(expected_errors: [], **synonyms)
Alias for: generate
generate(expected_errors: [], **synonyms) click to toggle source

it will generate an string following the pattern specified

# File lib/string/pattern/add_to_ruby.rb, line 64
def generate(expected_errors: [], **synonyms)
  StringPattern.generate(self, expected_errors: expected_errors, **synonyms)
end
Also aliased as: gen
to_sp() click to toggle source

adds method to convert a Regexp to StringPattern returns an array of string patterns or just one string pattern

# File lib/string/pattern/add_to_ruby.rb, line 72
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