regexp_parser 1.4.0 → 1.5.0

data/test/helpers.rb

@@ -1,10 +0,0 @@
-require "test/unit"
-require File.expand_path("../../lib/regexp_parser", __FILE__)
-require 'regexp_property_values'
-
-RS = Regexp::Scanner
-RL = Regexp::Lexer
-RP = Regexp::Parser
-RE = Regexp::Expression
-
-include Regexp::Expression

data/test/lexer/test_all.rb

@@ -1,41 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-%w{
-  literals nesting refcalls
-}.each do|tc|
-  require File.expand_path("../test_#{tc}", __FILE__)
-end
-
-if RUBY_VERSION >= '2.0.0'
-  %w{conditionals keep}.each do|tc|
-    require File.expand_path("../test_#{tc}", __FILE__)
-  end
-end
-
-class TestRegexpLexer < Test::Unit::TestCase
-
-  def test_lexer_returns_an_array
-    assert_instance_of Array, RL.lex('abc')
-  end
-
-  def test_lexer_returns_tokens
-    tokens = RL.lex('^abc+[^one]{2,3}\b\d\\\C-C$')
-
-    assert tokens.all?{ |token| token.kind_of?(Regexp::Token) },
-          "Not all array members are tokens"
-
-    assert tokens.all?{ |token| token.to_a.length == 8 },
-          "Not all tokens have a length of 8"
-  end
-
-  def test_lexer_token_count
-    tokens = RL.lex(/^(one|two){2,3}([^d\]efm-qz\,\-]*)(ghi)+$/i)
-
-    assert_equal 28, tokens.length
-  end
-
-  def test_lexer_scan_alias
-    assert_equal RL.lex(/a|b|c/), RL.scan(/a|b|c/)
-  end
-
-end

data/test/lexer/test_keep.rb

@@ -1,24 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class LexerKeep < Test::Unit::TestCase
-
-  def test_lex_keep_token
-    regexp = /ab\Kcd/
-    tokens = RL.lex(regexp)
-
-    assert_equal :keep, tokens[1].type
-    assert_equal :mark, tokens[1].token
-  end
-
-  def test_lex_keep_nested
-    regexp = /(a\Kb)|(c\\\Kd)ef/
-    tokens = RL.lex(regexp)
-
-    assert_equal :keep, tokens[2].type
-    assert_equal :mark, tokens[2].token
-
-    assert_equal :keep, tokens[9].type
-    assert_equal :mark, tokens[9].token
-  end
-
-end

data/test/lexer/test_refcalls.rb

