regextest 0.1.2

data/lib/regextest/regex-option.rb

@@ -0,0 +1,144 @@
+# encoding: utf-8
+
+# Copyright (C) 2016 Mikio Ikoma
+
+# A class that manages options of regular expression
+class Regextest::RegexOption
+  # Constants for the class
+  TstRegOptDefault  =  1
+  TstRegOptAscii    =  2
+  TstRegOptUnicode  =  3
+
+  attr_accessor :reg_options, :char_set
+  
+  def initialize(options = nil)
+    self.set(options)
+    @char_set = TstRegOptDefault
+  end
+  
+  # a method for copy (maybe unnecessary)
+  def initialize_copy(source_obj)
+    @reg_options = source_obj.reg_options
+    @char_set = source_obj.char_set
+  end
+    
+  # set one or more options
+  def set(options)
+    @reg_options = 0
+    modify(options)
+  end
+    
+  # modify one or more options
+  def modify(options)
+    case options
+    when String
+      modify_string(options)
+    when Integer
+      modify_integer(options)
+    end
+  end
+    
+  # modify regoption by string (like 'x-im')
+  def modify_string(opt_string)
+    opts = opt_string.split("-")
+    raise "Option string (#{opt_string}) is invalid." if(opts.size > 2)
+    
+    # set option bits
+    if(opts[0])
+      opts[0].split(//).each do | opt |
+        case opt
+        when 'i'
+          @reg_options |= Regexp::IGNORECASE
+        when 'x'
+          @reg_options |= Regexp::EXTENDED
+        when 'm'
+          @reg_options |= Regexp::MULTILINE
+        when 'd'
+          @char_set = TstRegOptDefault
+        when 'u'
+          @char_set = TstRegOptUnicode
+        when 'a'
+          @char_set = TstRegOptAscii
+        else
+          raise "Invalid char (#{opt}) found in regexp option"
+        end
+      end
+    end
+    
+    # reset option bits
+    if(opts[1])
+      opts[1].split(//).each do | opt |
+        case opt
+        when 'i'
+          @reg_options &= ~Regexp::IGNORECASE
+        when 'x'
+          @reg_options &= ~Regexp::EXTENDED
+        when 'm'
+          @reg_options &= ~Regexp::MULTILINE
+        else
+          raise "Invalid char (#{opt}) found in regexp option"
+        end
+      end
+    end
+    @reg_options
+  end
+
+  # modify options by integer
+  def modify_integer(options)
+    @reg_options |= options
+  end
+      
+
+  # methods for checking each flag
+  def is_ignore?
+    (@reg_options & Regexp::IGNORECASE != 0)
+  end
+  
+  def is_extended?
+    (@reg_options & Regexp::EXTENDED != 0)
+  end
+  
+  def is_multiline?
+    (@reg_options & Regexp::MULTILINE != 0)
+  end
+  
+  def is_default_char_set?
+    (@char_set == TstRegOptDefault)
+  end
+  
+  def is_ascii?
+    (@char_set == TstRegOptAscii)
+  end
+  
+  def is_unicode?
+    (@char_set == TstRegOptUnicode)
+  end
+end
+
+
+  # Test suite (execute when this file is specified in command line)
+  if __FILE__ == $0 
+    puts "test #{__FILE__}"
+    
+    opts = Regextest::RegexOption.new("ixm")
+    puts "OK igonore" if(opts.is_ignore?)
+    puts "OK extended" if(opts.is_extended?)
+    puts "OK multiline" if(opts.is_multiline?)
+    
+    opts2 = opts.dup
+    puts "OK dup igonore" if(opts2.is_ignore?)
+    puts "OK dup extended" if(opts2.is_extended?)
+    puts "OK dup multiline" if(opts2.is_multiline?)
+    
+    opts.modify("-ixm")
+    puts "OK mod igonore" if(!opts.is_ignore?)
+    puts "OK mod extended" if(!opts.is_extended?)
+    puts "OK mod multiline" if(!opts.is_multiline?)
+    
+    # verify opt2 is independent of opt
+    puts "OK mod igonore" if(opts2.is_ignore?)
+    puts "OK mod extended" if(opts2.is_extended?)
+    puts "OK mod multiline" if(opts2.is_multiline?)
+    
+  end
+

data/lib/regextest/regexp.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+# Copyright (C) 2016 Mikio Ikoma
+
+# Add-on methods (samples, sample, match_data) for Regexp class
+# @raise [Regextest::RegextestError] if impossible to generate.
+# @raise [Regextest::RegextestFailedToGenerate] if failed to generate. Mainly caused by Regextest's restrictions.
+# @raise [Regextest::RegextestTimeout] if detected timeout while verification. Option 'verification: false' may be workaround.
+# @raise [RuntimeError] if something wrong... mainly caused by Regextest's bug
+class Regexp
+
+  # generate a sample string of regexp
+  # @param [Hash] option option parameters for sampling
+  # @option option [Fixnum] :seed seed for randomization
+  # @option option [TrueClass] :verification specify true (or not speficy) if verified using ruby Regexp.
+  # @option option [FalseClass] :verification specify false if skip to verify using ruby Regexp.
+  # @return [String] if able to generate matched string
+  def sample(option = {})
+    if option[:verification] != false
+      match_data(option).string
+    else
+      match_data(option)
+    end
+  end
+  
+  # generate match-data object(s) of regexp
+  # @param [Hash] option option parameters for sampling
+  # @option option [Fixnum] :seed seed for randomization
+  # @option option [TrueClass] :verification specify true (or not speficy) if verified using ruby Regexp.
+  # @option option [FalseClass] :verification specify false if skip to verify using ruby Regexp.
+  # @return [MatchData] if able to generate matched data
+  def match_data(option = {})
+    regextest = Regextest.new(self, option)
+    result = regextest.generate
+  end
+  
+  # parse regexp and return json data
+  # @return [String] return parsed json string
+  def to_json
+    regextest = Regextest.new(self, {})
+    regextest.to_json
+  end
+  
+end

data/lib/regextest/version.rb

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

data/lib/tst-reg-test.rb

@@ -0,0 +1,159 @@
+# encoding: utf-8
+
+# Copyright (C) 2016 Mikio Ikoma
+
+require 'regextest'
+require 'kconv'
+require 'timeout'
+require 'pp'
+
+class Regextest::Test
+  def initialize(min_test, max_test)
+    results = {
+      success: [],
+      bug: [],
+      failed: [],
+      impossible: [],
+      others: [],
+      not_scope: [],
+      timeout: [],
+      perl_syntax: [],
+    }
+    time_out = 1
+    do_test(results, min_test, max_test, time_out)
+    print_results(results)
+  end
+  
+  def print_results(results)
+    puts ""
+    (results[:failed] + results[:bug]).each do | failed_hash |
+      regex = failed_hash[:test] || failed_hash[:result][:reg]
+      puts "======="
+      puts "  type: #{failed_hash[:type] || failed_hash[:result][:result]}"
+      puts "  test: #{regex}"
+      puts "  info: #{failed_hash[:info] || failed_hash[:result][:reason]}"
+      puts "  indx: #{failed_hash[:index]}"
+      pp failed_hash
+    end
+
+    puts "======"
+    puts "success:    #{results[:success].size}"
+    puts "bug:        #{results[:bug].size}"
+    puts "failed:     #{results[:failed].size}"
+    puts "impossible: #{results[:impossible].size}"
+    puts "others:     #{results[:others].size}"
+    puts "timeout:    #{results[:timeout].size}"
+    puts "regexp error: #{results[:not_scope].size}"
+    puts "perl_syntax:  #{results[:perl_syntax].size}"
+  end
+  
+  def do_test(results, min_test, max_test, timeout_seconds)
+    get_lines(results).each_with_index do | line, i |
+      next if(i < min_test || i > max_test)
+      puts line
+      begin
+        rc = nil
+        timeout(timeout_seconds){
+          rc = eval(line)
+        }
+        if(rc[:result] == :ok)
+          results[:success].push({ md: rc[:md], reg: rc[:reg], index: i})
+        else
+          results[:failed].push({ result: rc, index: i })
+        end
+      rescue Timeout::Error => ex
+        warn "Timeout::Error #{ex}. \nline:#{line}"
+        results[:timeout].push({result: :timeout, message: ex, reg: line, index: i})
+      rescue RegexpError => ex
+        warn "RegexpError #{ex}. \nline:#{line}"
+        results[:not_scope].push({result: :regexp_error, message: ex, reg: line, index: i})
+      rescue ArgumentError => ex
+        warn "ArgumentError #{ex}. \nline: line"
+        results[:failed].push({type: :argument_error, info: ex, test: line, index: i})
+      #rescue Regextest::Common::RegextestTimeout => ex
+      #  warn "RegextestTimeout #{ex}. \nline:#{line}"
+      #  results[:failed].push({ type: :timeout, test: line, info: ex, index: i})
+      rescue Regextest::RegextestError => ex
+        warn "RegextestError #{ex}. \nline:#{line}"
+        results[:impossible].push({ type: Regextest::RegextestError, test: line, info: ex, index: i})
+      rescue Regextest::RegextestFailedToGenerate => ex
+        warn "RegextestFailedToGenerate #{ex}. \nline:#{line}"
+        results[:failed].push({ type: Regextest::RegextestFailedToGenerate, test: line, info: ex, index: i})
+      rescue RuntimeError => ex
+        warn "RuntimeError #{ex}. \nline:#{line}"
+        results[:bug].push({ type: RuntimeError, test: line, info: ex, index: i})
+      rescue SyntaxError => ex
+        warn "SyntaxError #{ex}. \nline:#{line}"
+        results[:failed].push({ type: SyntaxError, test: line, info: ex, index: i})
+      rescue NameError => ex
+        warn "NameError #{ex}. \nline:#{line}"
+        results[:failed].push({ type: NameError, test: line, info: ex, index: i})
+      rescue TypeError => ex
+        warn "TypeError #{ex}. \nline:#{line}"
+        results[:failed].push({ type: TypeError, test: line, info: ex, index: i})
+      rescue Encoding::CompatibilityError => ex
+        warn "Encoding::CompatibilityError #{ex}. \nline:#{line}"
+        results[:failed].push({ type: Encoding::CompatibilityError, test: line, info: ex, index: i})
+      end
+    end
+  end
+
+  def get_lines(results)
+    lines = []
+    # py_source = IO.read("../contrib/Onigmo/testpy.py")
+    File::open("../contrib/Onigmo/testpy.py") do |f|
+      f.each do |line|
+        line.force_encoding("utf-8")
+        if !line.match(/ONIG_SYNTAX_PERL/)
+          if(md = line.match(/^\s*(?:x|x2|n)\s*\(.+?$/u) rescue nil)
+            line.sub!(/,\s*\".+?$/, ")") rescue nil
+            lines.push line if line
+          end
+        else
+          warn "Perl syntax. \nline:#{line}"
+          results[:perl_syntax].push({ type: :perl_syntax, test: line, info: nil})
+        end
+      end
+    end
+    lines
+  end
+
+  def check_normal_test(reg)
+    result = nil
+    a_test = /#{reg}/
+    # puts a_test.source
+    obj = Regextest.new(a_test)
+    10.times do | i |
+      md = obj.generate
+      if(md)
+        # print "OK md:#{md},"
+        result = {result: :ok, md: md, reg: a_test}
+      else
+        warn "Failed. reg='#{a_test}', reason=#{obj.reason}"
+        result = {result: :unmatched, reg: a_test, reason: obj.reason}
+        break
+      end
+    end
+    result
+  end
+
+  def x(reg, *params)
+    check_normal_test(reg)
+  end
+
+  def x2(reg, *params)
+    check_normal_test(reg)
+  end
+
+  def n(reg, *params)
+    check_normal_test(reg)
+  end
+
+end
+
+# Test suite (execute when this file is specified in command line)
+if __FILE__ == $0
+  min_test = ARGV[1]?(ARGV[0].to_i):0
+  max_test = ARGV[1]?(ARGV[1].to_i):(ARGV[0]?(ARGV[0].to_i):99999999)
+  Regextest::Test.new(min_test, max_test)
+end

data/regextest.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'regextest/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "regextest"
+  spec.version       = Regextest::VERSION
+  spec.authors       = ["IKOMA, Mikio"]
+  spec.email         = ["mikio.ikoma@gmail.com"]
+
+  spec.summary       = %q{A ruby library for generating sample data of regular expression}
+  spec.description   = %q{This library generates data matched with specified regular expression.}
+  spec.homepage      = "https://bitbucket.org/ikomamik/regextest"
+  spec.license       = "2-clause BSD license (see the file LICENSE.txt)"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.8"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "yard", "~> 0.9.5"
+  spec.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: regextest
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- IKOMA, Mikio
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-08-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This library generates data matched with specified regular expression.
+email:
+- mikio.ikoma@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/regextest
+- bin/setup
+- contrib/Onigmo/RE.txt
+- contrib/Onigmo/UnicodeProps.txt
+- contrib/Onigmo/testpy.py
+- contrib/unicode/Blocks.txt
+- contrib/unicode/CaseFolding.txt
+- contrib/unicode/DerivedAge.txt
+- contrib/unicode/DerivedCoreProperties.txt
+- contrib/unicode/PropList.txt
+- contrib/unicode/PropertyAliases.txt
+- contrib/unicode/PropertyValueAliases.txt
+- contrib/unicode/README.txt
+- contrib/unicode/Scripts.txt
+- contrib/unicode/UnicodeData.txt
+- lib/pre-case-folding.rb
+- lib/pre-posix-char-class.rb
+- lib/pre-unicode.rb
+- lib/regextest.rb
+- lib/regextest/back.rb
+- lib/regextest/back/element.rb
+- lib/regextest/back/main.rb
+- lib/regextest/back/result.rb
+- lib/regextest/back/test-case.rb
+- lib/regextest/back/work-thread.rb
+- lib/regextest/common.rb
+- lib/regextest/front.rb
+- lib/regextest/front/anchor.rb
+- lib/regextest/front/back-refer.rb
+- lib/regextest/front/bracket-parser.rb
+- lib/regextest/front/bracket-parser.y
+- lib/regextest/front/bracket-scanner.rb
+- lib/regextest/front/bracket.rb
+- lib/regextest/front/builtin-functions.rb
+- lib/regextest/front/case-folding.rb
+- lib/regextest/front/char-class.rb
+- lib/regextest/front/empty.rb
+- lib/regextest/front/letter.rb
+- lib/regextest/front/manage-parentheses.rb
+- lib/regextest/front/parenthesis.rb
+- lib/regextest/front/parser.rb
+- lib/regextest/front/parser.y
+- lib/regextest/front/range.rb
+- lib/regextest/front/repeat.rb
+- lib/regextest/front/repeatable.rb
+- 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/version.rb
+- lib/tst-reg-test.rb
+- regextest.gemspec
+homepage: https://bitbucket.org/ikomamik/regextest
+licenses:
+- 2-clause BSD license (see the file LICENSE.txt)
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: A ruby library for generating sample data of regular expression
+test_files: []