regextest 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b51a91bb714731ac6c008e71cc768024e7125ae0
-  data.tar.gz: e6f0cf1de571dc253c9097313c067763e4b09b14
+  metadata.gz: 1ebc162f43002fb402e523b7d9a504a9593cce57
+  data.tar.gz: ef3b47e4e0b53e2d8a0c2eac831688fe805fe6c2
 SHA512:
-  metadata.gz: 7e2cafea68bc1bde41e965fd3348c4bc8e4ad4160f96acb506081faa5b0db0d440461a879e5b6400bfa0dc8e04f4df3bc1276df26b7dc00e257c5bed72e5ef6e
-  data.tar.gz: 8848c862ab67d58fc053798d71139c84e84c5be3ccb6fb8651bb22dc9cb51ce70c728a613e6168773fc523b9d240913b53706e4914068496a54a3a6cf84374bf
+  metadata.gz: 642b88f4089090dad4b15a4b7b9486987d5d6ffd9a8c7ff7e76e6a95c6d6e51852718adc76e09e9a7589f66815d302dfa7c4ef44af70c7672667cd93b73cc545
+  data.tar.gz: 04c4b88d7f133428f2594fc6a7d623030702d01444f3846ca3d34839b2bd46b3d30e4c5a0a7da718bed5468c8e515aeebee16d5aca8f928235f2ee1af65fad22

data/Rakefile

@@ -20,21 +20,21 @@ file 'lib/regextest/front/bracket-parser.rb' => 'lib/regextest/front/bracket-par
 end
 
 # Generating Unicode parser
-file 'lib/regextest/front/unicode.rb' => 'lib/pre-unicode.rb' do
-  puts "making regextest/front/unicode.rb"
-  sh 'ruby  lib/pre-unicode.rb'
+file 'lib/regextest/unicode.rb' => 'lib/pre/unicode.rb' do
+  puts "making regextest/unicode.rb"
+  sh 'ruby  lib/pre/unicode.rb'
 end
 
 # Generating case-folding mapping
-file 'lib/regextest/front/case-folding.rb' => 'lib/pre-case-folding.rb' do
+file 'lib/regextest/front/case-folding.rb' => 'lib/pre/case-folding.rb' do
   puts "making regextest/front/case-folding.rb"
-  sh 'ruby  lib/pre-case-folding.rb'
+  sh 'ruby  lib/pre/case-folding.rb'
 end
 
 # Generating regression test suite
-file 'spec/regression_spec.rb' => 'lib/pre-generate-spec.rb' do
+file 'spec/regression_spec.rb' => 'lib/pre/generate-spec.rb' do
   puts "making spec/regression_spec.rb"
-  sh 'ruby  lib/pre-generate-spec.rb'
+  sh 'ruby  lib/pre/generate-spec.rb'
 end
 
 # Generating documents
@@ -46,8 +46,8 @@ end
 task :make =>
         ['lib/regextest/front/parser.rb',
          'lib/regextest/front/bracket-parser.rb',
-         'lib/regextest/front/unicode.rb',
          'lib/regextest/front/case-folding.rb',
+         'lib/regextest/unicode.rb',
          'spec/regression_spec.rb',
          'doc/index.html',
         ] do 

data/lib/{pre-unicode.rb → pre/unicode.rb}

@@ -13,7 +13,7 @@ class RegextestPreUnicode
     # Get valid properties of Ruby
     onig_properties = read_onig_properties("./contrib/Onigmo/UnicodeProps.txt")
     ranges = get_ranges_of_properties(onig_properties)
-    puts_unicode_ranges('lib/regextest/front/unicode.rb', ranges)
+    puts_unicode_ranges('lib/regextest/unicode.rb', ranges)
   end
 
   # Get list of Unicode classes from Onigmo manual
@@ -85,13 +85,14 @@ class RegextestPreUnicode
       # DO NOT Modify This File Since Automatically Generated
 
       # Range of Unicode
-      class Regextest::Front::Unicode
+      class Regextest::Unicode
         # Generate hash of properties
         def self.property(class_name)
           case class_name.downcase
 #{ranges_source}
           else