@@ -1,56 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class LexerRefCalls < Test::Unit::TestCase
-
-  tests = {
-    # Traditional numerical group back-reference
-    '(abc)\1'         => [3, :backref, :number,             '\1',         5,  7, 0, 0, 0],
-
-    # Group back-references, named, numbered, and relative
-    '(?<X>abc)\k<X>'  => [3, :backref, :name_ref,           '\k<X>',      9, 14, 0, 0, 0],
-    "(?<X>abc)\\k'X'" => [3, :backref, :name_ref,           "\\k'X'",     9, 14, 0, 0, 0],
-
-    '(abc)\k<1>'      => [3, :backref, :number_ref,         '\k<1>',      5, 10, 0, 0, 0],
-    "(abc)\\k'1'"     => [3, :backref, :number_ref,         "\\k'1'",     5, 10, 0, 0, 0],
-
-    '(abc)\k<-1>'     => [3, :backref, :number_rel_ref,     '\k<-1>',     5, 11, 0, 0, 0],
-    "(abc)\\k'-1'"    => [3, :backref, :number_rel_ref,     "\\k'-1'",    5, 11, 0, 0, 0],
-
-    # Sub-expression invocation, named, numbered, and relative
-    '(?<X>abc)\g<X>'  => [3, :backref, :name_call,          '\g<X>',      9, 14, 0, 0, 0],
-    "(?<X>abc)\\g'X'" => [3, :backref, :name_call,          "\\g'X'",     9, 14, 0, 0, 0],
-
-    '(abc)\g<1>'      => [3, :backref, :number_call,        '\g<1>',      5, 10, 0, 0, 0],
-    "(abc)\\g'1'"     => [3, :backref, :number_call,        "\\g'1'",     5, 10, 0, 0, 0],
-
-    '(abc)\g<-1>'     => [3, :backref, :number_rel_call,    '\g<-1>',     5, 11, 0, 0, 0],
-    "(abc)\\g'-1'"    => [3, :backref, :number_rel_call,    "\\g'-1'",    5, 11, 0, 0, 0],
-
-    '(abc)\g<+1>'     => [3, :backref, :number_rel_call,    '\g<+1>',     5, 11, 0, 0, 0],
-    "(abc)\\g'+1'"    => [3, :backref, :number_rel_call,    "\\g'+1'",    5, 11, 0, 0, 0],
-
-    # Group back-references, with nesting level
-    '(?<X>abc)\k<X-0>'  => [3, :backref, :name_recursion_ref,    '\k<X-0>',    9, 16, 0, 0, 0],
-    "(?<X>abc)\\k'X-0'" => [3, :backref, :name_recursion_ref,    "\\k'X-0'",   9, 16, 0, 0, 0],
-
-    '(abc)\k<1-0>'      => [3, :backref, :number_recursion_ref,  '\k<1-0>',    5, 12, 0, 0, 0],
-    "(abc)\\k'1-0'"     => [3, :backref, :number_recursion_ref,  "\\k'1-0'",   5, 12, 0, 0, 0],
-  }
-
-  tests.each_with_index do |(pattern, (index, type, token, text, ts, te, level, set_level, conditional_level)), count|
-    define_method "test_lexer_#{type}_#{token}_#{count}" do
-      tokens = RL.lex(pattern, 'ruby/1.9')
-      struct = tokens.at(index)
-
-      assert_equal type,              struct.type
-      assert_equal token,             struct.token
-      assert_equal text,              struct.text
-      assert_equal ts,                struct.ts
-      assert_equal te,                struct.te
-      assert_equal level,             struct.level
-      assert_equal set_level,         struct.set_level
-      assert_equal conditional_level, struct.conditional_level
-    end
-  end
-
-end

data/test/parser/set/test_intersections.rb

