regextest 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ebc162f43002fb402e523b7d9a504a9593cce57
-  data.tar.gz: ef3b47e4e0b53e2d8a0c2eac831688fe805fe6c2
+  metadata.gz: dee3ca4abbe70edabbe42f690c1a3c586fe689e0
+  data.tar.gz: 7bfe0081c0432cb7e9f9da3e4918042a36770bc1
 SHA512:
-  metadata.gz: 642b88f4089090dad4b15a4b7b9486987d5d6ffd9a8c7ff7e76e6a95c6d6e51852718adc76e09e9a7589f66815d302dfa7c4ef44af70c7672667cd93b73cc545
-  data.tar.gz: 04c4b88d7f133428f2594fc6a7d623030702d01444f3846ca3d34839b2bd46b3d30e4c5a0a7da718bed5468c8e515aeebee16d5aca8f928235f2ee1af65fad22
+  metadata.gz: 4b2bf4c54259660e4f4509ee944676388530e6203266820b22a4cc32bb82d1adb849e8c535b8d4044057517fa8169ad9c39ec2ff23391ff43672042a492515f4
+  data.tar.gz: 8f9faee644cd13ade02be3cdcc1ab51eb8e4f14985402eb6ea732bfb988ac2eb363c82fa2da595bd39c2f3e2bbc514ead114a33603275000fd717167eae77fc3

data/lib/pre/unicode.rb

@@ -89,6 +89,11 @@ class RegextestPreUnicode
         # Generate hash of properties
         def self.property(class_name)
           case class_name.downcase
+          # Regextest defined char classes (from underscore)
+          when "_asciiprint"
+            ([[32, 126]])
+            
+          # Unicode.org defined char classes
 #{ranges_source}
           else
             warn "Class name (#\{class_name\}) not found. Ignored."

data/lib/regextest.rb

@@ -72,8 +72,11 @@ class Regextest
   # @raise [RuntimeError] if something wrong...
   # @raise [Regextest::RegextestTimeout] if detected timeout while verification. Option 'verification: false' may be workaround.
   def generate
-    TstConstRetryMax.times do | retry_count |
-    
+    start_time = Time.now
+    0.step(TstFixnumMax) do | retry_count |
+      duration = Time.now - start_time
+      break if retry_count >= TstConstRetryMax && duration >= TstConstRetryMaxSecond
+      
       # generate string
       reset_random_called
       @result = @back_end.generate(retry_count)
@@ -114,6 +117,7 @@ class Regextest
   def to_json
     @front_end.get_json_string
   end
+  
   #---------------#
   private
   
@@ -143,7 +147,7 @@ class Regextest
     when Regexp
       @reg_exp = param
       @@parse_options[:reg_options].set(@reg_exp.options)   # inner regex options have priorty
-      @reg_string = "#{@reg_exp}"    # this generates string with options
+      @reg_string = @@parse_options[:reg_options].prefix_reg + @reg_exp.source
     else
       raise "Error: string or regular expression required"
     end

data/lib/regextest/back/element.rb

@@ -8,10 +8,14 @@ require 'regextest/common'
 class Regextest::Back::Element
   include Regextest::Common
   def initialize(param)
-    # puts "Element param:#{param[:cmd]} data:#{param[:data].size}"
-    @command = param[:cmd]
+    # puts "Element param:#{param[:cmd]} data:#{param[:ranges].size}"
     @param = param
-    @candidates = param[:data] if @command == :CMD_SELECT
+    @command = param[:cmd]
+    @charset = param[:charset]
+    if @command == :CMD_SELECT
+      @candidates = param[:ranges].inject([]){|result, range| result += range.to_a}
+    end
+    # @candidates = param[:data] if @command == :CMD_SELECT
   end
   
   attr_reader :param, :command, :candidates
@@ -33,7 +37,8 @@ class Regextest::Back::Element
     if(@candidates)
       @candidates.size
     else
