regextest 0.1.2

data/lib/regextest/back.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+# Copyright (C) 2016 Mikio Ikoma
+
+class Regextest::Back; end
+require 'regextest/common'
+require 'regextest/back/main'
+
+# Backend class of regextest. Generate matched string
+class Regextest::Back
+  include Regextest::Common
+  
+  # Constructor
+  def initialize(json_obj)
+    @reg_source = @@parse_options[:reg_source]
+    @json_obj = json_obj
+    
+    # COMMENTED OUT at present
+    # make a hash to manage names and corresponding objects
+    # @name_hash = make_name_hash(@json_obj, {})
+    # get test cases (commented at present)
+    # @test_info = Regextest::Back::TestCase.new(@json_obj, @name_hash)
+    
+    # default max recursion is 8.
+    @max_nest = TstConstRecursionMax
+  end
+  
+  # A public method that generates string to match the regexp
+  def generate
+    generate_obj = Regextest::Back::Main.new(@json_obj, @max_nest)
+    generate_obj.generate
+  end
+  
+  # make a hash to manage names and corresponding objects
+  def make_name_hash(target, name_hash)
+    # register id (and refer-name in case of parenthesis)
+    raise "Internal error: found duplicate id #{target["id"]}" if target["id"] && name_hash[target["id"]]
+    name_hash[target["id"]] = target
+    name_hash[target["refer_name"]] = target if(target["type"] == "LEX_PAREN")
+    
+    # recursively register names
+    if(target["value"])
+      if( Array === target["value"])
+        target["value"].each{|child| make_name_hash(child, name_hash)}
+      else
+        make_name_hash(target["value"], name_hash)
+      end
+    end
+    name_hash
+  end
+  
+end
+
+# Test suite (execute when this file is specified in command line)
+if __FILE__ == $0
+
+end
+

data/lib/regextest/back/element.rb

