regextest 0.1.2

data/lib/regextest/front/empty.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+# Copyright (C) 2016 Mikio Ikoma
+
+require 'regextest/common'
+
+# Empty part
+module Regextest::Front::Empty
+  class TEmpty
+    include Regextest::Common
+    @@id = 0   # a class variable for generating unique name of element
+
+    # Constructor
+    def initialize
+      TstLog("Empty: ")
+      @offset = -1
+      @length = 0
+    end
+    
+    attr_reader :offset, :length
+    
+    # set options
+    def set_options(options)
+      TstLog("Empty set_options: #{options[:reg_options].inspect}");
+      # do nothing
+      self
+    end
+    
+    # generate json format
+    def json
+      @@id += 1
+        "{" +
+           "\"type\": \"LEX_EMPTY\", \"id\": \"E#{@@id}\", \"value\": \"\", " +
+           "\"offset\": #{@offset}, \"length\": #{@length}" +
+        "}"
+    end
+  end
+end
+
+# Test suite (execute when this file is specified in command line)
+if __FILE__ == $0 
+end
+

data/lib/regextest/front/letter.rb

@@ -0,0 +1,327 @@
+# encoding: utf-8
+
+# Copyright (C) 2016 Mikio Ikoma
+
+require 'regextest/common'
+require 'regextest/front/char-class'     # character class element
+require 'regextest/front/range'          # range of character point
+require 'regextest/regex-option'
+require 'regextest/front/unicode'
+
+# A letter
+module Regextest::Front::Letter
+  class TLetter
+    include Regextest::Common
+    include Regextest::Front::CharClass
+    include Regextest::Front::Range
+    @@id = 0   # a class variable for generating unique name of element
+    @@unicode_ranges = {}
+      
+    # Constructor
+    def initialize(type, val)
+      TstLog("TLetter: type:#{type}, value:#{val}")
+      @options = nil
+      @data_type = type
+      @value = val[0] || ""
+      @offset = val[1] || -1
+      @length = val[2] || 0
+      @obj = nil
+    end
+    
+    attr_reader :offset, :length, :value
+    
+    # generate character(s) corresponding type of the character
+    def set_attr(type, val)
+      case type
+      when :LEX_CHAR, :LEX_SPACE
+        @data_type = :LEX_CHAR
+        @obj = CharClass.new([ TRange.new(val)])
+      when :LEX_SIMPLE_ESCAPE
+        @data_type = :LEX_CHAR
+        @obj = CharClass.new([ TRange.new(val[1..1])])
+      when :LEX_CODE_LITERAL, :LEX_ESCAPED_LETTER, :LEX_UNICODE, :LEX_CONTROL_LETTER, :LEX_META_LETTER, :LEX_OCTET
+        @data_type = :LEX_CHAR
+        @obj = CharClass.new([ TRange.new(eval('"'+ val + '"'))])   # convert using ruby's eval
+      when :LEX_BRACKET
+        @obj = Regextest::Front::Bracket.new(val)
+      when :LEX_SIMPLIFIED_CLASS
+        @obj = generate_simplified_class(val)
+      when :LEX_POSIX_CHAR_CLASS
+        @obj = generate_char_class(val)
+      when :LEX_UNICODE_CLASS
+        @obj = generate_unicode_char(val)
+      when :LEX_ANY_LETTER
+        @obj = generate_any_char(val)
+      when :LEX_SPECIAL_LETTER
+        @obj = generate_special_char(val)
+      when :LEX_AND_AND
+        raise "Internal error: enexpected LEX_AND_AND"
+        @obj = CharClass.new([TRange.new(val)])
+      else
+        raise "Error: internal error, type:#{type} not implemented"
+      end
+    end
+    
+    # generate whole set of letters (depends on option)
+    def generate_any_char(val)
+      if @options[:reg_options].is_unicode?
+        obj = CharClass.new(TstConstUnicodeCharSet)
+      else
+        obj = CharClass.new( [ TRange.new("\x20", "\x7e") ] )
+      end
+      
+      if( @options[:reg_options].is_multiline? )
+          obj.add_ranges( [ TRange.new("\n") ] )
+      end
+      obj
+    end
+    
+    # generate special character class
+    def generate_special_char(val)
+      @data_type = :LEX_CHAR
+      obj = nil
+      case val
+      when "\\R"
+        if @options[:reg_options].is_unicode?
+          # BUG: "\x0a\x0d" must be supported!
+          obj = CharClass.new(
+                  [ TRange.new("\x0a", "\x0d"), TRange.new("\u{85}"),
+                    TRange.new("\u{2028}", "\u{2029}") ]
+                )
+        else
+          # BUG: "\x0a\x0d" must be supported!
+          obj = CharClass.new(
+                  [ TRange.new("\x0a", "\x0d") ]
+                )
+        end
+      when "\\X"
+        if @options[:reg_options].is_unicode?
+          # BUG: (?>\P{M}\p{M}*)
+          obj = CharClass.new("M")
+          obj.set_reverse(@options)
+        else
+          obj = CharClass.new(
+                  [ TRange.new("\x20", "\x7e"), TRange.new("\n") ]
+                )
+        end
+      else
+        raise "Error: internal error, invalid special char: #{val}"
+      end
+      obj
+    end
+    
+    # generate simplified character class
+    def generate_simplified_class(val)
+      obj = nil
+      case val
+      when "\\w"
+        if @options[:reg_options].is_unicode?
+          obj = CharClass.new("Letter|Mark|Number|Connector_Punctuation")
+        else
+          obj = CharClass.new(
+                  [ TRange.new('a', 'z'), TRange.new('A', 'Z'),
+                    TRange.new('0', '9'), TRange.new('_') ]
+                )
+        end
+      when "\\W"
+        obj = CharClass.new(
+                [ TRange.new("\x20", "\x2f"), TRange.new("\x3a", "\x40"),
+                  TRange.new("\x5b", "\x5e"), TRange.new("\x60"),
+                  TRange.new("\x7b", "\x7e") ]
+              )
+      when "\\d"
+        if @options[:reg_options].is_unicode?
+          #obj = CharClass.new([ TRange.new('0', '9'),  TRange.new('０', '９')])
+          obj = CharClass.new("Decimal_Number")
+        else
+          obj = CharClass.new(
+                   [ TRange.new('0', '9') ]
+                 )
+        end
+      when "\\D"
+        obj = CharClass.new(
+                [ TRange.new("\x20", "\x2f"), TRange.new("\x3a", "\x7e") ]
+              )
+      when "\\h"
+        obj = CharClass.new(
+                [ TRange.new('0', '9') , TRange.new('a', 'f'), TRange.new('A', 'F')]
+              )
+      when "\\H"
+        obj = CharClass.new(
+                [ TRange.new("\x20", "\x2f"), TRange.new("\x3a", "\x40"),
+                  TRange.new("\x47", "\x60"), TRange.new("\x67", "\x7e")]
+              )
+      when "\\s"
+        ascii_ranges = [ TRange.new(' '), TRange.new("\x9", "\xd") ]
+        if @options[:reg_options].is_unicode?
+          obj = CharClass.new("Line_Separator|Paragraph_Separator|Space_Separator")
+          obj.add_ranges(ascii_ranges + [ TRange.new("\u{85}") ])
+        else
+          obj = CharClass.new(ascii_ranges)
+        end
+      when "\\S"
+        obj = CharClass.new(
+                [ TRange.new("\x21", "\x7e") ]
+              )
+      when "\\n", "\\r", "\\t", "\\f", "\\a", "\\e", "\\v"
+        obj = CharClass.new(
+                [ TRange.new(eval("\""+ string + "\"")) ]
+              )
+      when "\\b", "\\z", "\\A", "\\B", "\\G", "\\Z"
+        warn "Ignored unsupported escape char #{val}."
+      when "\\c", "\\x", "\\C", "\\M"
+        raise "Error: Unsupported escape char #{string}"
+      else
+        raise "Error: Invalid simplifiled class #{val}"
+      end
+      obj
+    end
+    
+    # generate Unicode class (ie. \p{...} | \P{...})
+    def generate_unicode_char(val)
+      # Dynamic loading of Unicode regarding modules (for better performance).
+      # commented out since this code not executed at ruby 2.0.0
+      # require 'regextest/front/unicode'
+      
+      if(md = val.match(/(p|P)\{(\^?)(\w+)\}/))
+        class_name = md[3].downcase
+        reverse = (md[2] && md[2]=="^")?true:false
+        
+        # if not found at cache
+        if !@@unicode_ranges[class_name]
+          #work = Regextest::Front::Unicode.property(class_name) ||
+          #  raise("Invalid Unicode class #{class_name} in #{val}")
+          # construct char class
+          #work = work.map{|elem| TRange.new(elem[0], elem[1])}
+          @@unicode_ranges[class_name] = CharClass.new(class_name)
+        end
+      else
+        raise "Internal error, inconsistent Unicode class #{val}"
+      end
+      
+      # ￥P{^...} is equivalent to \p{...}
+      if((md[1] == "p" && !reverse) || (md[1] == "P" && reverse))
+        @@unicode_ranges[class_name]
+      else      # \P{}  or \p{^}
+        @@unicode_ranges[class_name].set_reverse(@options)
+      end
+    end
+    
+    def classname_to_ranges(arrays)
+    end
+    
+    # generate POSIX character class (ie. [[:alpha:]], etc.)
+    def generate_char_class(val)
+      if(md = val.match(/^\[\:(\^)?(\w+)\:\]$/))
+        reverse = (md[1] && md[1]=="^")?true:false
+        class_name = md[2]
+      else
+        raise "internal error, invalid POSIX class name(#{val})"
+      end
+      
+      obj = nil
+      if @options[:reg_options].is_unicode?
+        obj = CharClass.new(class_name)
+      else
+        case class_name
+        when 'alnum'
+          obj = CharClass.new(
+                  [ TRange.new('a', 'z'), TRange.new('A', 'Z'),
+                    TRange.new('0', '9') ]
+                )
+        when 'alpha'
+          obj = CharClass.new(
+                  [ TRange.new('a', 'z'), TRange.new('A', 'Z') ]
+                )
+        when 'cntrl'
+          obj = CharClass.new(
+                  [ TRange.new("\x00", "\x1f"), TRange.new("\x7f") ]
+                )
+        when 'lower'
+          obj = CharClass.new(
+                  [ TRange.new('a', 'z') ]
+                )
+        when 'print'
+          obj = CharClass.new(
+                  [ TRange.new("\x20", "\x7e") ]
+                )
+        when 'space'
+          obj = CharClass.new(
+                  [ TRange.new(' '), TRange.new("\n"), TRange.new("\r"), 
+                    TRange.new("\t"), TRange.new("\f"), TRange.new("\v") ]
+                )
+        when 'digit'
+          obj = CharClass.new(
+                  [ TRange.new('0', '9') ]
+                )
+        when 'upper'
+          obj = CharClass.new(
+                  [ TRange.new('A', 'Z') ]
+                )
+        when 'blank'
+          obj = CharClass.new(
+                  [ TRange.new(' '), TRange.new("\t")  ]
+                )
+        when 'graph'
+          obj = CharClass.new(
+                  [ TRange.new("\x21", "\x7e") ]
+                )
+        when 'punct'
+          obj = CharClass.new(
+                  [ TRange.new("\x21", "\x23"), TRange.new("\x25", "\x2a"), 
+                    TRange.new("\x2c", "\x2f"), TRange.new("\x3a", "\x3b"),
+                    TRange.new("\x3f", "\x40"), TRange.new("\x5b", "\x5d"),
+                    TRange.new("\x5f"), TRange.new("\x7b"), TRange.new("\x7d") ]
+                )
+        when 'xdigit'
+          obj = CharClass.new(
+                  [ TRange.new('a', 'f'), TRange.new('A', 'F'),
+                    TRange.new('0', '9') ]
+                )
+        when 'word'
+          obj = CharClass.new(
+                  [ TRange.new('a', 'z'), TRange.new('A', 'Z'),
+                    TRange.new('0', '9'), TRange.new('_') ]
+                )
+        else
+          raise "Error: Invalid character class #{val}"
+        end
+      end
+      
+      if reverse
+        obj.set_reverse(@options)
+      end
+      
+      obj
+    end
+    
+    # enumerate codepoints
+    def enumerate
+      @obj.enumerate
+    end
+    
+    # set options
+    def set_options(options)
+      TstLog("Letter set_options: #{options[:reg_options].inspect}")
+      @options = options
+      set_attr(@data_type, @value)
+      @obj.set_options(options)
+      self
+    end
+    
+    # transform to json format
+    def json
+      @@id += 1
+      "{" +
+        "\"type\": \"#{@data_type}\", \"id\": \"L#{@@id}\", \"value\": #{@obj.json}, " +
+         "\"offset\": #{@offset}, \"length\": #{@length}" +
+      "}"
+    end
+  end
+end
+
+
+# Test suite (execute when this file is specified in command line)
+if __FILE__ == $0 
+end
+