@@ -1,127 +0,0 @@
-require File.expand_path('../../../helpers', __FILE__)
-
-# edge cases with `...-&&...` and `...&&-...` are checked in test_ranges.rb
-
-class ParserSetIntersections < Test::Unit::TestCase
-  def test_parse_set_intersection
-    root = RP.parse('[a&&z]')
-    set  = root[0]
-    ints = set[0]
-
-    assert_equal 1, set.count
-    assert_equal CharacterSet::Intersection, ints.class
-    assert_equal 2, ints.count
-
-    seq1, seq2 = ints.expressions
-    assert_equal CharacterSet::IntersectedSequence, seq1.class
-    assert_equal 1, seq1.count
-    assert_equal 'a', seq1.first.to_s
-    assert_equal Literal, seq1.first.class
-    assert_equal CharacterSet::IntersectedSequence, seq2.class
-    assert_equal 1, seq2.count
-    assert_equal 'z', seq2.first.to_s
-    assert_equal Literal, seq2.first.class
-
-    refute       set.matches?('a')
-    refute       set.matches?('&')
-    refute       set.matches?('z')
-  end
-
-  def test_parse_set_intersection_range_and_subset
-    root = RP.parse('[a-z&&[^a]]')
-    set  = root[0]
-    ints = set[0]
-
-    assert_equal 1, set.count
-    assert_equal CharacterSet::Intersection, ints.class
-    assert_equal 2, ints.count
-
-    seq1, seq2 = ints.expressions
-    assert_equal CharacterSet::IntersectedSequence, seq1.class
-    assert_equal 1, seq1.count
-    assert_equal 'a-z', seq1.first.to_s
-    assert_equal CharacterSet::Range, seq1.first.class
-    assert_equal CharacterSet::IntersectedSequence, seq2.class
-    assert_equal 1, seq2.count
-    assert_equal '[^a]', seq2.first.to_s
-    assert_equal CharacterSet, seq2.first.class
-
-    refute       set.matches?('a')
-    refute       set.matches?('&')
-    assert       set.matches?('b')
-  end
-
-  def test_parse_set_intersection_trailing_range
-    root = RP.parse('[a&&a-z]')
-    set  = root[0]
-    ints = set[0]
-
-    assert_equal 1, set.count
-    assert_equal CharacterSet::Intersection, ints.class
-    assert_equal 2, ints.count
-
-    seq1, seq2 = ints.expressions
-    assert_equal CharacterSet::IntersectedSequence, seq1.class
-    assert_equal 1, seq1.count
-    assert_equal 'a', seq1.first.to_s
-    assert_equal Literal, seq1.first.class
-    assert_equal CharacterSet::IntersectedSequence, seq2.class
-    assert_equal 1, seq2.count
-    assert_equal 'a-z', seq2.first.to_s
-    assert_equal CharacterSet::Range, seq2.first.class
-
-    assert       set.matches?('a')
-    refute       set.matches?('&')
-    refute       set.matches?('b')
-  end
-
-  def test_parse_set_intersection_type
-    root = RP.parse('[a&&\w]')
-    set  = root[0]
-    ints = set[0]
-
-    assert_equal 1, set.count
-    assert_equal CharacterSet::Intersection, ints.class
-    assert_equal 2, ints.count
-
-    seq1, seq2 = ints.expressions
-    assert_equal CharacterSet::IntersectedSequence, seq1.class
-    assert_equal 1, seq1.count
-    assert_equal 'a', seq1.first.to_s
-    assert_equal Literal, seq1.first.class
-    assert_equal CharacterSet::IntersectedSequence, seq2.class
-    assert_equal 1, seq2.count
-    assert_equal '\w', seq2.first.to_s
-    assert_equal CharacterType::Word, seq2.first.class
-
-    assert       set.matches?('a')
-    refute       set.matches?('&')
-    refute       set.matches?('b')
-  end
-
-  def test_parse_set_intersection_multipart
-    root = RP.parse('[\h&&\w&&efg]')
-    set  = root[0]
-    ints = set[0]
-
-    assert_equal 1, set.count
-    assert_equal CharacterSet::Intersection, ints.class
-    assert_equal 3, ints.count
-
-    seq1, seq2, seq3 = ints.expressions
-    assert_equal CharacterSet::IntersectedSequence, seq1.class
-    assert_equal 1, seq1.count
-    assert_equal '\h', seq1.first.to_s
-    assert_equal CharacterSet::IntersectedSequence, seq2.class
-    assert_equal 1, seq2.count
-    assert_equal '\w', seq2.first.to_s
-    assert_equal CharacterSet::IntersectedSequence, seq3.class
-    assert_equal 3, seq3.count
-    assert_equal 'efg', seq3.to_s
-
-    assert       set.matches?('e')
-    assert       set.matches?('f')
-    refute       set.matches?('a')
-    refute       set.matches?('g')
-  end
-end

data/test/parser/set/test_ranges.rb