@@ -0,0 +1,151 @@
+# encoding: utf-8
+
+# Copyright (C) 2016 Mikio Ikoma
+
+require "pp"
+require 'regextest/common'
+
+class Regextest::Back::Element
+  include Regextest::Common
+  def initialize(param)
+    @command = param[:cmd]
+    @param = param
+    @candidates = param[:data] if @command == :CMD_SELECT
+  end
+  
+  attr_reader :param, :command, :candidates
+  
+  # random fix
+  def random_fix
+    if @command == :CMD_SELECT
+      offset = (@candidates.size > 1)?TstRand(@candidates.size):0
+      result = @candidates[offset]
+      @candidates = [result]   # fixed!
+    else
+      raise "invalid command at random_fix: #{@command}"
+    end
+    result
+  end
+  
+  # size of candidates
+  def size
+    if(@candidates)
+      @candidates.size
+    else
+      raise "internal error: candidates not found at size-method"
+    end
+  end
+  
+  # [] of candidates
+  def [](num)
+    if(@candidates)
+      @candidates[num]
+    else
+      raise "internal error: candidates not found at at-method"
+    end
+  end
+  
+  # narrow down candidates
+  def intersect(other_obj)
+    raise "invalid command at intersect" if(other_obj.command != :CMD_SELECT)
+    work = @candidates & other_obj.candidates
+    if work.size > 0
+      @candidates = work
+    else
+      nil
+    end
+  end
+  
+  # exclude
+  def exclude(other_obj)
+    raise "invalid command at exclude" if(other_obj.command != :CMD_SELECT)
+    work = @candidates - other_obj.candidates
+    if work.size > 0
+      @candidates = work
+    else
+      nil
+    end
+  end
+  
+  # join candidates
+  def union(other_obj)
+    raise "invalid command at union" if(other_obj.command != :CMD_SELECT)
+    #@candidates |= other_obj.candidates
+    @candidates += other_obj.candidates # to be faster
+  end
+  
+  # for simple pretty print
+  def inspect
+    case @command
+    when :CMD_SELECT
+      if(@candidates)
+        @candidates.inspect
+      else
+        @param[:data].inspect
+      end
+    when :CMD_LOOK_BEHIND, :CMD_LOOK_AHEAD, :CMD_NOT_LOOK_BEHIND, :CMD_NOT_LOOK_AHEAD
+      @param.inspect
+    when :CMD_ANC_LINE_BEGIN, :CMD_ANC_LINE_END, :CMD_ANC_WORD_BOUND, :CMD_ANC_WORD_UNBOUND,
+         :CMD_ANC_STRING_BEGIN, :CMD_ANC_STRING_END, :CMD_ANC_STRING_END2, :CMD_ANC_MATCH_START,
+         :CMD_ANC_LOOK_BEHIND2, :CMD_ANC_RELUCTANT_BEGIN, :CMD_ANC_RELUCTANT_END
+      @param.inspect
+    else
+      raise "inner error, invalid command #{@command}"
+    end
+  end
+  
+  # Includes new line or not
+  def new_line?
+    @candidates.index("\n")
+  end
+  
+  # Sets new line
+  def set_new_line
+    @candidates = ["\n"]
+  end
+  
+  # Is word-elements only?
+  def word_elements?
+    @candidates.join("").match(/^\p{Word}+$/)
+  end
+  
+  # is non-word-elements only?
+  def non_word_elements?
+    @candidates.join("").match(/^\p{^Word}+$/)
+  end
+
+  # set word-elements
+  def set_word_elements
+    @candidates.select!{|elem| elem.match(/^\w$/)}
+  end
+  
+  # set non_word-elements
+  def set_non_word_elements
+    @candidates.select!{|elem| elem.match(/^\W$/)}
+  end
+  
+  # checks empty
+  def empty?
+    @candidates.size == 0
+  end
+  
+  # factory method to generate any char element
+  def self.any_char
+    # BUG: must consider other character set!
+    Regextest::Back::Element.new({cmd: :CMD_SELECT, data:  (" ".."\x7e").to_a})
+  end
+  
+  # factory method to generate any char element
+  def reverse
+    @candidates = ((" ".."\x7e").to_a) - @candidates
+    self
+  end
+  
+
+end
+
+# Test suite (execute when this file is specified in command line)
+if __FILE__ == $0
+end
+
+

data/lib/regextest/back/main.rb

