regexp_parser 1.4.0 → 1.5.0

data/spec/parser/sets_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+RSpec.describe('Set parsing') do
+  specify('parse set basic') do
+    root = RP.parse('[ab]+')
+    exp = root[0]
+
+    expect(exp).to be_instance_of(CharacterSet)
+    expect(exp.count).to eq 2
+
+    expect(exp[0]).to be_instance_of(Literal)
+    expect(exp[0].text).to eq 'a'
+    expect(exp[1]).to be_instance_of(Literal)
+    expect(exp[1].text).to eq 'b'
+
+    expect(exp).to be_quantified
+    expect(exp.quantifier.min).to eq 1
+    expect(exp.quantifier.max).to eq(-1)
+  end
+
+  specify('parse set char type') do
+    root = RP.parse('[a\\dc]')
+    exp = root[0]
+
+    expect(exp).to be_instance_of(CharacterSet)
+    expect(exp.count).to eq 3
+
+    expect(exp[1]).to be_instance_of(CharacterType::Digit)
+    expect(exp[1].text).to eq '\\d'
+  end
+
+  specify('parse set escape sequence backspace') do
+    root = RP.parse('[a\\bc]')
+    exp = root[0]
+
+    expect(exp).to be_instance_of(CharacterSet)
+    expect(exp.count).to eq 3
+
+    expect(exp[1]).to be_instance_of(EscapeSequence::Backspace)
+    expect(exp[1].text).to eq '\\b'
+
+    expect(exp.matches?('a')).to be true
+    expect(exp.matches?("\b")).to be true
+    expect(exp.matches?('b')).to be false
+    expect(exp.matches?('c')).to be true
+  end
+
+  specify('parse set escape sequence hex') do
+    root = RP.parse('[a\\x20c]', :any)
+    exp = root[0]
+
+    expect(exp).to be_instance_of(CharacterSet)
+    expect(exp.count).to eq 3
+
+    expect(exp[1]).to be_instance_of(EscapeSequence::Hex)
+    expect(exp[1].text).to eq '\\x20'
+  end
+
+  specify('parse set escape sequence codepoint') do
+    root = RP.parse('[a\\u0640]')
+    exp = root[0]
+
+    expect(exp).to be_instance_of(CharacterSet)
+    expect(exp.count).to eq 2
+
+    expect(exp[1]).to be_instance_of(EscapeSequence::Codepoint)
+    expect(exp[1].text).to eq '\\u0640'
+  end
+
+  specify('parse set escape sequence codepoint list') do
+    root = RP.parse('[a\\u{41 1F60D}]')
+    exp = root[0]
+
+    expect(exp).to be_instance_of(CharacterSet)
+    expect(exp.count).to eq 2
+
+    expect(exp[1]).to be_instance_of(EscapeSequence::CodepointList)
+    expect(exp[1].text).to eq '\\u{41 1F60D}'
+  end
+
+  specify('parse set posix class') do
+    root = RP.parse('[[:digit:][:^lower:]]+')
+    exp = root[0]
+
+    expect(exp).to be_instance_of(CharacterSet)
+    expect(exp.count).to eq 2
+
+    expect(exp[0]).to be_instance_of(PosixClass)
+    expect(exp[0].text).to eq '[:digit:]'
+    expect(exp[1]).to be_instance_of(PosixClass)
+    expect(exp[1].text).to eq '[:^lower:]'
+  end
+
+  specify('parse set nesting') do
+    root = RP.parse('[a[b[c]d]e]')
+
+    exp = root[0]
+    expect(exp).to be_instance_of(CharacterSet)
+    expect(exp.count).to eq 3
+    expect(exp[0]).to be_instance_of(Literal)
+    expect(exp[2]).to be_instance_of(Literal)
+
+    subset1 = exp[1]
+    expect(subset1).to be_instance_of(CharacterSet)
+    expect(subset1.count).to eq 3
+    expect(subset1[0]).to be_instance_of(Literal)
+    expect(subset1[2]).to be_instance_of(Literal)
+
+    subset2 = subset1[1]
+    expect(subset2).to be_instance_of(CharacterSet)
+    expect(subset2.count).to eq 1
+    expect(subset2[0]).to be_instance_of(Literal)
+  end
+
+  specify('parse set nesting negative') do
+    root = RP.parse('[a[^b[c]]]')
+    exp = root[0]
+
+    expect(exp).to be_instance_of(CharacterSet)
+    expect(exp.count).to eq 2
+    expect(exp[0]).to be_instance_of(Literal)
+    expect(exp).not_to be_negative
+
+    subset1 = exp[1]
+    expect(subset1).to be_instance_of(CharacterSet)
+    expect(subset1.count).to eq 2
+    expect(subset1[0]).to be_instance_of(Literal)
+    expect(subset1).to be_negative
+
+    subset2 = subset1[1]
+    expect(subset2).to be_instance_of(CharacterSet)
+    expect(subset2.count).to eq 1
+    expect(subset2[0]).to be_instance_of(Literal)
+    expect(subset2).not_to be_negative
+  end
+
+  specify('parse set nesting #to_s') do
+    pattern = '[a[b[^c]]]'
+    root = RP.parse(pattern)
+
+    expect(root.to_s).to eq pattern
+  end
+
+  specify('parse set literals are not merged') do
+    root = RP.parse("[#{('a' * 10)}]")
+    exp = root[0]
+
+    expect(exp.count).to eq 10
+  end
+
+  specify('parse set whitespace is not merged') do
+    root = RP.parse("[#{(' ' * 10)}]")
+    exp = root[0]
+
+    expect(exp.count).to eq 10
+  end
+
+  specify('parse set whitespace is not merged in x mode') do
+    root = RP.parse("(?x)[#{(' ' * 10)}]")
+    exp = root[1]
+
+    expect(exp.count).to eq 10
+  end
+
+  specify('parse set collating sequence') do
+    root = RP.parse('[a[.span-ll.]h]', :any)
+    exp = root[0]
+
+    expect(exp[1].to_s).to eq '[.span-ll.]'
+  end
+
+  specify('parse set character equivalents') do
+    root = RP.parse('[a[=e=]h]', :any)
+    exp = root[0]
+
+    expect(exp[1].to_s).to eq '[=e=]'
+  end
+end

