Class: Regexp

Inherits:

Object

• Object
• Regexp

Defined in:

lib/string/pattern/add_to_ruby.rb

Instance Method Summary

• #generate(expected_errors: [], **synonyms) ⇒ Object (also: #gen)

  it will generate an string following the pattern specified.

• #to_sp ⇒ Object

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

Instance Method Details

#generate(expected_errors: [], **synonyms) ⇒ Object Also known as: gen

it will generate an string following the pattern specified

# File 'lib/string/pattern/add_to_ruby.rb', line 54

def generate(expected_errors: [], **synonyms)
  StringPattern.generate(self, expected_errors: expected_errors, **synonyms)
end

#to_sp ⇒ Object

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 62

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