regexp_parser 1.4.0 → 1.5.0

data/test/syntax/test_syntax_token_map.rb

@@ -1,25 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class TestSyntaxTokenMap < Test::Unit::TestCase
-  def test_syntax_token_map_complete
-    map = Regexp::Syntax::Token::Map
-    latest_syntax = Regexp::Syntax.new 'ruby/2.9'
-
-    latest_syntax.features.each do |type, tokens|
-      tokens.each do |token|
-        assert map[type].include?(token),
-               "`#{type} #{token}` implemented but missing from Map"
-      end
-    end
-  end
-
-  def test_syntax_token_map_uniq
-    combinations = Regexp::Syntax::Token::Map.flat_map do |type, tokens|
-      tokens.map { |token| "#{type} #{token}" }
-    end
-
-    non_uniq = combinations.group_by { |str| str }.select { |_, v| v.count > 1 }
-
-    assert_empty non_uniq.keys
-  end
-end

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

@@ -1,55 +0,0 @@
-require File.expand_path("../../../helpers", __FILE__)
-
-class TestSyntaxV1_8 < Test::Unit::TestCase
-  include Regexp::Syntax::Token
-
-  def setup
-    @syntax = Regexp::Syntax.new 'ruby/1.8'
-  end
-
-  tests = {
-    implements: {
-      assertion:    [Assertion::Lookahead].flatten,
-      backref:      [:number],
-      escape:       [
-        Escape::Basic + Escape::ASCII + Escape::Meta + Escape::Control
-      ].flatten,
-      group:        [Group::V1_8_6].flatten,
-      quantifier:   [
-          Quantifier::Greedy + Quantifier::Reluctant +
-          Quantifier::Interval + Quantifier::IntervalReluctant
-      ].flatten,
-    },
-
-    excludes: {
-      assertion: [Assertion::Lookbehind].flatten,
-
-      backref: [
-        Backreference::All - [:number] + SubexpressionCall::All
-      ].flatten,
-
-      quantifier: [
-        Quantifier::Possessive
-      ].flatten
-    },
-  }
-
-  tests.each do |method, types|
-    expected = method == :excludes ? false : true
-
-    types.each do |type, tokens|
-      if tokens.nil? or tokens.empty?
-        define_method "test_syntax_V1_8_#{method}_#{type}" do
-          assert_equal expected, @syntax.implements?(type, nil)
-        end
-      else
-        tokens.each do |token|
-          define_method "test_syntax_V1_8_#{method}_#{type}_#{token}" do
-            assert_equal expected, @syntax.implements?(type, token)
-          end
-        end
-      end
-    end
-  end
-
-end

data/test/syntax/versions/test_1.9.1.rb

@@ -1,36 +0,0 @@
-require File.expand_path("../../../helpers", __FILE__)
-
-class TestSyntaxV1_9_1 < Test::Unit::TestCase
-  include Regexp::Syntax::Token
-
-  def setup
-    @syntax = Regexp::Syntax.new 'ruby/1.9.1'
-  end
-
-  tests = {
-    implements: {
-      escape: [
-        Escape::Hex + Escape::Octal + Escape::Unicode
-      ].flatten,
-
-      type: [
-        CharacterType::Hex
-      ].flatten,
-
-      quantifier: [
-        Quantifier::Greedy + Quantifier::Reluctant + Quantifier::Possessive
-      ].flatten,
-    },
-  }
-
-  tests.each do |method, types|
-    types.each do |type, tokens|
-      tokens.each do |token|
-        define_method "test_syntax_V1_9_1_#{method}_#{type}_#{token}" do
-          assert_equal true, @syntax.implements?(type, token)
-        end
-      end
-    end
-  end
-
-end

data/test/syntax/versions/test_1.9.3.rb

@@ -1,32 +0,0 @@
-require File.expand_path("../../../helpers", __FILE__)
-
-class TestSyntaxV1_9_3 < Test::Unit::TestCase
-  include Regexp::Syntax::Token
-
-  def setup
-    @syntax = Regexp::Syntax.new 'ruby/1.9.3'
-  end
-
-  tests = {
-    implements: {
-      property: [
-        UnicodeProperty::Script_V1_9_3 + UnicodeProperty::Age_V1_9_3
-      ].flatten,
-
-      nonproperty: [
-        UnicodeProperty::Script_V1_9_3 + UnicodeProperty::Age_V1_9_3
-      ].flatten,
-    },
-  }
-
-  tests.each do |method, types|
-    types.each do |type, tokens|
-      tokens.each do |token|
-        define_method "test_syntax_V1_9_3_#{method}_#{type}_#{token}" do
-          assert_equal true, @syntax.implements?(type, token)
-        end
-      end
-    end
-  end
-
-end

data/test/syntax/versions/test_2.0.0.rb