data/{test/parser/test_types.rb → spec/parser/types_spec.rb}

@@ -1,7 +1,6 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class TestParserTypes < Test::Unit::TestCase
+require 'spec_helper'
 
+RSpec.describe('Type parsing') do
   tests = {
     /a\dc/    => [1, :type,   :digit,     CharacterType::Digit],
     /a\Dc/    => [1, :type,   :nondigit,  CharacterType::NonDigit],
@@ -17,34 +16,28 @@ class TestParserTypes < Test::Unit::TestCase
   }
 
   tests.each_with_index do |(pattern, (index, type, token, klass)), count|
-    define_method "test_parse_type_#{token}_#{count}" do
+    specify("parse_type_#{token}_#{count}") do
       root = RP.parse(pattern, 'ruby/1.9')
-      exp  = root.expressions.at(index)
+      exp = root.expressions.at(index)
 
-      assert exp.is_a?( klass ),
-             "Expected #{klass}, but got #{exp.class.name}"
+      expect(exp).to be_a(klass)
 
-      assert_equal type,  exp.type
-      assert_equal token, exp.token
+      expect(exp.type).to eq type
+      expect(exp.token).to eq token
     end
   end
 
-  tests_2_0 = {
-    'a\Rc'    => [1, :type,   :linebreak, CharacterType::Linebreak],
-    'a\Xc'    => [1, :type,   :xgrapheme, CharacterType::ExtendedGrapheme],
-  }
+  tests_2_0 = { 'a\\Rc' => [1, :type, :linebreak, CharacterType::Linebreak], 'a\\Xc' => [1, :type, :xgrapheme, CharacterType::ExtendedGrapheme] }
 
   tests_2_0.each_with_index do |(pattern, (index, type, token, klass)), count|
-    define_method "test_parse_type_#{token}_#{count}" do
+    specify("parse_type_#{token}_#{count}") do
       root = RP.parse(pattern, 'ruby/2.0')
-      exp  = root.expressions.at(index)
+      exp = root.expressions.at(index)
 
-      assert exp.is_a?( klass ),
-             "Expected #{klass}, but got #{exp.class.name}"
+      expect(exp).to be_a(klass)
 
-      assert_equal type,  exp.type
-      assert_equal token, exp.token
+      expect(exp.type).to eq type
+      expect(exp.token).to eq token
     end
   end
-
 end