data/lib/regextest/front/manage-parentheses.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+# Copyright (C) 2016 Mikio Ikoma
+
+# A class for managing parentheses
+class Regextest::Front::ManageParentheses
+  def initialize()
+    @paren_hash = {}
+    @paren_array = []
+  end
+  
+  # register a parenthesis
+  def add(paren)
+    # register capturable parentheses
+    if(paren.prefix.length == 0 ||    # capture without prefix or
+       (paren.prefix[-1] != ':' &&    # other than (?: or (?i: or (?imx), etc.
+        !paren.prefix.match(/^([imx]*(?:\-[imx]+)?)$/) &&
+        !paren.prefix.match(/^[\=\!\>]|\<[\=\!]/)
+       )
+      ) 
+      @paren_array.push paren
+    end
+    
+    # if name (ie. (?<foo>... ), register the name
+    if(paren.name)
+      @paren_hash[paren.name] = paren
+    end
+    paren
+  end
+  
+  # sort of parentheses (since number of parenthesis not analyze order but offset order)
+  def sort
+    # pp @paren_array.map{|paren| paren.offset}
+    @paren_array.sort{|x, y| x.offset <=> y.offset}.each_with_index do | paren, i |
+      # puts "$$_#{i+1}  offset:#{paren.offset}"
+      refer_name = "$$_#{i+1}"
+      @paren_hash[refer_name] = paren    # parenthesis number from 1
+      paren.set_refer_name(refer_name)
+    end
+  end
+  
+  # search target parenthesis
+  def get_paren(get_id, offset = nil)
+    if !offset
+      if(Integer === get_id)
+        @paren_hash["$$_#{get_id}"]
+      else
+        @paren_hash[get_id]
+      end
+    else
+      # puts "offset = #{offset}, id = #{get_id}"
+      target_id = @paren_array.size + 1
+      @paren_array.each_with_index do | paren, i |
+        # puts paren.offset
+        if paren.offset > offset
+          target_id = i + 1  # paren is started from 1
+          break
+        end
+      end
+      relative_offset = get_id.to_i
+      if relative_offset < 0
+        target_id += get_id.to_i
+      else
+        target_id += get_id.to_i - 1
+      end
+      @paren_hash["$$_#{target_id}"]
+    end
+  end
+end
+
+# Test suite (execute when this file is specified in command line)
+if __FILE__ == $0 
+end
+

