regexp_parser 0.1.1 → 0.1.5

data/test/scanner/test_anchors.rb

@@ -3,8 +3,8 @@ require File.expand_path("../../helpers", __FILE__)
 class ScannerAnchors < Test::Unit::TestCase
 
   tests = {
-   '^abc'       => [0, :anchor,     :beginning_of_line,     '^',    0, 1],
-   'abc$'       => [1, :anchor,     :end_of_line,           '$',    3, 4],
+   '^abc'       => [0, :anchor,     :bol,                   '^',    0, 1],
+   'abc$'       => [1, :anchor,     :eol,                   '$',    3, 4],
 
    '\Aabc'      => [0, :anchor,     :bos,                   '\A',   0, 2],
    'abc\z'      => [1, :anchor,     :eos,                   '\z',   3, 5],

data/test/scanner/test_conditionals.rb

@@ -0,0 +1,31 @@
+require File.expand_path("../../helpers", __FILE__)
+
+class ScannerConditionals < Test::Unit::TestCase
+
+  tests = {
+    /(?(1)Y|N)/         => [0, :conditional,  :open,        '(?(',  0,  3],
+    /(?(2)Y|N)/         => [1, :conditional,  :condition,   '2',    3,  4],
+    /(?(3)Y|N)/         => [2, :conditional,  :yes,         'Y',    5,  6],
+
+    #"(?(<name>)Y|N)"    => [0, :conditional,  :condition, '(?(<name>)Y|N)',  0, 14],
+    #"(?('name')Y|N)"    => [0, :conditional,  :yes,       "(?('name')Y|N)",  0, 14],
+  }
+
+  count = 0
+  tests.each do |pattern, test|
+    define_method "test_scan_#{test[1]}_#{test[2]}_#{count+=1}" do
+
+      tokens = RS.scan(pattern)
+      token = tokens[test[0]]
+      assert_equal( test[1,5], token )
+
+    end
+  end
+
+ #def test_scanner_quote
+ #  tokens = RS.scan('a\QX\Eb\QX\Ec')
+ #  puts tokens.inspect
+ #  #assert_equal( tokens[0] )
+ #end
+
+end

data/test/scanner/test_errors.rb

@@ -3,34 +3,114 @@ require File.expand_path("../../helpers", __FILE__)
 class ScannerErrors < Test::Unit::TestCase
 
   def test_scanner_unbalanced_set
-    assert_raise( Regexp::Scanner::PrematureEndError ) { RS.scan('[[:alpha:]') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('[[:alpha:]') }
   end
 
   def test_scanner_unbalanced_group
-    assert_raise( Regexp::Scanner::PrematureEndError ) { RS.scan('(abc') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('(abc') }
   end
 
   def test_scanner_unbalanced_interval
-    assert_raise( Regexp::Scanner::PrematureEndError ) { RS.scan('a{1,2') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('a{1,2') }
+  end
+
+  def test_scanner_eof_in_property
+    assert_raise( RS::PrematureEndError ) { RS.scan('\p{asci') }
   end
 
   def test_scanner_incomplete_property
-    assert_raise( Regexp::Scanner::PrematureEndError ) { RS.scan('\p{ascii abc') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\p{ascii abc') }
   end
 
   def test_scanner_unknown_property
-    assert_raise( Regexp::Scanner::UnknownUnicodePropertyError ) { RS.scan('\p{foobar}') }
+    assert_raise( RS::UnknownUnicodePropertyError ) { RS.scan('\p{foobar}') }
   end
 
   def test_scanner_incomplete_options
-    assert_raise( Regexp::Scanner::ScannerError ) { RS.scan('(?mix abc)') }
+    assert_raise( RS::ScannerError ) { RS.scan('(?mix abc)') }
   end
 
   def test_scanner_eof_options
-    assert_raise( Regexp::Scanner::PrematureEndError ) { RS.scan('(?mix') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('(?mix') }
   end
 
   def test_scanner_incorrect_options
-    assert_raise( Regexp::Scanner::ScannerError ) { RS.scan('(?mix^bc') }
+    assert_raise( RS::ScannerError ) { RS.scan('(?mix^bc') }
+  end
+
+  def test_scanner_eof_escape
+    assert_raise( RS::PrematureEndError ) { RS.scan('\\') }
+  end
+
+  def test_scanner_eof_in_hex_escape
+    assert_raise( RS::PrematureEndError ) { RS.scan('\x') }
+  end
+
+  def test_scanner_eof_in_wide_hex_escape
+    assert_raise( RS::PrematureEndError ) { RS.scan('\x{') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\x{0') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\x{02') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\x{024') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\x{0246') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\x{02468') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\x{02468A') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\x{02468AC') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\x{02468ACE') }
+  end
+
+  def test_scanner_eof_in_codepoint_escape
+    assert_raise( RS::PrematureEndError ) { RS.scan('\u') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\u0') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\u00') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\u000') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\u{') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\u{00') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\u{0000') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\u{0000 ') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\u{0000 0000') }
+  end
+
+  def test_scanner_eof_in_control_sequence
+    assert_raise( RS::PrematureEndError ) { RS.scan('\c') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\C') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\C-') }
+  end
+
+  def test_scanner_eof_in_meta_sequence
+    assert_raise( RS::PrematureEndError ) { RS.scan('\M') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\M-') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\M-\\') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\M-\C') }
+    assert_raise( RS::PrematureEndError ) { RS.scan('\M-\C-') }
+  end
+
+  def test_scanner_invalid_hex_escape
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\xZ') }
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\xZ0') }
+  end
+
+  def test_scanner_invalid_wide_hex_escape
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\x{}') }
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\x{ }') }
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\x{ A }') }
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\x{0-}') }
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\x{Z00}') }
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\x{000Z}') }
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\x{00ZZ}') }
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\x{0000ZZ}') }
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\x{0000ZZ0}') }
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\x{0000ZZ0X}') }
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\x{00X') }
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\x{00XYZ') }
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\x{0000XYZ') }
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\x{02468ACED') }
+    assert_raise( RS::InvalidSequenceError ) { RS.scan('\x{02468ACE]') }
+  end
+
+  def test_scanner_invalid_named_group
+    assert_raise( RS::InvalidGroupError ) { RS.scan("(?'')") }
+    assert_raise( RS::InvalidGroupError ) { RS.scan("(?''empty-name)") }
+    assert_raise( RS::InvalidGroupError ) { RS.scan("(?<>)") }
+    assert_raise( RS::InvalidGroupError ) { RS.scan("(?<>empty-name)") }
   end
 end

data/test/scanner/test_escapes.rb

@@ -27,12 +27,12 @@ class ScannerEscapes < Test::Unit::TestCase
     'a\u0640c'        => [1, :escape,  :codepoint,        '\u0640',         1,  7],
     'a\u{0640 0641}c' => [1, :escape,  :codepoint_list,   '\u{0640 0641}',  1,  14],
 
-    'a\cCc'           => [1, :escape,  :control,          '\cC',            1,  4],
-    'a\C-cc'          => [1, :escape,  :control,          '\C-c',           1,  5],
+    'a\cBc'           => [1, :escape,  :control,          '\cB',            1,  4],
+    'a\C-bc'          => [1, :escape,  :control,          '\C-b',           1,  5],
 
     # TODO: verify these escapes
-    'a\M-Cc'          => [1, :escape,  :meta_sequence,    '\M-C',           1,  5],
-    'a\M-\C-cc'       => [1, :escape,  :meta_sequence,    '\M-\C-c',        1,  8],
+    'a\M-Bc'          => [1, :escape,  :meta_sequence,    '\M-B',           1,  5],
+    'a\M-\C-Bc'       => [1, :escape,  :meta_sequence,    '\M-\C-B',        1,  8],
   }
 
   count = 0

data/test/scanner/test_groups.rb

@@ -9,13 +9,20 @@ class ScannerGroups < Test::Unit::TestCase
     '(?mi-x:abc)'     => [0, :group,     :options,      '(?mi-x:',    0, 7],
     '(?mix:abc)'      => [0, :group,     :options,      '(?mix:',     0, 6],
     '(?mix)'          => [0, :group,     :options,      '(?mix',      0, 5],
+    '(?m:)'           => [0, :group,     :options,      '(?m:',       0, 4],
+    '(?i:)'           => [0, :group,     :options,      '(?i:',       0, 4],
+    '(?x:)'           => [0, :group,     :options,      '(?x:',       0, 4],
 
     # Group types
     '(?>abc)'         => [0, :group,     :atomic,       '(?>',        0, 3],
     '(abc)'           => [0, :group,     :capture,      '(',          0, 1],
+
     '(?<name>abc)'    => [0, :group,     :named_ab,     '(?<name>',   0, 8],
     "(?'name'abc)"    => [0, :group,     :named_sq,     "(?'name'",   0, 8],
+
     '(?:abc)'         => [0, :group,     :passive,      '(?:',        0, 3],
+    '(?:)'            => [0, :group,     :passive,      '(?:',        0, 3],
+    '(?::)'           => [0, :group,     :passive,      '(?:',        0, 3],
 
     # Comments
     '(?#abc)'         => [0, :group,     :comment,      '(?#abc)',    0, 7],

data/test/scanner/test_quoting.rb

@@ -0,0 +1,29 @@
+require File.expand_path("../../helpers", __FILE__)
+
+class ScannerQuoting < Test::Unit::TestCase
+
+  tests = {
+    /\Qquoted\Ea/               => [0, :quoted,   :literal,  '\Qquoted\E',     0,  10],
+    /\Qquoted\Eb/               => [1, :literal,  :literal,  'b',             10,  11],
+    /a\Qquoted\Eb\Qquoted\Ec/   => [3, :quoted,   :literal,  '\Qquoted\E',    12,  22],
+    /a\Qqu\o\t\ed\Eb/           => [1, :quoted,   :literal,  '\Qqu\o\t\ed\E',  1,  14],
+  }
+
+  count = 0
+  tests.each do |pattern, test|
+    define_method "test_scan_#{test[1]}_#{test[2]}_#{count+=1}" do
+
+      tokens = RS.scan(pattern)
+      token = tokens[test[0]]
+      assert_equal( test[1,5], token )
+
+    end
+  end
+
+ #def test_scanner_quote
+ #  tokens = RS.scan('a\QX\Eb\QX\Ec')
+ #  puts tokens.inspect
+ #  #assert_equal( tokens[0] )
+ #end
+
+end

data/test/scanner/test_sets.rb

@@ -9,6 +9,7 @@ class ScannerSets < Test::Unit::TestCase
 
     '[c]'                   => [1, :set,    :member,          'c',          1, 2],
     '[\b]'                  => [1, :set,    :backspace,       '\b',         1, 3],
+    '[A\bX]'                => [2, :set,    :backspace,       '\b',         2, 4],
 
     '[.]'                   => [1, :set,    :member,          '.',          1, 2],
     '[?]'                   => [1, :set,    :member,          '?',          1, 2],

data/test/syntax/ruby/test_1.8.rb

@@ -9,7 +9,7 @@ class TestSyntaxRuby_V18 < Test::Unit::TestCase
 
   tests = {
     :implements => {
-      :assertion    => [Group::Assertion::Lookahead].flatten,
+      :assertion    => [Assertion::Lookahead].flatten,
       :backref      => [:number],
       :escape       => [Escape::All].flatten,
       :group        => [Group::All].flatten,
@@ -20,10 +20,10 @@ class TestSyntaxRuby_V18 < Test::Unit::TestCase
     },
 
     :excludes => {
-      :assertion    => [Group::Assertion::Lookbehind].flatten,
+      :assertion    => [Assertion::Lookbehind].flatten,
 
       :backref => [
-        Group::Backreference::All + Group::SubexpressionCall::All
+        Backreference::All + SubexpressionCall::All
       ].flatten,
 
       :quantifier => [

data/test/test_all.rb

@@ -1,4 +1,4 @@
 require File.expand_path("../helpers", __FILE__)
-%w{ scanner syntax lexer parser }.each do |subject|
+%w{ scanner syntax lexer parser expression }.each do |subject|
   require File.expand_path("../#{subject}/test_all", __FILE__)
 end

metadata

@@ -1,38 +1,37 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: regexp_parser
-version: !ruby/object:Gem::Version 
-  hash: 25
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 1
-  version: 0.1.1
+version: !ruby/object:Gem::Version
+  version: 0.1.5
 platform: ruby
-authors: 
+authors:
 - Ammar Ali
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-11-23 00:00:00 +02:00
-default_executable: 
+date: 2014-01-14 00:00:00.000000000 Z
 dependencies: []
-
 description: A library for tokenizing, lexing, and parsing Ruby regular expressions.
 email: ammarabuali@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - ChangeLog
 - LICENSE
 - README.rdoc
-files: 
+files:
 - lib/regexp_parser/ctype.rb
-- lib/regexp_parser/expression/property.rb
-- lib/regexp_parser/expression/set.rb
+- lib/regexp_parser/expression/classes/alternation.rb
+- lib/regexp_parser/expression/classes/anchor.rb
+- lib/regexp_parser/expression/classes/backref.rb
+- lib/regexp_parser/expression/classes/escape.rb
+- lib/regexp_parser/expression/classes/group.rb
+- lib/regexp_parser/expression/classes/literal.rb
+- lib/regexp_parser/expression/classes/property.rb
+- lib/regexp_parser/expression/classes/root.rb
+- lib/regexp_parser/expression/classes/set.rb
+- lib/regexp_parser/expression/classes/type.rb
+- lib/regexp_parser/expression/quantifier.rb
+- lib/regexp_parser/expression/subexpression.rb
 - lib/regexp_parser/expression.rb
 - lib/regexp_parser/lexer.rb
 - lib/regexp_parser/parser.rb
@@ -44,9 +43,26 @@ files:
 - lib/regexp_parser/syntax/ruby/1.9.2.rb
 - lib/regexp_parser/syntax/ruby/1.9.3.rb
 - lib/regexp_parser/syntax/ruby/1.9.rb
+- lib/regexp_parser/syntax/ruby/2.0.0.rb
+- lib/regexp_parser/syntax/ruby/2.1.0.rb
+- lib/regexp_parser/syntax/tokens/anchor.rb
+- lib/regexp_parser/syntax/tokens/assertion.rb
+- lib/regexp_parser/syntax/tokens/backref.rb
+- lib/regexp_parser/syntax/tokens/character_set.rb
+- lib/regexp_parser/syntax/tokens/character_type.rb
+- lib/regexp_parser/syntax/tokens/escape.rb
+- lib/regexp_parser/syntax/tokens/group.rb
+- lib/regexp_parser/syntax/tokens/meta.rb
+- lib/regexp_parser/syntax/tokens/quantifier.rb
+- lib/regexp_parser/syntax/tokens/unicode_property.rb
 - lib/regexp_parser/syntax/tokens.rb
 - lib/regexp_parser/syntax.rb
+- lib/regexp_parser/token.rb
 - lib/regexp_parser.rb
+- test/expression/test_all.rb
+- test/expression/test_base.rb
+- test/expression/test_clone.rb
+- test/expression/test_to_s.rb
 - test/helpers.rb
 - test/lexer/test_all.rb
 - test/lexer/test_literals.rb
@@ -57,7 +73,6 @@ files:
 - test/parser/test_anchors.rb
 - test/parser/test_errors.rb
 - test/parser/test_escapes.rb
-- test/parser/test_expression.rb
 - test/parser/test_groups.rb
 - test/parser/test_properties.rb
 - test/parser/test_quantifiers.rb
@@ -65,6 +80,7 @@ files:
 - test/parser/test_sets.rb
 - test/scanner/test_all.rb
 - test/scanner/test_anchors.rb
+- test/scanner/test_conditionals.rb
 - test/scanner/test_errors.rb
 - test/scanner/test_escapes.rb
 - test/scanner/test_groups.rb
@@ -72,6 +88,7 @@ files:
 - test/scanner/test_meta.rb
 - test/scanner/test_properties.rb
 - test/scanner/test_quantifiers.rb
+- test/scanner/test_quoting.rb
 - test/scanner/test_refcalls.rb
 - test/scanner/test_scripts.rb
 - test/scanner/test_sets.rb
@@ -84,46 +101,42 @@ files:
 - test/test_all.rb
 - lib/regexp_parser/scanner/property.rl
 - lib/regexp_parser/scanner/scanner.rl
+- VERSION.yml
 - Rakefile
 - LICENSE
 - README.rdoc
 - ChangeLog
-has_rdoc: true
 homepage: http://github.com/ammar/regexp_parser
-licenses: 
+licenses:
 - MIT
+metadata: {}
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --inline-source
 - --charset=UTF-8
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+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: 1.3.7
+rubygems_version: 2.0.6
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Scanner, lexer, parser for ruby's regular expressions
-test_files: 
+test_files:
+- test/expression/test_all.rb
+- test/expression/test_base.rb
+- test/expression/test_clone.rb
+- test/expression/test_to_s.rb
 - test/helpers.rb
 - test/lexer/test_all.rb
 - test/lexer/test_literals.rb
@@ -134,7 +147,6 @@ test_files:
 - test/parser/test_anchors.rb
 - test/parser/test_errors.rb
 - test/parser/test_escapes.rb
-- test/parser/test_expression.rb
 - test/parser/test_groups.rb
 - test/parser/test_properties.rb
 - test/parser/test_quantifiers.rb
@@ -142,6 +154,7 @@ test_files:
 - test/parser/test_sets.rb
 - test/scanner/test_all.rb
 - test/scanner/test_anchors.rb
+- test/scanner/test_conditionals.rb
 - test/scanner/test_errors.rb
 - test/scanner/test_escapes.rb
 - test/scanner/test_groups.rb
@@ -149,6 +162,7 @@ test_files:
 - test/scanner/test_meta.rb
 - test/scanner/test_properties.rb
 - test/scanner/test_quantifiers.rb
+- test/scanner/test_quoting.rb
 - test/scanner/test_refcalls.rb
 - test/scanner/test_scripts.rb
 - test/scanner/test_sets.rb