@@ -1,111 +0,0 @@
-require File.expand_path('../../../helpers', __FILE__)
-
-class ParserSetRangs < Test::Unit::TestCase
-  def test_parse_set_range
-    root  = RP.parse('[a-z]')
-    set   = root[0]
-    range = set[0]
-
-    assert_equal 1, set.count
-    assert_equal CharacterSet::Range, range.class
-    assert_equal 2, range.count
-    assert_equal 'a', range.first.to_s
-    assert_equal Literal, range.first.class
-    assert_equal 'z', range.last.to_s
-    assert_equal Literal, range.last.class
-    assert       set.matches?('m')
-  end
-
-  def test_parse_set_range_hex
-    root  = RP.parse('[\x00-\x99]')
-    set   = root[0]
-    range = set[0]
-
-    assert_equal 1, set.count
-    assert_equal CharacterSet::Range, range.class
-    assert_equal 2, range.count
-    assert_equal '\x00', range.first.to_s
-    assert_equal EscapeSequence::Hex, range.first.class
-    assert_equal '\x99', range.last.to_s
-    assert_equal EscapeSequence::Hex, range.last.class
-    assert       set.matches?('\x50')
-  end
-
-  def test_parse_set_range_unicode
-    root  = RP.parse('[\u{40 42}-\u1234]')
-    set   = root[0]
-    range = set[0]
-
-    assert_equal 1, set.count
-    assert_equal CharacterSet::Range, range.class
-    assert_equal 2, range.count
-    assert_equal '\u{40 42}', range.first.to_s
-    assert_equal EscapeSequence::CodepointList, range.first.class
-    assert_equal '\u1234', range.last.to_s
-    assert_equal EscapeSequence::Codepoint, range.last.class
-    assert       set.matches?('\u600')
-  end
-
-  def test_parse_set_range_edge_case_leading_dash
-    root  = RP.parse('[--z]')
-    set   = root[0]
-    range = set[0]
-
-    assert_equal 1, set.count
-    assert_equal 2, range.count
-    assert       set.matches?('a')
-  end
-
-  def test_parse_set_range_edge_case_trailing_dash
-    root  = RP.parse('[!--]')
-    set   = root[0]
-    range = set[0]
-
-    assert_equal 1, set.count
-    assert_equal 2, range.count
-    assert       set.matches?('$')
-  end
-
-  def test_parse_set_range_edge_case_leading_negate
-    root = RP.parse('[^-z]')
-    set  = root[0]
-
-    assert_equal 2, set.count
-    assert       set.matches?('a')
-    refute       set.matches?('z')
-  end
-
-  def test_parse_set_range_edge_case_trailing_negate
-    root  = RP.parse('[!-^]')
-    set   = root[0]
-    range = set[0]
-
-    assert_equal 1, set.count
-    assert_equal 2, range.count
-    assert       set.matches?('$')
-  end
-
-  def test_parse_set_range_edge_case_leading_intersection
-    root  = RP.parse('[[\-ab]&&-bc]')
-    set   = root[0]
-
-    assert_equal 1, set.count
-    assert_equal '-bc', set.first.last.to_s
-    assert       set.matches?('-')
-    assert       set.matches?('b')
-    refute       set.matches?('a')
-    refute       set.matches?('c')
-  end
-
-  def test_parse_set_range_edge_case_trailing_intersection
-    root  = RP.parse('[bc-&&[\-ab]]')
-    set   = root[0]
-
-    assert_equal 1, set.count
-    assert_equal 'bc-', set.first.first.to_s
-    assert       set.matches?('-')
-    assert       set.matches?('b')
-    refute       set.matches?('a')
-    refute       set.matches?('c')
-  end
-end

data/test/parser/test_all.rb

@@ -1,64 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-%w[
-  alternation anchors errors escapes free_space groups
-  posix_classes properties quantifiers refcalls sets types
-].each do |tc|
-  require File.expand_path("../test_#{tc}", __FILE__)
-end
-
-require File.expand_path('../set/test_ranges.rb', __FILE__)
-require File.expand_path('../set/test_intersections.rb', __FILE__)
-
-if RUBY_VERSION >= '2.0.0'
-  %w[conditionals keep].each do |tc|
-    require File.expand_path("../test_#{tc}", __FILE__)
-  end
-end
-
-class TestParser < Test::Unit::TestCase
-
-  def test_parse_returns_a_root_expression
-    assert_instance_of Regexp::Expression::Root, RP.parse('abc')
-  end
-
-
-  def test_parse_root_contains_expressions
-    root = RP.parse(/^a.c+[^one]{2,3}\b\d\\\C-C$/)
-
-    all_base = root.expressions.all? do |exp|
-      exp.kind_of?(Regexp::Expression::Base)
-    end
-
-    assert all_base, "Not all nodes are instances of Regexp::Expression"
-  end
-
-
-  def test_parse_node_types
-    root = RP.parse('^(one){2,3}([^d\]efm-qz\,\-]*)(ghi)+$')
-
-    assert root.expressions[1].expressions[0].is_a?(Literal),
-          "Not a literal node, but should be"
-
-    assert root.expressions[1].quantified?, "Not quanfified, but should be"
-
-    assert root.expressions[2].expressions[0].is_a?(CharacterSet),
-          "Not a caracter set, but it should be"
-
-    assert_equal false, root.expressions[2].quantified?
-
-    assert root.expressions[3].is_a?(Group::Capture),
-          "Not a group, but should be"
-
-    assert_equal true, root.expressions[3].quantified?
-  end
-
-  def test_parse_no_quantifier_target_raises_error
-    assert_raise( ArgumentError ) { RP.parse('?abc') }
-  end
-
-  def test_parse_sequence_no_quantifier_target_raises_error
-    assert_raise( ArgumentError ) { RP.parse('abc|?def') }
-  end
-
-end