-      raise "internal error: candidates not found at size-method"
+      # raise "internal error: candidates not found at size-method"
+      0
     end
   end
   
@@ -82,13 +87,14 @@ class Regextest::Back::Element
       if(@candidates)
         @candidates.inspect
       else
-        @param[:data].inspect
+        @param[:ranges].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
+         :CMD_ANC_LOOK_BEHIND2, :CMD_ANC_RELUCTANT_BEGIN, :CMD_ANC_RELUCTANT_END,
+         :CMD_ANC_POSSESSIVE_BEGIN, :CMD_ANC_POSSESSIVE_END
       @param.inspect
     else
       raise "inner error, invalid command #{@command}"
@@ -107,24 +113,41 @@ class Regextest::Back::Element
   
   # Is word-elements only?
   def word_elements?
-    letters = @candidates.map{|elem| [elem].pack("U*")}
-    letters.join("").match(/^\p{Word}+$/)
+    letters = @candidates.map{|elem| [elem].pack("U*")}.join("")
+    if @charset == "u" || @charset == "d"
+      letters.match(/^\p{Word}+$/)
+    else
+      letters.match(/^\w+$/)
+    end
   end
   
   # is non-word-elements only?
   def non_word_elements?
-    letters = @candidates.map{|elem| [elem].pack("U*")}
-    letters.join("").match(/^\p{^Word}+$/)
+    letters = @candidates.map{|elem| [elem].pack("U*")}.join("")
+    if @charset == "u" || @charset == "d"
+      letters.match(/^\p{^Word}+$/)
+    else
+      letters.match(/^\W+$/)
+    end
   end
 
   # set word-elements
   def set_word_elements
-    @candidates.select!{|elem| [elem].pack("U*").match(/^\w$/)}
+    if @charset == "u" || @charset == "d"
+      @candidates.select!{|elem| [elem].pack("U*").match(/^\p{Word}$/)}
+    else
+      @candidates.select!{|elem| [elem].pack("U*").match(/^\w$/)}
+    end
   end
   
   # set non_word-elements
   def set_non_word_elements
-    @candidates.select!{|elem| [elem].pack("U*").match(/^\W$/)}
+    if @charset == "u" || @charset == "d"
+      @candidates.select!{|elem| [elem].pack("U*").match(/^\p{^Word}$/)}
+      #@candidates.select!{|elem| [elem].pack("U*").match(/^[[:^word:]]$/)}
+    else
+      @candidates.select!{|elem| [elem].pack("U*").match(/^[[:^word:]]$/)}
+    end
   end
   
   # checks empty
@@ -135,7 +158,7 @@ class Regextest::Back::Element
   # 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:  (0x20..0x7e).to_a})
+    Regextest::Back::Element.new({cmd: :CMD_SELECT, ranges:  [0x20..0x7e]})
   end
   
   # factory method to generate any char element

data/lib/regextest/back/main.rb

@@ -12,6 +12,7 @@ class Regextest::Back::Main
   def initialize(json_obj, max_nest, retry_count = 0)
     @json_obj = json_obj
     @max_nest = max_nest
+    @past_max_nest = 0 # max nest of the past
     @retry_count = retry_count
     @parens_hash = {}  # hash to keep string generated by parentheses
     @nest = 0          # current nest of back-reference
@@ -24,15 +25,15 @@ class Regextest::Back::Main
     seek_parens(@json_obj)
     
     # generate pre-result of matched string (pre-result contains candidates of letters)
-    pre_result = generate_candidates({json: @json_obj})
+    param = {}
+    pre_result = generate_candidates(@json_obj, param)
     return nil unless pre_result
-    TstLog("pre_result1:\n" + pre_result.inspect)
-    
+    TstLog("pre_result1:\n" + pre_result.map{|elem| elem.inspect}.join("\n"))
+
     # 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
     