@@ -1,37 +0,0 @@
-require File.expand_path("../../../helpers", __FILE__)
-
-class TestSyntaxV2_0_0 < Test::Unit::TestCase
-  include Regexp::Syntax::Token
-
-  def setup
-    @syntax = Regexp::Syntax.new 'ruby/2.0.0'
-  end
-
-  tests = {
-    implements: {
-      property: [
-        UnicodeProperty::Age_V2_0_0
-      ].flatten,
-
-      nonproperty: [
-        UnicodeProperty::Age_V2_0_0
-      ].flatten,
-    },
-    excludes: {
-      property:    [:newline],
-      nonproperty: [:newline],
-    }
-  }
-
-  tests.each do |method, types|
-    expected = method == :excludes ? false : true
-
-    types.each do |type, tokens|
-      tokens.each do |token|
-        define_method "test_syntax_ruby_V2_0_0_#{method}_#{type}_#{token}" do
-          assert_equal expected, @syntax.implements?(type, token)
-        end
-      end
-    end
-  end
-end

data/test/syntax/versions/test_2.2.0.rb

@@ -1,32 +0,0 @@
-require File.expand_path("../../../helpers", __FILE__)
-
-class TestSyntaxV2_2_0 < Test::Unit::TestCase
-  include Regexp::Syntax::Token
-
-  def setup
-    @syntax = Regexp::Syntax.new 'ruby/2.2.0'
-  end
-
-  tests = {
-    implements: {
-      property: [
-        UnicodeProperty::Script_V2_2_0 + UnicodeProperty::Age_V2_2_0
-      ].flatten,
-
-      nonproperty: [
-        UnicodeProperty::Script_V2_2_0 + UnicodeProperty::Age_V2_2_0
-      ].flatten,
-    },
-  }
-
-  tests.each do |method, types|
-    types.each do |type, tokens|
-      tokens.each do |token|
-        define_method "test_syntax_V2_2_0_#{method}_#{type}_#{token}" do
-          assert_equal true, @syntax.implements?(type, token)
-        end
-      end
-    end
-  end
-
-end

data/test/syntax/versions/test_aliases.rb

@@ -1,129 +0,0 @@
-require File.expand_path("../../../helpers", __FILE__)
-
-class TestSyntaxAliases < Test::Unit::TestCase
-  # 1.8 syntax
-  def test_syntax_alias_1_8_6
-    syntax = Regexp::Syntax.new 'ruby/1.8.6'
-
-    assert syntax.is_a?(Regexp::Syntax::V1_8_6)
-  end
-
-  def test_syntax_alias_1_8_alias
-    syntax = Regexp::Syntax.new 'ruby/1.8'
-
-    assert syntax.is_a?(Regexp::Syntax::V1_8_6)
-  end
-
-  # 1.9 syntax
-  def test_syntax_alias_1_9_1
-    syntax = Regexp::Syntax.new 'ruby/1.9.1'
-
-    assert syntax.is_a?(Regexp::Syntax::V1_9_1)
-  end
-
-  def test_syntax_alias_1_9_alias
-    syntax = Regexp::Syntax.new 'ruby/1.9'
-
-    assert syntax.is_a?(Regexp::Syntax::V1_9_3)
-  end
-
-  # 2.0 syntax
-  def test_syntax_alias_2_0_0
-    syntax = Regexp::Syntax.new 'ruby/2.0.0'
-
-    assert syntax.is_a?(Regexp::Syntax::V1_9)
-  end
-
-  def test_syntax_alias_2_0_alias
-    syntax = Regexp::Syntax.new 'ruby/2.0'
-
-    assert syntax.is_a?(Regexp::Syntax::V2_0_0)
-  end
-
-  # 2.1 syntax
-  def test_syntax_alias_2_1_alias
-    syntax = Regexp::Syntax.new 'ruby/2.1'
-
-    assert syntax.is_a?(Regexp::Syntax::V2_0_0)
-  end
-
-  # 2.2 syntax
-  def test_syntax_alias_2_2_0
-    syntax = Regexp::Syntax.new 'ruby/2.2.0'
-
-    assert syntax.is_a?(Regexp::Syntax::V2_0_0)
-  end
-
-  def test_syntax_alias_2_2_10
-    syntax = Regexp::Syntax.new 'ruby/2.2.10'
-
-    assert syntax.is_a?(Regexp::Syntax::V2_0_0)
-  end
-
-  def test_syntax_alias_2_2_alias
-    syntax = Regexp::Syntax.new 'ruby/2.2'
-
-    assert syntax.is_a?(Regexp::Syntax::V2_0_0)
-  end
-
-  # 2.3 syntax
-  def test_syntax_alias_2_3_0
-    syntax = Regexp::Syntax.new 'ruby/2.3.0'
-
-    assert syntax.is_a?(Regexp::Syntax::V2_3_0)
-  end
-
-  def test_syntax_alias_2_3
-    syntax = Regexp::Syntax.new 'ruby/2.3'
-
-    assert syntax.is_a?(Regexp::Syntax::V2_3_0)
-  end
-
-  # 2.4 syntax
-  def test_syntax_alias_2_4_0
-    syntax = Regexp::Syntax.new 'ruby/2.4.0'
-
-    assert syntax.is_a?(Regexp::Syntax::V2_4_0)
-  end
-
-  def test_syntax_alias_2_4_1
-    syntax = Regexp::Syntax.new 'ruby/2.4.1'
-
-    assert syntax.is_a?(Regexp::Syntax::V2_4_1)
-  end
-
-  # 2.5 syntax
-  def test_syntax_alias_2_5_0
-    syntax = Regexp::Syntax.new 'ruby/2.5.0'
-
-    assert syntax.is_a?(Regexp::Syntax::V2_4_1)
-    assert syntax.is_a?(Regexp::Syntax::V2_5_0)
-  end
-
-  def test_syntax_alias_2_5
-    syntax = Regexp::Syntax.new 'ruby/2.5'
-
-    assert syntax.is_a?(Regexp::Syntax::V2_5_0)
-  end
-
-  # 2.6 syntax
-  def test_syntax_alias_2_6_0
-    syntax = Regexp::Syntax.new 'ruby/2.6.0'
-
-    assert syntax.is_a?(Regexp::Syntax::V2_5_0)
-    assert syntax.is_a?(Regexp::Syntax::V2_6_0)
-  end
-
-  def test_syntax_alias_2_6
-    syntax = Regexp::Syntax.new 'ruby/2.6'
-
-    assert syntax.is_a?(Regexp::Syntax::V2_5_0)
-  end
-
-  def test_future_alias_warning
-    _, stderr_output = capture_output { Regexp::Syntax.new 'ruby/5.0' }
-
-    assert_match(/This library .* but you are running .* \(feature set of .*\)/,
-                 stderr_output)
-  end
-end