data/test/parser/test_alternation.rb

@@ -1,92 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class ParserAlternation < Test::Unit::TestCase
-
-  def setup
-    @root = RP.parse('(ab??|cd*|ef+)*|(gh|ij|kl)?')
-  end
-
-  def test_parse_alternation_root
-    e = @root.expressions[0]
-    assert_equal true,   e.is_a?(Alternation)
-  end
-
-  def test_parse_alternation_alts
-    alts = @root.expressions[0].alternatives
-
-    assert_equal true,   alts[0].is_a?(Alternative)
-    assert_equal true,   alts[1].is_a?(Alternative)
-
-    assert_equal true,   alts[0][0].is_a?(Group::Capture)
-    assert_equal true,   alts[1][0].is_a?(Group::Capture)
-
-    assert_equal 2,      alts.length
-  end
-
-  def test_parse_alternation_nested
-    e = @root[0].alternatives[0][0][0]
-
-    assert_equal true, e.is_a?(Alternation)
-  end
-
-  def test_parse_alternation_nested_sequence
-    alts    = @root.expressions[0][0]
-    nested  = alts.expressions[0][0][0]
-
-    assert_equal true,   nested.is_a?(Alternative)
-
-    assert_equal true,   nested.expressions[0].is_a?(Literal)
-    assert_equal true,   nested.expressions[1].is_a?(Literal)
-    assert_equal 2,      nested.expressions.length
-  end
-
-  def test_parse_alternation_nested_groups
-    root = RP.parse('(i|ey|([ougfd]+)|(ney))')
-
-    alts = root.expressions[0][0].alternatives
-    assert_equal 4,  alts.length
-  end
-
-  def test_parse_alternation_grouped_alts
-    root = RP.parse('ca((n)|(t)|(ll)|(b))')
-
-    alts = root.expressions[1][0].alternatives
-
-    assert_equal 4, alts.length
-
-    assert_equal true, alts[0].is_a?(Alternative)
-    assert_equal true, alts[1].is_a?(Alternative)
-    assert_equal true, alts[2].is_a?(Alternative)
-    assert_equal true, alts[3].is_a?(Alternative)
-  end
-
-  def test_parse_alternation_nested_grouped_alts
-    root = RP.parse('ca((n|t)|(ll|b))')
-
-    alts = root.expressions[1][0].alternatives
-
-    assert_equal 2, alts.length
-
-    assert_equal true, alts[0].is_a?(Alternative)
-    assert_equal true, alts[1].is_a?(Alternative)
-
-    subalts = root.expressions[1][0][0][0][0].alternatives
-
-    assert_equal 2, alts.length
-
-    assert_equal true, subalts[0].is_a?(Alternative)
-    assert_equal true, subalts[1].is_a?(Alternative)
-  end
-
-  def test_parse_alternation_continues_after_nesting
-    root = RP.parse(/a|(b)c/)
-
-    seq = root.expressions[0][1].expressions
-
-    assert_equal 2, seq.length
-
-    assert_equal true, seq[0].is_a?(Group::Capture)
-    assert_equal true, seq[1].is_a?(Literal)
-  end
-
-end