@@ -54,32 +55,31 @@ class Regextest::Back::Main
   end
   
   # generate pre-result of matched string (pre-result contains candidates of letters)
-  def generate_candidates(param)
-    target = param[:json]
+  def generate_candidates(target, param)
     # puts "MATCH type:#{target["type"]}"
     
     result = nil
     case target["type"]
     when "LEX_SEQ"  # sequence of letters or parentheses
-      result = generate_candidates_seq(param)
+      result = generate_candidates_seq(target, param)
     when "LEX_SELECT"
-      result = generate_candidates_select(param)
+      result = generate_candidates_select(target, param)
     when "LEX_PAREN"
-      result = generate_candidates_paren(param)
+      result = generate_candidates_paren(target, 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"]})
+      result = generate_candidates_char_class(target, param)
+    when "LEX_BRACKET", "LEX_SIMPLIFIED_CLASS", "LEX_ANY_LETTER", "LEX_POSIX_CHAR_CLASS", "LEX_UNICODE_CLASS", "LEX_UNICODE_CLASS_BRACKET"
+      result = generate_candidates(target["value"], param)
     when "LEX_REPEAT"
-      result = generate_candidates_repeat(param)
+      result = generate_candidates_repeat(target, param)
     when "LEX_RANGE"
-      result = generate_candidates_range(param)
+      result = generate_candidates_range(target, param)
     when "LEX_BACK_REFER", "LEX_NAMED_REFER"
-      result = generate_candidates_back_refer(param)
+      result = generate_candidates_back_refer(target, param)
     when "LEX_NAMED_GENERATE"
-      result = generate_candidates_named_generate(param)
+      result = generate_candidates_named_generate(target, param)
     when "LEX_CHAR"
-      result = generate_candidates_char(param)
+      result = generate_candidates_char(target, param)
     when "LEX_ANC_LINE_BEGIN"
       result = Regextest::Back::Element.new({cmd: :CMD_ANC_LINE_BEGIN})
     when "LEX_ANC_LINE_END"
@@ -109,11 +109,10 @@ class Regextest::Back::Main
   end
   
   # sequence of letters or parentheses
-  def generate_candidates_seq(param)
-    target = param[:json]
+  def generate_candidates_seq(target, param)
     results = []
     target["value"].each do |elem|
-      generated_string = generate_candidates({json: elem})
+      generated_string = generate_candidates(elem, param)
       if(Array === generated_string)
         generated_string.flatten!(1)
         results += generated_string
@@ -132,12 +131,13 @@ class Regextest::Back::Main
   end
   
   # selection of sequence. such as (aa|b|c)
-  def generate_candidates_select(param)
-    target = param[:json]
+  def generate_candidates_select(target, param)
     if param[:forced_select]
-      # index is specified by condition 
-      if target["value"][param[:forced_select]]
-        result = generate_candidates({json: target["value"][param[:forced_select]]})
+      # index is specified by condition
+      offset = param[:forced_select]
+      param.delete :forced_select
+      if target["value"][offset]
+        result = generate_candidates(target["value"][offset], param)
       else
         # regexp such as /^(?:b|(a))(?(1)1)$/ match "b"!
         result = []
@@ -145,43 +145,72 @@ class Regextest::Back::Main
     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
+      
+      # shuffle if element size more than 1
+      offsets = TstShuffle(offsets)  if offsets.size > 1
+
       result = nil
-      offsets.each do | offset |
-        result = generate_candidates({json: target["value"][offset]})
-        break if(result)
+      if param[:atomic]
+        param.delete :atomic
+        # if atomic, assure proceeding results not appeared
+        offsets.each do | offset |
+          result = []
+          (0...offset).each do | prev |
+            la_result = generate_candidates(target["value"][prev], param)
+            result.push Regextest::Back::Element.new({cmd: :CMD_NOT_LOOK_AHEAD, result: la_result})
+          end
+          result.push generate_candidates(target["value"][offset], param)
+          break if(!result.find{|elem| !elem })
+        end
+      elsif negative_type = param[:negative]
+        # if negative, assure all results not appeared
+        result = []
+        offsets.each do | offset |
+          la_result = generate_candidates(target["value"][offset], param)
+          la_result.each do | elem |
+            if elem.command == :CMD_NOT_LOOK_AHEAD
+              result.push elem
+            else
+              result.push Regextest::Back::Element.new({cmd: negative_type, result: la_result})
+            end
+          end
+        end
+        param.delete :negative
+      else
+        offsets.each do | offset |
+          result = generate_candidates(target["value"][offset], param)
+          break if(result)
+        end
       end
     end
     result
   end
   
   # parenthesis
-  def generate_candidates_paren(param)
-    target = param[:json]
+  def generate_candidates_paren(target, param)
     # analyze options of the parenthesis
     paren_prefix = target["prefix"]
     # pp target["prefix"]
     if(paren_prefix == "<=")
-      lb_result = generate_candidates({json: target["value"]})
+      lb_result = generate_candidates(target["value"], param)
       result = Regextest::Back::Element.new({cmd: :CMD_LOOK_BEHIND, result: lb_result})
     elsif(paren_prefix == "=")
-      la_result = generate_candidates({json: target["value"]})
+      la_result = generate_candidates(target["value"], param)
       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})