data/test/syntax/versions/test_all.rb

@@ -1,5 +0,0 @@
-require File.expand_path("../../../helpers", __FILE__)
-
-%w{aliases 1.8 1.9.1 1.9.3 2.0.0 2.2.0}.each do|tc|
-  require File.expand_path("../test_#{tc}", __FILE__)
-end

data/test/test_all.rb

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

data/test/token/test_all.rb

@@ -1,2 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-require File.expand_path("../test_token", __FILE__)

data/test/token/test_token.rb

@@ -1,107 +0,0 @@
-require File.expand_path("../../helpers", __FILE__)
-
-class Token < Test::Unit::TestCase
-
-  def test_token_offset
-    regexp = /ab?cd/
-    tokens = RL.lex(regexp)
-
-    assert_equal 'b',    tokens[1].text
-    assert_equal [1, 2], tokens[1].offset
-
-    assert_equal '?',    tokens[2].text
-    assert_equal [2, 3], tokens[2].offset
-
-    assert_equal 'cd',   tokens[3].text
-    assert_equal [3, 5], tokens[3].offset
-  end
-
-  def test_token_length
-    regexp = /abc?def/
-    tokens = RL.lex(regexp)
-
-    assert_equal 'ab',  tokens[0].text
-    assert_equal 2,     tokens[0].length
-
-    assert_equal 'c',   tokens[1].text
-    assert_equal 1,     tokens[1].length
-
-    assert_equal '?',   tokens[2].text
-    assert_equal 1,     tokens[2].length
-
-    assert_equal 'def', tokens[3].text
-    assert_equal 3,     tokens[3].length
-  end
-
-  def test_token_to_h
-    regexp = /abc?def/
-    tokens = RL.lex(regexp)
-
-    assert_equal 'ab', tokens[0].text
-    assert_equal({
-        :type               => :literal,
-        :token              => :literal,
-        :text               => 'ab',
-        :ts                 => 0,
-        :te                 => 2,
-        :level              => 0,
-        :set_level          => 0,
-        :conditional_level  => 0
-      }, tokens[0].to_h
-    )
-
-    assert_equal '?', tokens[2].text
-    assert_equal({
-        :type               => :quantifier,
-        :token              => :zero_or_one,
-        :text               => '?',
-        :ts                 => 3,
-        :te                 => 4,
-        :level              => 0,
-        :set_level          => 0,
-        :conditional_level  => 0
-      }, tokens[2].to_h
-    )
-  end
-
-  def test_token_next
-    regexp = /a+b?c*d{2,3}/
-    tokens = RL.lex(regexp)
-
-    a = tokens.first
-    assert_equal 'a',  a.text
-
-    plus = a.next
-    assert_equal '+',  plus.text
-
-    b = plus.next
-    assert_equal 'b',  b.text
-
-    interval = tokens.last
-    assert_equal '{2,3}',  interval.text
-
-    assert_equal nil,  interval.next
-  end
-
-  def test_token_previous
-    regexp = /a+b?c*d{2,3}/
-    tokens = RL.lex(regexp)
-
-    interval = tokens.last
-    assert_equal '{2,3}',  interval.text
-
-    d = interval.previous
-    assert_equal 'd',  d.text
-
-    star = d.previous
-    assert_equal '*',  star.text
-
-    c = star.previous
-    assert_equal 'c',  c.text
-
-    a = tokens.first
-    assert_equal 'a',  a.text
-    assert_equal nil,  a.previous
-  end
-
-end