data/spec/scanner/all_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+RSpec.describe(Regexp::Scanner) do
+  specify('scanner returns an array') do
+    expect(RS.scan('abc')).to be_instance_of(Array)
+  end
+
+  specify('scanner returns tokens as arrays') do
+    tokens = RS.scan('^abc+[^one]{2,3}\\b\\d\\\\C-C$')
+    expect(tokens).to all(be_a Array)
+    expect(tokens.map(&:length)).to all(eq 5)
+  end
+
+  specify('scanner token count') do
+    re = /^(one|two){2,3}([^d\]efm-qz\,\-]*)(ghi)+$/i
+    expect(RS.scan(re).length).to eq 28
+  end
+end

data/{test/scanner/test_anchors.rb → spec/scanner/anchors_spec.rb}

@@ -1,7 +1,6 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ScannerAnchors < Test::Unit::TestCase
+require 'spec_helper'
 
+RSpec.describe('Anchor scanning') do
   tests = {
    '^abc'       => [0, :anchor,     :bol,                   '^',    0, 1],
    'abc$'       => [1, :anchor,     :eol,                   '$',    3, 4],
@@ -23,16 +22,15 @@ class ScannerAnchors < Test::Unit::TestCase
   }
 
   tests.each_with_index do |(pattern, (index, type, token, text, ts, te)), count|
-    define_method "test_scanner_#{type}_#{token}_#{count}" do
+    specify("scanner_#{type}_#{token}_#{count}") do
       tokens = RS.scan(pattern)
       result = tokens[index]
 
-      assert_equal type,  result[0]
-      assert_equal token, result[1]
-      assert_equal text,  result[2]
-      assert_equal ts,    result[3]
-      assert_equal te,    result[4]
+      expect(result[0]).to eq type
+      expect(result[1]).to eq token
+      expect(result[2]).to eq text
+      expect(result[3]).to eq ts
+      expect(result[4]).to eq te
     end
   end
-
 end

data/{test/scanner/test_conditionals.rb → spec/scanner/conditionals_spec.rb}

@@ -1,45 +1,41 @@
-require File.expand_path("../../helpers", __FILE__)
+require 'spec_helper'
 
-class ScannerConditionals < Test::Unit::TestCase
-
-  # Basic conditional scan token tests
+RSpec.describe('Conditional scanning') do
   tests = {
-    /(a)(?(1)T|F)1/       => [3,  :conditional,  :open,              '(?',   3,  5],
-    /(a)(?(1)T|F)2/       => [4,  :conditional,  :condition_open,    '(',    5,  6],
-    /(a)(?(1)T|F)3/       => [5,  :conditional,  :condition,         '1',    6,  7],
-    /(a)(?(1)T|F)4/       => [6,  :conditional,  :condition_close,   ')',    7,  8],
-    /(a)(?(1)T|F)5/       => [7,  :literal,      :literal,           'T',    8,  9],
-    /(a)(?(1)T|F)6/       => [8,  :conditional,  :separator,         '|',    9,  10],
-    /(a)(?(1)T|F)7/       => [9,  :literal,      :literal,           'F',    10, 11],
-    /(a)(?(1)T|F)8/       => [10, :conditional,  :close,             ')',    11, 12],
-
-    /(a)(?(1)TRUE)9/      => [8,  :conditional,  :close,             ')',    12, 13],
-
-    /(a)(?(1)TRUE|)10/    => [8,  :conditional,  :separator,         '|',    12, 13],
-    /(a)(?(1)TRUE|)11/    => [9,  :conditional,  :close,             ')',    13, 14],
-
-    /(?<N>A)(?(<N>)T|F)1/ => [5,  :conditional,  :condition,         '<N>',  10, 13],
-    /(?'N'A)(?('N')T|F)2/ => [5,  :conditional,  :condition,         "'N'",  10, 13],
+    '(a)(?(1)T|F)1'          => [3,  :conditional,  :open,             '(?',  3,  5],
+    '(a)(?(1)T|F)2'          => [4,  :conditional,  :condition_open,   '(',   5,  6],
+    '(a)(?(1)T|F)3'          => [5,  :conditional,  :condition,        '1',   6,  7],
+    '(a)(?(1)T|F)4'          => [6,  :conditional,  :condition_close,  ')',   7,  8],
+    '(a)(?(1)T|F)5'          => [7,  :literal,      :literal,          'T',   8,  9],
+    '(a)(?(1)T|F)6'          => [8,  :conditional,  :separator,        '|',   9,  10],
+    '(a)(?(1)T|F)7'          => [9,  :literal,      :literal,          'F',   10, 11],
+    '(a)(?(1)T|F)8'          => [10, :conditional,  :close,            ')',   11, 12],
+    '(a)(?(1)TRUE)9'         => [8,  :conditional,  :close,            ')',   12, 13],
+    '(a)(?(1)TRUE|)10'       => [8,  :conditional,  :separator,        '|',   12, 13],
+    '(a)(?(1)TRUE|)11'       => [9,  :conditional,  :close,            ')',   13, 14],
+    '(?<N>A)(?(<N>)T|F)1'    => [5,  :conditional,  :condition,        '<N>', 10, 13],
+    "(?'N'A)(?('N')T|F)2"    => [5,  :conditional,  :condition,        "'N'", 10, 13]
   }
 
   tests.each_with_index do |(pattern, (index, type, token, text, ts, te)), count|