+      param[:negative] = :CMD_NOT_LOOK_BEHIND
+      result = generate_candidates(target["value"], param)
     elsif(paren_prefix == "!")
-      la_result = generate_candidates({json: target["value"]})
-      result = Regextest::Back::Element.new({cmd: :CMD_NOT_LOOK_AHEAD, result: la_result})
+      param[:negative] = :CMD_NOT_LOOK_AHEAD
+      result = generate_candidates(target["value"], param)
     elsif(paren_prefix == ">")   # atomic group
-      generate_string = generate_candidates({json: target["value"], atomic: true})
+      param[:atomic] = true
+      generate_string = generate_candidates(target["value"], param)
       @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"]})
+      generate_string = generate_candidates(target["value"], param)
       @parens_hash[target["refer_name"]][:generated] ||= []
       @parens_hash[target["refer_name"]][:generated][@nest] = generate_string
       result = generate_string
@@ -199,7 +228,8 @@ class Regextest::Back::Main
       if(select_num == 1 && target["value"]["type"] != "LEX_SELECT")
         result = nil
       else
-        generate_string = generate_candidates({json: target["value"], forced_select: select_num})
+        param[:forced_select] = select_num
+        generate_string = generate_candidates(target["value"], param)
         
         @parens_hash[target["refer_name"]][:generated] ||= []
         @parens_hash[target["refer_name"]][:generated][@nest] = generate_string
@@ -210,11 +240,11 @@ class Regextest::Back::Main
   end
   
   # char class
-  def generate_candidates_char_class(param)
-    target = param[:json]
-    results = Regextest::Back::Element.new({cmd: :CMD_SELECT, data: []})
+  def generate_candidates_char_class(target, param)
+    charset = target["charset"]
+    results = Regextest::Back::Element.new({cmd: :CMD_SELECT, ranges: [], charset: charset})
     target["value"].each do | elem |
-      if sub_results = generate_candidates({json: elem})
+      if sub_results = generate_candidates(elem, param)
         results.union sub_results
       end
     end
@@ -227,12 +257,12 @@ class Regextest::Back::Main
   end
   
   # repeat
-  def generate_candidates_repeat(param)
-    target = param[:json]
+  def generate_candidates_repeat(target, param)
     max_repeat = target["max_repeat"]
     min_repeat = target["min_repeat"]
     
-    if @retry_count > 0
+    # reduce repeat count if retry and there are one or more \g<foo> calls
+    if @retry_count > 0 && @past_max_nest > 0
       @retry_count.times{ max_repeat = (max_repeat + 1)/2 }
     end
  