-            raise "Internal error. Class name (#\{class_name\}) not found"
+            warn "Class name (#\{class_name\}) not found. Ignored."
+            []
           end
         end
         

data/lib/regextest.rb

@@ -46,11 +46,8 @@ class Regextest
     # Parse string
     @front_end = Regextest::Front.new(@reg_string, @@parse_options)
     
-    # To json (use json format for backend)
-    @json_obj = @front_end.get_json_obj
-    
     # Prepare back-end process. (use generate method for generating string)
-    @back_end = Regextest::Back.new(@json_obj)
+    @back_end = Regextest::Back.new(@front_end)
     
     @result = nil
     @reason = nil
@@ -75,11 +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
+    TstConstRetryMax.times do | retry_count |
     
       # generate string
       reset_random_called
-      @result = @back_end.generate
+      @result = @back_end.generate(retry_count)
       if !@result
         TstLog "NG: Failed to generate"
         @reason = :failed_to_generate
@@ -143,14 +140,14 @@ class Regextest
         @reg_string = new_param
         @reg_exp = /#{@reg_string}/
       end
-      @@parse_options[:reg_source] = @reg_string
     when Regexp
       @reg_exp = param
       @@parse_options[:reg_options].set(@reg_exp.options)   # inner regex options have priorty
-      @reg_string = @reg_exp.source
+      @reg_string = "#{@reg_exp}"    # this generates string with options
     else
       raise "Error: string or regular expression required"
     end
+    @@parse_options[:reg_source] = @reg_string
   end
 
   # add built-in functions if any
@@ -213,20 +210,22 @@ if __FILE__ == $0
   begin
     
     regex = ARGV[0] || $<
+    
     if(regex == "reg")
-      regex = /ab # comment
+      regex = /(?ix:ab # comment
       [a-z]{5,10}
-      cd	   /ix
+      cd	   )/
     end
+    
     if(regex == "reg2")
-      regex = %r(
+      regex = %r((?x:
       (?<name> [a-zA-Z_:]+ ){0}
       (?<stag> < \g<name>  > ){0}
-      (?<content> ||\w+|\w+|\w+ (\g<element> | \w+)* ){0}
+      (?<content> \w+ (\g<element> | \w+)* ){0}
       (?<etag> </ \k<name+1> >){0}
       (?<element> \g<stag> \g<content>* \g<etag> ){0}
       \g<element>
-      )x
+      ))x
     end
     
     begin

data/lib/regextest/back.rb

@@ -11,23 +11,25 @@ class Regextest::Back
   include Regextest::Common
   
   # Constructor
-  def initialize(json_obj)
-    @reg_source = @@parse_options[:reg_source]
-    @json_obj = json_obj
+  def initialize(front_end)
+    # To json (use json format for backend)
+    @parsed_object = front_end.get_object
+    @parse_result = @parsed_object["regex"]
+    @reg_source = @parsed_object["source"]
     
     # COMMENTED OUT at present
     # make a hash to manage names and corresponding objects
-    # @name_hash = make_name_hash(@json_obj, {})
+    # @name_hash = make_name_hash(@parse_result, {})
     # get test cases (commented at present)
-    # @test_info = Regextest::Back::TestCase.new(@json_obj, @name_hash)
+    # @test_info = Regextest::Back::TestCase.new(@parse_result, @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)
+  def generate(retry_count = 0)
+    generate_obj = Regextest::Back::Main.new(@parse_result, @max_nest, retry_count)
     generate_obj.generate
   end
   

data/lib/regextest/back/main.rb

@@ -9,9 +9,10 @@ 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)
+  def initialize(json_obj, max_nest, retry_count = 0)
     @json_obj = json_obj
     @max_nest = max_nest
+    @retry_count = retry_count
     @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
@@ -228,12 +229,19 @@ class Regextest::Back::Main
   # repeat
   def generate_candidates_repeat(param)
     target = param[:json]
+    max_repeat = target["max_repeat"]
+    min_repeat = target["min_repeat"]
+    
+    if @retry_count > 0
+      @retry_count.times{ max_repeat = (max_repeat + 1)/2 }
+    end
+ 
     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)
+      repeat = min_repeat
+    elsif(max_repeat > min_repeat)
+      repeat = min_repeat + TstRand(max_repeat - min_repeat + 1)
     else