-    define_method "test_scanner_#{type}_#{token}_#{count}" do
+    specify("scanner_#{type}_#{token}_#{count}") do
       tokens = RS.scan(pattern)
       result = tokens[index]
 
-      assert_equal type,  result[0]
-      assert_equal token, result[1]
-      assert_equal text,  result[2]
-      assert_equal ts,    result[3]
-      assert_equal te,    result[4]
+      expect(result[0]).to eq type
+      expect(result[1]).to eq token
+      expect(result[2]).to eq text
+      expect(result[3]).to eq ts
+      expect(result[4]).to eq te
     end
   end
 
-  def test_scan_conditional_nested
-    regexp = /(a(b(c)))(?(1)(?(2)d|(?(3)e|f))|(?(2)(?(1)g|h)))/
+  specify('scan conditional nested') do
+    regexp = '(a(b(c)))(?(1)(?(2)d|(?(3)e|f))|(?(2)(?(1)g|h)))'
     tokens = RS.scan(regexp)
 
-    [ [ 0, :group,        :capture,         '(',   0,  1],
+    [
+      [ 0, :group,        :capture,         '(',   0,  1],
       [ 1, :literal,      :literal,         'a',   1,  2],
       [ 2, :group,        :capture,         '(',   2,  3],
       [ 3, :literal,      :literal,         'b',   3,  4],
@@ -85,19 +81,20 @@ class ScannerConditionals < Test::Unit::TestCase
     ].each do |index, type, token, text, ts, te|
       result = tokens[index]
 
-      assert_equal type,  result[0]
-      assert_equal token, result[1]
-      assert_equal text,  result[2]
-      assert_equal ts,    result[3]
-      assert_equal te,    result[4]
+      expect(result[0]).to eq type
+      expect(result[1]).to eq token
+      expect(result[2]).to eq text
+      expect(result[3]).to eq ts
+      expect(result[4]).to eq te
     end
   end
 
-  def test_scan_conditional_nested_groups
-    regexp = /((a)|(b)|((?(2)(c(d|e)+)?|(?(3)f|(?(4)(g|(h)(i)))))))/
+  specify('scan conditional nested groups') do
+    regexp = '((a)|(b)|((?(2)(c(d|e)+)?|(?(3)f|(?(4)(g|(h)(i)))))))'
     tokens = RS.scan(regexp)
 
-    [ [ 0, :group,        :capture,         '(',   0,  1],
+    [
+      [ 0, :group,        :capture,         '(',   0,  1],
       [ 1, :group,        :capture,         '(',   1,  2],
       [ 2, :literal,      :literal,         'a',   2,  3],
       [ 3, :group,        :close,           ')',   3,  4],
@@ -150,35 +147,34 @@ class ScannerConditionals < Test::Unit::TestCase
     ].each do |index, type, token, text, ts, te|
       result = tokens[index]
 
-      assert_equal type,  result[0]
-      assert_equal token, result[1]
-      assert_equal text,  result[2]
-      assert_equal ts,    result[3]
-      assert_equal te,    result[4]
+      expect(result[0]).to eq type
+      expect(result[1]).to eq token
+      expect(result[2]).to eq text
+      expect(result[3]).to eq ts
+      expect(result[4]).to eq te
     end
   end
 
-  def test_scan_conditional_nested_alternation
-    regexp = /(a)(?(1)(b|c|d)|(e|f|g))(h)(?(2)(i|j|k)|(l|m|n))|o|p/
+  specify('scan conditional nested alternation') do
+    regexp = '(a)(?(1)(b|c|d)|(e|f|g))(h)(?(2)(i|j|k)|(l|m|n))|o|p'
     tokens = RS.scan(regexp)
 
     [9, 11, 17, 19, 32, 34, 40, 42, 46, 48].each do |index|
       result = tokens[index]
 
-      assert_equal :meta,         result[0]
-      assert_equal :alternation,  result[1]
-      assert_equal '|',           result[2]
-      assert_equal 1,             result[4] - result[3]
+      expect(result[0]).to eq :meta
+      expect(result[1]).to eq :alternation
+      expect(result[2]).to eq '|'
+      expect((result[4] - result[3])).to eq 1
     end
 
     [14, 37].each do |index|
       result = tokens[index]
 
-      assert_equal :conditional,  result[0]
-      assert_equal :separator,    result[1]
-      assert_equal '|',           result[2]
-      assert_equal 1,             result[4] - result[3]
+      expect(result[0]).to eq :conditional
+      expect(result[1]).to eq :separator
+      expect(result[2]).to eq '|'
+      expect((result[4] - result[3])).to eq 1
     end
   end
-
 end

data/spec/scanner/errors_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+RSpec.describe('Scanning errors') do
+  specify('scanner unbalanced set') do
+    expect { RS.scan('[[:alpha:]') }.to raise_error(RS::PrematureEndError)
+  end
+
+  specify('scanner unbalanced group') do
+    expect { RS.scan('(abc') }.to raise_error(RS::PrematureEndError)
+  end
+
+  specify('scanner unbalanced interval') do
+    expect { RS.scan('a{1,2') }.to raise_error(RS::PrematureEndError)
+  end
+
+  specify('scanner eof in property') do
+    expect { RS.scan('\\p{asci') }.to raise_error(RS::PrematureEndError)
+  end
+
+  specify('scanner incomplete property') do
+    expect { RS.scan('\\p{ascii abc') }.to raise_error(RS::PrematureEndError)
+  end
+
+  specify('scanner unknown property') do
+    expect { RS.scan('\\p{foobar}') }.to raise_error(RS::UnknownUnicodePropertyError)
+  end
+
+  specify('scanner incomplete options') do
+    expect { RS.scan('(?mix abc)') }.to raise_error(RS::ScannerError)
+  end
+
+  specify('scanner eof options') do
+    expect { RS.scan('(?mix') }.to raise_error(RS::PrematureEndError)
+  end
+
+  specify('scanner incorrect options') do
+    expect { RS.scan('(?mix^bc') }.to raise_error(RS::ScannerError)
+  end
+
+  specify('scanner eof escape') do
+    expect { RS.scan('\\') }.to raise_error(RS::PrematureEndError)
+  end
+
+  specify('scanner eof in hex escape') do
+    expect { RS.scan('\\x') }.to raise_error(RS::PrematureEndError)
+  end
+
+  specify('scanner eof in codepoint escape') do
+    expect { RS.scan('\\u') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\u0') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\u00') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\u000') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\u{') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\u{00') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\u{0000') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\u{0000 ') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\u{0000 0000') }.to raise_error(RS::PrematureEndError)
+  end
+
+  specify('scanner eof in control sequence') do
+    expect { RS.scan('\\c') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\c\\M') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\c\\M-') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\C') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\C-') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\C-\\M') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\C-\\M-') }.to raise_error(RS::PrematureEndError)
+  end
+
+  specify('scanner eof in meta sequence') do
+    expect { RS.scan('\\M') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\M-') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\M-\\') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\M-\\c') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\M-\\C') }.to raise_error(RS::PrematureEndError)
+    expect { RS.scan('\\M-\\C-') }.to raise_error(RS::PrematureEndError)
+  end
+
+  specify('scanner invalid hex escape') do
+    expect { RS.scan('\\xZ') }.to raise_error(RS::InvalidSequenceError)
+    expect { RS.scan('\\xZ0') }.to raise_error(RS::InvalidSequenceError)
+  end
+
+  specify('scanner invalid named group') do
+    expect { RS.scan("(?'')") }.to raise_error(RS::InvalidGroupError)
+    expect { RS.scan("(?''empty-name)") }.to raise_error(RS::InvalidGroupError)
+    expect { RS.scan('(?<>)') }.to raise_error(RS::InvalidGroupError)
+    expect { RS.scan('(?<>empty-name)') }.to raise_error(RS::InvalidGroupError)
+  end
+end