@@ -0,0 +1,356 @@
+# encoding: utf-8
+
+# Copyright (C) 2016 Mikio Ikoma
+
+require 'regextest/common'
+require 'regextest/back/element'
+require 'regextest/back/result'
+
+# Main class of back-end. Construct candidates array and narrow down
+class Regextest::Back::Main
+  include Regextest::Common
+  def initialize(json_obj, max_nest)
+    @json_obj = json_obj
+    @max_nest = max_nest
+    @parens_hash = {}  # hash to keep string generated by parentheses
+    @nest = 0          # current nest of back-reference
+    @quit_mode = false # flag for preventing from increase of nest
+                       # if true, \g<foo> is restrained if possible
+  end
+  
+  def generate
+    # seek parentheses because there are references defined ahead
+    seek_parens(@json_obj)
+    
+    # generate pre-result of matched string (pre-result contains candidates of letters)
+    pre_result = generate_candidates({json: @json_obj})
+    return nil unless pre_result
+    TstLog("pre_result1:\n" + pre_result.inspect)
+    
+    # narrow down the candidates
+    result = narrow_down_candidates(pre_result)
+    TstLog("pre_result2:\n" + result.inspect)
+    return nil if !result || !result.narrow_down
+    
+    # fixes result
+    result.fix
+    
+    result
+  end
+  
+  # seek parentheses
+  def seek_parens(target)
+    if(target["type"] == "LEX_PAREN")
+      @parens_hash[target["refer_name"]] = {:target => target}
+    end
+    if(target["value"])
+      if( Array === target["value"])
+        target["value"].each{|child| seek_parens(child)}
+      else
+        seek_parens(target["value"])
+      end
+    end
+  end
+  
+  # generate pre-result of matched string (pre-result contains candidates of letters)
+  def generate_candidates(param)
+    target = param[:json]
+    # puts "MATCH type:#{target["type"]}"
+    
+    result = nil
+    case target["type"]
+    when "LEX_SEQ"  # sequence of letters or parentheses
+      result = generate_candidates_seq(param)
+    when "LEX_SELECT"
+      result = generate_candidates_select(param)
+    when "LEX_PAREN"
+      result = generate_candidates_paren(param)
+    when "LEX_CHAR_CLASS"
+      result = generate_candidates_char_class(param)
+    when "LEX_BRACKET", "LEX_SIMPLIFIED_CLASS", "LEX_ANY_LETTER", "LEX_POSIX_CHAR_CLASS", "LEX_UNICODE_CLASS"
+      result = generate_candidates({json: target["value"]})
+    when "LEX_REPEAT"
+      result = generate_candidates_repeat(param)
+    when "LEX_RANGE"
+      result = generate_candidates_range(param)
+    when "LEX_BACK_REFER", "LEX_NAMED_REFER"
+      result = generate_candidates_back_refer(param)
+    when "LEX_NAMED_GENERATE"
+      result = generate_candidates_named_generate(param)
+    when "LEX_CHAR"
+      result = generate_candidates_char(param)
+    when "LEX_ANC_LINE_BEGIN"
+      result = Regextest::Back::Element.new({cmd: :CMD_ANC_LINE_BEGIN})
+    when "LEX_ANC_LINE_END"
+      result = Regextest::Back::Element.new({cmd: :CMD_ANC_LINE_END})
+    when "LEX_ANC_WORD_BOUND"
+      result = Regextest::Back::Element.new({cmd: :CMD_ANC_WORD_BOUND})
+    when "LEX_ANC_WORD_UNBOUND"
+      result = Regextest::Back::Element.new({cmd: :CMD_ANC_WORD_UNBOUND})
+    when "LEX_ANC_STRING_BEGIN"
+      result = Regextest::Back::Element.new({cmd: :CMD_ANC_STRING_BEGIN})
+    when "LEX_ANC_STRING_END"
+      result = Regextest::Back::Element.new({cmd: :CMD_ANC_STRING_END})
+    when "LEX_ANC_STRING_END2"
+      result = Regextest::Back::Element.new({cmd: :CMD_ANC_STRING_END2})
+    when "LEX_ANC_MATCH_START"
+      result = Regextest::Back::Element.new({cmd: :CMD_ANC_MATCH_START})
+    when "LEX_ANC_LOOK_BEHIND2"
+      result = Regextest::Back::Element.new({cmd: :CMD_ANC_LOOK_BEHIND2})
+    when "LEX_OPTION_PAREN"     # options are processed at front-end
+      result = []
+    when "LEX_EMPTY"
+      result = []
+    else
+      raise "#{target["type"]} not implemented (from generate_candidates routine)"
+    end
+    result
+  end
+  
+  # sequence of letters or parentheses
+  def generate_candidates_seq(param)
+    target = param[:json]
+    results = []
+    target["value"].each do |elem|
+      generated_string = generate_candidates({json: elem})
+      if(Array === generated_string)
+        generated_string.flatten!(1)
+        results += generated_string
+      else
+        results.push generated_string
+      end
+    end
+    # nil if one element failed
+    if(results.index(nil))
+      result = nil
+    else
+      # result = results.join("")
+      result = results
+    end
+    result
+  end
+  
+  # selection of sequence. such as (aa|b|c)
+  def generate_candidates_select(param)
+    target = param[:json]
+    if param[:forced_select]
+      # index is specified by condition 
+      if target["value"][param[:forced_select]]
+        result = generate_candidates({json: target["value"][param[:forced_select]]})
+      else
+        # regexp such as /^(?:b|(a))(?(1)1)$/ match "b"!
+        result = []
+      end
+    else
+      # success if there is at least one result
+      offsets = (0 ... target["value"].size).to_a
+      if !param[:atomic] && offsets.size > 1
+        offsets = TstShuffle(offsets)  # shuffle if not atomic group (this proceduce is not sufficient...)
+      end
+      result = nil
+      offsets.each do | offset |
+        result = generate_candidates({json: target["value"][offset]})
+        break if(result)
+      end
+    end
+    result
+  end
+  
+  # parenthesis
+  def generate_candidates_paren(param)
+    target = param[:json]
+    # analyze options of the parenthesis
+    paren_prefix = target["prefix"]
+    # pp target["prefix"]
+    if(paren_prefix == "<=")
+      lb_result = generate_candidates({json: target["value"]})
+      result = Regextest::Back::Element.new({cmd: :CMD_LOOK_BEHIND, result: lb_result})
+    elsif(paren_prefix == "=")
+      la_result = generate_candidates({json: target["value"]})
+      result = Regextest::Back::Element.new({cmd: :CMD_LOOK_AHEAD, result: la_result})
+    elsif(paren_prefix == "<!")
+      lb_result = generate_candidates({json: target["value"]})
+      result = Regextest::Back::Element.new({cmd: :CMD_NOT_LOOK_BEHIND, result: lb_result})
+    elsif(paren_prefix == "!")
+      la_result = generate_candidates({json: target["value"]})
+      result = Regextest::Back::Element.new({cmd: :CMD_NOT_LOOK_AHEAD, result: la_result})
+    elsif(paren_prefix == ">")   # atomic group
+      generate_string = generate_candidates({json: target["value"], atomic: true})
+      @parens_hash[target["refer_name"]][:generated] ||= []
+      @parens_hash[target["refer_name"]][:generated][@nest] = generate_string
+      result = generate_string
+    elsif(paren_prefix == "")   # simple parenthesis
+      generate_string = generate_candidates({json: target["value"]})
+      @parens_hash[target["refer_name"]][:generated] ||= []
+      @parens_hash[target["refer_name"]][:generated][@nest] = generate_string
+      result = generate_string
+    else
+      # when condition is specified
+      select_num = nil
+      if(target["condition_name"] && target["condition_name"].length > 0)
+        if @parens_hash[target["condition_name"]][:generated]
+          select_num = 0
+        else
+          select_num = 1
+        end
+      end
+      
+      if(select_num == 1 && target["value"]["type"] != "LEX_SELECT")
+        result = nil
+      else
+        generate_string = generate_candidates({json: target["value"], forced_select: select_num})
+        
+        @parens_hash[target["refer_name"]][:generated] ||= []
+        @parens_hash[target["refer_name"]][:generated][@nest] = generate_string
+        result = generate_string
+      end
+    end
+    result
+  end
+  
+  # char class
+  def generate_candidates_char_class(param)
+    target = param[:json]
+    results = Regextest::Back::Element.new({cmd: :CMD_SELECT, data: []})
+    target["value"].each do | elem |
+      if sub_results = generate_candidates({json: elem})
+        results.union sub_results
+      end
+    end
+    if results.size > 0
+      result = results
+    else
+      result = nil
+    end
+    result
+  end
+  
+  # repeat
+  def generate_candidates_repeat(param)
+    target = param[:json]
+    if(@quit_mode)
+      repeat = target["min_repeat"]
+    elsif(target["max_repeat"] > target["min_repeat"])
+      repeat = target["min_repeat"]+TstRand(target["max_repeat"]-target["min_repeat"]+1)
+    else
+      repeat = target["min_repeat"]
+    end
+    result = []
+    if target["repeat_option"].index("reluctant")
+      result.push Regextest::Back::Element.new({cmd: :CMD_ANC_RELUCTANT_BEGIN, id: target["id"]})
+    end
+    # puts "repeat=#{repeat} quit=#{@quit_mode} nest=#{@nest}"
+    repeat.times do
+      if( elem = generate_candidates({json: target["value"]}))
+        result.push elem
+      else
+        result = nil
+        break
+      end
+      
+      # quit to repeat if the first element is begin anchor
+      elem.flatten! if Array === elem  # flatten considering duplicated repeat
+      if elem.size > 0 && elem[0].respond_to?(:command) && elem[-1].respond_to?(:command)
+        break if elem[0].command == :CMD_ANC_LINE_BEGIN && !elem[-1].new_line?
+        break if elem[0].command == :CMD_ANC_STRING_BEGIN
+      end
+    end
+    if target["repeat_option"].index("reluctant")
+      result.push Regextest::Back::Element.new({cmd: :CMD_ANC_RELUCTANT_END, id: target["id"]})
+    end
+    result
+  end
+  
+  # range
+  def generate_candidates_range(param)
+    target = param[:json]
+    letter = []
+    codepoints = (target["begin"]..target["end"]).to_a
+    letter = codepoints.map{| codepoint | [codepoint].pack("U*")}   # to be faster
+    result = Regextest::Back::Element.new({cmd: :CMD_SELECT, data: letter})
+  end
+  
+  # back_refer
+  def generate_candidates_back_refer(param)
+    target = param[:json]
+    if @parens_hash[target["refer_name"]][:generated]
+      relative_num = (target["relative_num"]=="")?(-1):(@nest + target["relative_num"].to_i)
+      result = @parens_hash[target["refer_name"]][:generated][relative_num]
+    else
+      result = nil
+    end
+    result
+  end
+  
+  # named generate
+  def generate_candidates_named_generate(param)
+    target = param[:json]
+    @quit_mode = true if(@nest >= @max_nest)
+    if(@quit_mode)
+      result = nil
+    else
+      @nest += 1
+      if target["refer_name"] == "$$_0"     # recursively call whole expression
+        result = generate_candidates({json: @json_obj})
+      else
+        result = generate_candidates({json: @parens_hash[target["refer_name"]][:target]})
+      end
+      @nest -= 1
+    end
+    result
+  end
+  
+  # char
+  def generate_candidates_char(param)
+    target = param[:json]
+    case target["value"]
+    when String
+      result = Regextest::Back::Element.new({cmd: :CMD_SELECT, data: [target["value"]]})
+    else
+      result = generate_candidates({json: target["value"]})
+    end
+    result
+  end
+  
+  # narrow down candidates considering anchors
+  def narrow_down_candidates(candidate_array)
+    results = Regextest::Back::Result.new
+    candidate_array.each do | elem |
+      command = elem.command
+      case command
+      when :CMD_SELECT
+        results.push_body elem
+      when :CMD_LOOK_AHEAD, :CMD_NOT_LOOK_AHEAD
+        if(sub_results = narrow_down_candidates(elem.param[:result]))
+          results.add_look_ahead(command, sub_results)
+        else
+          return nil
+        end
+      when :CMD_LOOK_BEHIND, :CMD_NOT_LOOK_BEHIND
+        if(sub_results = narrow_down_candidates(elem.param[:result]))
+          results.add_look_behind(command, sub_results)
+        else
+          return nil
+        end
+      when :CMD_ANC_LINE_BEGIN, :CMD_ANC_LINE_END, :CMD_ANC_WORD_BOUND, :CMD_ANC_WORD_UNBOUND,
+           :CMD_ANC_STRING_BEGIN, :CMD_ANC_STRING_END, :CMD_ANC_STRING_END2, :CMD_ANC_MATCH_START,
+           :CMD_ANC_LOOK_BEHIND2
+        results.add_anchor(command)
+      when :CMD_ANC_RELUCTANT_BEGIN, :CMD_ANC_RELUCTANT_END
+        results.add_reluctant_repeat(elem)
+      else
+        raise "inner error, invalid command at checking anchors: #{command}"
+      end
+    end
+    if !results.merge
+      return nil
+    end
+    results
+  end
+end
+
+# Test suite (execute when this file is specified in command line)
+if __FILE__ == $0
+
+end
+