-      repeat = target["min_repeat"]
+      repeat = min_repeat
     end
     result = []
     if target["repeat_option"].index("reluctant")
@@ -273,7 +281,13 @@ class Regextest::Back::Main
   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)
+      relative_num = -1   # default value
+      if target["relative_num"] != ""
+        work = @nest + target["relative_num"].to_i
+        return nil if(work < 0 || !@parens_hash[target["refer_name"]][:generated][work])
+        relative_num = work
+      end
+      # puts "relative: #{relative_num}, nest=#{@nest}, :#{target}"
       result = @parens_hash[target["refer_name"]][:generated][relative_num]
     else
       result = nil

data/lib/regextest/front.rb

@@ -16,6 +16,9 @@ class Regextest::Front
   def initialize(reg_string, options)
     @options = options
   
+    # Json option as a workaround for ruby 1.9.*
+    @json_option = { max_nesting: 999 }  
+    
     # scanning the string
     scanner = Regextest::Front::Scanner.new
     lex_words = scanner.scan(reg_string)
@@ -27,30 +30,31 @@ class Regextest::Front
     @parser = RegextestFrontParser.new
     
     # Do parse
-    @obj = @parser.parse(lex_words, @options)
+    @parse_result = @parser.parse(lex_words, @options)
     
     # process options
-    @obj.set_options(options)
+    @parse_result.set_options(options)
     
     # sort parentheses, since number of parenthesis is by offset-order (not by parsing-order)
     @options[:parens].sort
     
-    @obj    
+    @parse_result    
   end
 
   # Output JSON format parse result of the regex
-  def get_json_obj(result = @obj)
-    option = { max_nesting: 999}  # work around for ruby 1.9.*
-    json_obj = JSON.parse(result.json, option)
-    TstLog("JSON param:\n" + JSON.pretty_generate(json_obj, option))
-    json_obj
+  def get_object
+    json_obj = JSON.parse(@parse_result.json, @json_option)
+    parsed_object = {
+      "regex"  => json_obj,
+      "source" => @options[:reg_source]
+    }
+    TstLog("JSON param:\n" + JSON.pretty_generate(parsed_object, @json_option))
+    parsed_object
   end
 
   # Return JSON string
-  def get_json_string(result = @obj)
-    json_obj = get_json_obj(result)
-    option = { max_nesting: 999}  # work around for ruby 1.9.*
-    JSON.pretty_generate(json_obj, option)
+  def get_json_string
+    JSON.pretty_generate(get_object, @json_option)
   end
 
 end

data/lib/regextest/front/back-refer.rb

@@ -45,7 +45,7 @@ module Regextest::Front::BackRefer
             raise "internal error: unexpected refer #{value}"
           end
           if md[5]
-            @relative_num = md[3].to_i
+            @relative_num = md[5].to_i
           end
         else
           raise "Error: Internal error, invalid named reference"

data/lib/regextest/front/bracket-scanner.rb

@@ -40,8 +40,8 @@ class Regextest::Front::BracketScanner
       /-(?!\]|\z)/ ],       # a letter must succeeds to minus
     [:LEX_AND_AND,
       %r!\&\&! ],