data/lib/regextest/front/parenthesis.rb

@@ -0,0 +1,153 @@
+#encoding: utf-8
+
+# Copyright (C) 2016 Mikio Ikoma
+
+require 'regextest/common'
+require 'regextest/front/empty'          # parser class for empty part ("", (|) etc.)
+
+# Class for parsing parenthesis
+module Regextest::Front::Parenthesis
+  
+  class Paren
+    include Regextest::Common
+    include Regextest::Front::Empty
+    @@id = 0   # a class variable for generating unique name of element
+    
+    # Constructor
+    def initialize(paren_start, element = nil, paren_end = nil)
+      @options = @@parse_options
+      @paren_type = paren_start[0]
+      @offset = paren_start[1]
+      if paren_end
+        @length = (paren_end[1] - paren_start[1]) + paren_end[2]
+      else
+        @length = paren_start[2]
+      end
+      
+      # delete head '(', '?', and tail ")"
+      @prefix = @paren_type.sub(/^\(\??/, "")
+      if @prefix.index("(") != 0
+        @prefix.sub!(/\)$/, "")
+      end
+      
+      @name = get_name(@prefix)
+      @condition = nil  # set at generating json
+      @refer_name = nil
+      if element
+        TstLog("Parenthesis: name:#{@name}, offset:#{@offset}, element:#{element}")
+        @element = element
+        @type_name = "LEX_PAREN"
+      else
+        TstLog("Parenthesis: name:#{@name}, offset:#{@offset}, element: \"\"")
+        @element = TEmpty.new
+        @type_name = "LEX_OPTION_PAREN"    # (?x-i) etc.
+      end
+      @generated_string = []
+      @nest = 0
+    end
+    
+    attr_reader :prefix, :name, :refer_name, :offset, :length
+
+    # get name of parenthesis (if any)
+    def get_name(prefix)
+      if(md = prefix.match(/^[<'](\w+)[>']$/))
+        md[1]
+      else
+        nil
+      end
+    end
+
+    # get condition of parenthesis
+    def get_condition(prefix)
+      # puts "prefix: #{prefix}"
+      if(md = prefix.match(/^\((\d+)\)$/))
+        condition_name = @options[:parens].get_paren(md[1].to_i)
+        if !condition_name
+          raise "condition number #{prefix} is invalid"
+        end
+      elsif(md = prefix.match(/^\(<(\w+)>\)|\('(\w+)'\)$/))
+        match_string = md[1] || md[2]
+        condition_name = @options[:parens].get_paren(match_string)
+        if !condition_name
+          raise "condition name (#{match_string}) is not found"
+        end
+      else
+        condition_name = nil
+      end
+      
+      # check number of elements
+      if(condition_name)
+        if(Regextest::Front::Selectable::Selectable === @element)
+          if(@element.candidates.size > 2)
+            raise "invalid condition. 1 or 2 selectable elements"
+          end
+        end
+      end
+      
+      condition_name
+    end
+
+    # set unique name for back reference
+    def set_refer_name(name)
+      @refer_name = name
+    end
+
+    # get generated string
+    def get_value(relative_num = 0)
+      # print "gen: "; pp @generated_string
+      if(@generated_string.size > 0)
+        @generated_string[-1]
+      else
+        warn "Error: refer uninitialized parenthesis"
+        nil
+      end
+    end
+    
+    # set options
+    def set_options(options)
+      reg_options = options[:reg_options]
+      TstLog("Parenthesis set_options before: #{reg_options.inspect}, prefix: #{@prefix}");
+      if md = @prefix.match(/^([imxdau]*(?:\-[imx]*)?)(:)?$/)
+        if md[2]
+          # deep copy if (?imx: ) pattern
+          cur_options = reg_options.dup
+        else
+          # replace option if (?imx) pattern
+          cur_options = reg_options
+        end
+        cur_options.modify(md[1])
+        TstLog("Parenthesis set_options after: #{cur_options.inspect}, new_regopt: #{md[1]}");
+      else
+        cur_options = reg_options
+      end
+      
+      new_options = options.dup
+      new_options[:reg_options] = cur_options
+
+      @element.set_options(new_options)
+      self
+    end
+    
+    # transform to json format
+    def json
+      @@id += 1
+      @condition = get_condition(@prefix)
+      condition_name = @condition.refer_name if @condition
+      "{\"type\": \"#{@type_name}\"," +
+      " \"name\": \"#{@name}\"," +
+      " \"offset\": \"#{@offset}\"," +
+      " \"length\": \"#{@length}\"," +
+      " \"prefix\": \"#{@prefix}\"," +
+      " \"refer_name\": \"#{@refer_name}\"," +
+      " \"condition_name\": \"#{condition_name}\"," +
+      " \"id\": \"p#{@@id}\", " +
+      " \"value\": #{@element.json}" +
+      "}"
+    end
+  end
+end
+
+# Test suite (execute when this file is specified in command line)
+if __FILE__ == $0 
+end
+