@@ -243,13 +273,15 @@ class Regextest::Back::Main
     else
       repeat = 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"]}))
+      if( elem = generate_candidates(target["value"], param))
         result.push elem
       else
         result = nil
@@ -263,23 +295,28 @@ class Regextest::Back::Main
         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
+    
+    if target["repeat_option"].index("possessive")
+      la_result = [ generate_candidates(target["value"], param) ].flatten
+      result.push Regextest::Back::Element.new({cmd: :CMD_NOT_LOOK_AHEAD, result: la_result})
+    end
     result
   end
   
   # range
-  def generate_candidates_range(param)
-    target = param[:json]
+  def generate_candidates_range(target, param)
+    charset = target["charset"]
     letter = []
-    codepoints = (target["begin"]..target["end"]).to_a
-    result = Regextest::Back::Element.new({cmd: :CMD_SELECT, data: codepoints})
+    codepoints = (target["begin"]..target["end"])
+    result = Regextest::Back::Element.new({cmd: :CMD_SELECT, ranges: [codepoints], charset: charset})
   end
   
   # back_refer
-  def generate_candidates_back_refer(param)
-    target = param[:json]
+  def generate_candidates_back_refer(target, param)
     if @parens_hash[target["refer_name"]][:generated]
       relative_num = -1   # default value
       if target["relative_num"] != ""
@@ -289,6 +326,13 @@ class Regextest::Back::Main
       end
       # puts "relative: #{relative_num}, nest=#{@nest}, :#{target}"
       result = @parens_hash[target["refer_name"]][:generated][relative_num]
+      
+      # Somehow /(^a)\1/ must match with "aa"
+      if result.size > 0 &&
+         (result[0].command == :CMD_ANC_LINE_BEGIN ||
+          result[0].command == :CMD_ANC_STRING_BEGIN)
+        result = result[1..-1]  # ignore first anchor
+      end
     else
       result = nil
     end
@@ -296,17 +340,17 @@ class Regextest::Back::Main
   end
   
   # named generate
-  def generate_candidates_named_generate(param)
-    target = param[:json]
+  def generate_candidates_named_generate(target, param)
     @quit_mode = true if(@nest >= @max_nest)
     if(@quit_mode)
       result = nil
     else
       @nest += 1
+      @past_max_nest = @nest if @nest > @past_max_nest
       if target["refer_name"] == "$$_0"     # recursively call whole expression
-        result = generate_candidates({json: @json_obj})
+        result = generate_candidates(@json_obj, param)
       else
-        result = generate_candidates({json: @parens_hash[target["refer_name"]][:target]})
+        result = generate_candidates(@parens_hash[target["refer_name"]][:target], param)
       end
       @nest -= 1
     end
@@ -314,14 +358,20 @@ class Regextest::Back::Main
   end
   
   # char
-  def generate_candidates_char(param)
-    target = param[:json]
+  def generate_candidates_char(target, param)
+    charset = target["charset"]
     case target["value"]
     when String
       codepoint = target["value"].unpack("U*")[0]
-      result = Regextest::Back::Element.new({cmd: :CMD_SELECT, data: [codepoint]})
+      result = Regextest::Back::Element.new(
+        {
+          cmd: :CMD_SELECT, 
+          ranges: [codepoint..codepoint],
+          charset: charset
+        }
+      )
     else
-      result = generate_candidates({json: target["value"]})
+      result = generate_candidates(target["value"], param)
     end
     result
   end
@@ -351,7 +401,8 @@ class Regextest::Back::Main
            :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
+      when :CMD_ANC_RELUCTANT_BEGIN, :CMD_ANC_RELUCTANT_END,
+           :CMD_ANC_POSSESSIVE_BEGIN, :CMD_ANC_POSSESSIVE_END
         results.add_reluctant_repeat(elem)
       else
         raise "inner error, invalid command at checking anchors: #{command}"