-    [:LEX_SPECIAL_LETTER,
-      %r!\\[RX]! ],
+    # [:LEX_SPECIAL_LETTER,  # special letters are not valid in bracket
+    #   %r!\\[RX]! ],
     [:LEX_ESCAPED_LETTER,
       %r!\\.! ],    # \b is valid within character class
     [:LEX_SPACE,

data/lib/regextest/front/char-class.rb

@@ -6,7 +6,7 @@ require 'regextest/common'
 require 'regextest/front/range'          # Range of character
 require 'regextest/front/case-folding'   # case folding class
 require 'regextest/regex-option'         # Options of regex
-require 'regextest/front/unicode'
+require 'regextest/unicode'
 
 # character class elements
 module Regextest::Front::CharClass
@@ -40,7 +40,7 @@ module Regextest::Front::CharClass
         class_names = value
         @candidates = []
         class_names.split("|").each do | class_name |
-          work = Regextest::Front::Unicode.property(class_name) ||
+          work = Regextest::Unicode.property(class_name) ||
             raise("Invalid Unicode class #{class_name}")
           # construct char class
           @candidates += work.map{|elem| TRange.new(elem[0], elem[1])}
@@ -153,19 +153,16 @@ module Regextest::Front::CharClass
     
     # Get whole code set of ascii
     def get_ascii_whole_set
-      # require 'regextest/front/unicode'
-      # same as  [ TRange.new("\x20", "\x7e") ]
-      ascii_set = Regextest::Front::Unicode.enumerate("ascii")
-      print_set = Regextest::Front::Unicode.enumerate("print")
+      ascii_set = Regextest::Unicode.enumerate("ascii")
+      print_set = Regextest::Unicode.enumerate("print")
       ascii_set & print_set
     end
     
     # Get whole code set of unicode
     def get_unicode_whole_set
-      # require 'regextest/front/unicode'
       char_set = []
       TstConstUnicodeCharSet.split("|").each do | elem |
-        char_set |= Regextest::Front::Unicode.enumerate(elem)
+        char_set |= Regextest::Unicode.enumerate(elem)
       end
       char_set
     end

data/lib/regextest/front/letter.rb

@@ -6,7 +6,6 @@ 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
@@ -179,37 +178,23 @@ module Regextest::Front::Letter
     
     # 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
+        obj = CharClass.new(class_name)
       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]
+        obj
       else      # \P{}  or \p{^}
-        @@unicode_ranges[class_name].set_reverse(@options)
+        obj.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+)\:\]$/))

data/lib/regextest/{front/unicode.rb → unicode.rb}

@@ -2,7 +2,7 @@
 # DO NOT Modify This File Since Automatically Generated
 
 # Range of Unicode
-class Regextest::Front::Unicode
+class Regextest::Unicode
   # Generate hash of properties
   def self.property(class_name)
     case class_name.downcase
@@ -1257,7 +1257,8 @@ class Regextest::Front::Unicode
         when "in_no_block"
           ([[2144, 2207], [6832, 6911], [7296, 7359], [12256, 12271], [43488, 43519], [43824, 43967], [66048, 66175], [66272, 66303], [66384, 66431], [66528, 66559], [66736, 67583], [67680, 67839], [67904, 67967], [68224, 68351], [68480, 68607], [68688, 69215], [69248, 69631], [69968, 70015], [70112, 71295], [71376, 73727], [74880, 77823], [78896, 92159], [92736, 93951], [94112, 110591], [110848, 118783], [119376, 119551], [119680, 119807], [120832, 126463], [126720, 126975], [128592, 128639], [128896, 131071], [173792, 173823], [178208, 194559], [195104, 917503], [917632, 917759], [918000, 983039]])
     else
-      raise "Internal error. Class name (#{class_name}) not found"
+      warn "Class name (#{class_name}) not found. Ignored."
+      []
     end
   end
   

data/lib/regextest/version.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2016 Mikio Ikoma
 
 class Regextest
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: regextest
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - IKOMA, Mikio
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-31 00:00:00.000000000 Z
+date: 2016-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby
@@ -128,10 +128,10 @@ files:
 - contrib/unicode/README.txt
 - contrib/unicode/Scripts.txt
 - contrib/unicode/UnicodeData.txt
-- lib/pre-case-folding.rb
-- lib/pre-generate-spec.rb
-- lib/pre-posix-char-class.rb
-- lib/pre-unicode.rb
+- lib/pre/case-folding.rb
+- lib/pre/generate-spec.rb
+- lib/pre/posix-char-class.rb
+- lib/pre/unicode.rb
 - lib/regextest.rb
 - lib/regextest/back.rb
 - lib/regextest/back/element.rb
@@ -162,9 +162,9 @@ files:
 - lib/regextest/front/scanner.rb
 - lib/regextest/front/selectable.rb
 - lib/regextest/front/sequence.rb
-- lib/regextest/front/unicode.rb
 - lib/regextest/regex-option.rb
 - lib/regextest/regexp.rb
+- lib/regextest/unicode.rb
 - lib/regextest/version.rb
 - lib/tst-reg-test.rb
 - regextest.gemspec