regexp_parser 0.4.13 → 0.5.0

data/lib/regexp_parser/syntax/version_lookup.rb

@@ -0,0 +1,82 @@
+module Regexp::Syntax
+  VERSION_FORMAT = '\Aruby/\d+\.\d+(\.\d+)?\z'
+  VERSION_REGEXP = /#{VERSION_FORMAT}/
+  VERSION_CONST_REGEXP = /\AV\d+_\d+(?:_\d+)?\z/
+
+  class InvalidVersionNameError < SyntaxError
+    def initialize(name)
+      super "Invalid version name '#{name}'. Expected format is '#{VERSION_FORMAT}'"
+    end
+  end
+
+  class UnknownSyntaxNameError < SyntaxError
+    def initialize(name)
+      super "Unknown syntax name '#{name}'."
+    end
+  end
+
+  module_function
+
+  # Loads and instantiates an instance of the syntax specification class for
+  # the given syntax version name. The special names 'any' and '*' return an
+  # instance of Syntax::Any.
+  def new(name)
+    return Regexp::Syntax::Any.new if ['*', 'any'].include?(name.to_s)
+    version_class(name).new
+  end
+
+  def supported?(name)
+    name =~ VERSION_REGEXP &&
+      comparable_version(name) >= comparable_version('1.8.6')
+  end
+
+  def version_class(version)
+    version =~ VERSION_REGEXP || raise(InvalidVersionNameError, version)
+    version_const_name = version_const_name(version)
+    const_get(version_const_name) || raise(UnknownSyntaxNameError, version)
+  end
+
+  def version_const_name(version_string)
+    "V#{version_string.to_s.scan(/\d+/).join('_')}"
+  end
+
+  def const_missing(const_name)
+    if const_name =~ VERSION_CONST_REGEXP
+      return fallback_version_class(const_name)
+    end
+    super
+  end
+
+  def fallback_version_class(version)
+    sorted_versions = (specified_versions + [version])
+                      .sort_by { |name| comparable_version(name) }
+    return if (version_index = sorted_versions.index(version)) < 1
+
+    next_lower_version = sorted_versions[version_index - 1]
+    inherit_from_version(next_lower_version, version)
+  end
+
+  def inherit_from_version(parent_version, new_version)
+    new_const = version_const_name(new_version)
+    parent = const_get(version_const_name(parent_version))
+    const_defined?(new_const) || const_set(new_const, Class.new(parent))
+    warn_if_future_version(new_const)
+    const_get(new_const)
+  end
+
+  def specified_versions
+    constants.select { |const_name| const_name =~ VERSION_CONST_REGEXP }
+  end
+
+  def comparable_version(name)
+    # add .99 to treat versions without a patch value as latest patch version
+    Gem::Version.new((name.to_s.scan(/\d+/) << 99).join('.'))
+  end
+
+  def warn_if_future_version(const_name)
+    return if comparable_version(const_name) < comparable_version('3.0.0')
+
+    warn('This library has only been tested up to Ruby 2.x, '\
+         "but you are running with #{const_get(const_name).inspect}")
+  end
+end

data/lib/regexp_parser/syntax/versions.rb

@@ -3,8 +3,4 @@
 #
 # Aliases for the latest patch version are provided as 'ruby/n.n',
 # e.g. 'ruby/1.9' refers to Ruby v1.9.3.
-module Regexp::Syntax
-  version_file_paths = Dir[File.expand_path('../ruby/*.rb', __FILE__)]
-  version_file_paths.each { |path| require path }
-  VERSIONS = version_file_paths.map { |path| path[%r{(ruby/[^/]+)\.rb}, 1] }
-end
+Dir[File.expand_path('../versions/*.rb', __FILE__)].sort.each { |f| require f }

data/lib/regexp_parser/syntax/versions/1.8.6.rb

@@ -0,0 +1,30 @@
+module Regexp::Syntax
+  class V1_8_6 < Regexp::Syntax::Base
+    def initialize
+      super
+
+      implements :anchor, Anchor::All
+      implements :assertion, Assertion::Lookahead
+      implements :backref, [:number]
+
+      implements :escape,
+        Escape::Basic + Escape::Backreference +
+        Escape::ASCII + Escape::Meta + Escape::Control
+
+      implements :group, Group::All
+
+      implements :meta, Meta::Extended
+
+      implements :quantifier,
+        Quantifier::Greedy + Quantifier::Reluctant +
+        Quantifier::Interval + Quantifier::IntervalReluctant
+
+      implements :set, CharacterSet::OpenClose +
+        CharacterSet::Extended + CharacterSet::Types +
+        CharacterSet::POSIX::Standard
+
+      implements :type,
+        CharacterType::Extended
+    end
+  end
+end

data/lib/regexp_parser/syntax/versions/1.9.1.rb

@@ -0,0 +1,36 @@
+module Regexp::Syntax
+  class V1_9_1 < Regexp::Syntax::V1_8_6
+    def initialize
+      super
+
+      implements :assertion, Assertion::Lookbehind +
+        SubexpressionCall::All
+
+      implements :backref, Backreference::All +
+        SubexpressionCall::All
+
+      implements :escape, Escape::Unicode + Escape::Hex + Escape::Octal
+
+      implements :type, CharacterType::Hex
+
+      implements :property,
+        UnicodeProperty::V1_9_0
+
+      implements :nonproperty,
+        UnicodeProperty::V1_9_0
+
+      implements :quantifier,
+        Quantifier::Possessive + Quantifier::IntervalPossessive
+
+      implements :set,
+        CharacterSet::POSIX::StandardNegative +
+        CharacterSet::POSIX::Extensions +
+        CharacterSet::POSIX::ExtensionsNegative +
+        UnicodeProperty::V1_9_0
+
+      implements :subset, CharacterSet::OpenClose +
+        CharacterSet::Extended + CharacterSet::Types +
+        CharacterSet::POSIX::Standard
+    end
+  end
+end

data/lib/regexp_parser/syntax/versions/1.9.3.rb

@@ -0,0 +1,11 @@
+module Regexp::Syntax
+  class V1_9_3 < Regexp::Syntax::V1_9_1
+    def initialize
+      super
+
+      # these were added with update of Oniguruma to Unicode 6.0
+      implements :property,    UnicodeProperty::V1_9_3
+      implements :nonproperty, UnicodeProperty::V1_9_3
+    end
+  end
+end

data/lib/regexp_parser/syntax/versions/2.0.0.rb

@@ -0,0 +1,20 @@
+module Regexp::Syntax
+  # use the last 1.9 release as the base
+  class V2_0_0 < Regexp::Syntax::V1_9
+    def initialize
+      super
+
+      implements :keep,        Keep::All
+      implements :conditional, Conditional::All
+      implements :property,    UnicodeProperty::V2_0_0
+      implements :nonproperty, UnicodeProperty::V2_0_0
+
+      implements :type,        CharacterType::Clustered
+      implements :set,         CharacterSet::Clustered
+      implements :subset,      CharacterSet::Clustered
+
+      excludes   :property,    :newline
+      excludes   :nonproperty, :newline
+    end
+  end
+end

data/lib/regexp_parser/syntax/versions/2.2.0.rb

@@ -0,0 +1,10 @@
+module Regexp::Syntax
+  class V2_2_0 < Regexp::Syntax::V2_1
+    def initialize
+      super
+
+      implements :property,    UnicodeProperty::V2_2_0
+      implements :nonproperty, UnicodeProperty::V2_2_0
+    end
+  end
+end

data/lib/regexp_parser/syntax/versions/2.3.0.rb

@@ -0,0 +1,10 @@
+module Regexp::Syntax
+  class V2_3_0 < Regexp::Syntax::V2_2
+    def initialize
+      super
+
+      implements :property,    UnicodeProperty::V2_3_0
+      implements :nonproperty, UnicodeProperty::V2_3_0
+    end
+  end
+end

data/lib/regexp_parser/syntax/versions/2.4.0.rb

@@ -0,0 +1,10 @@
+module Regexp::Syntax
+  class V2_4_0 < Regexp::Syntax::V2_3
+    def initialize
+      super
+
+      implements :property,    UnicodeProperty::V2_4_0
+      implements :nonproperty, UnicodeProperty::V2_4_0
+    end
+  end
+end

data/lib/regexp_parser/syntax/versions/2.4.1.rb

@@ -0,0 +1,9 @@
+module Regexp::Syntax
+  class V2_4_1 < Regexp::Syntax::V2_4_0
+    def initialize
+      super
+
+      implements :group, Group::Absence
+    end
+  end
+end

data/lib/regexp_parser/syntax/versions/2.5.0.rb

@@ -0,0 +1,10 @@
+module Regexp::Syntax
+  class V2_5_0 < Regexp::Syntax::V2_4
+    def initialize
+      super
+
+      implements :property,    UnicodeProperty::V2_5_0
+      implements :nonproperty, UnicodeProperty::V2_5_0
+    end
+  end
+end

data/lib/regexp_parser/token.rb

@@ -12,45 +12,22 @@ class Regexp
   ].freeze
 
   Token = Struct.new(*TOKEN_KEYS) do
-    def initialize(*)
-      super
-
-      @previous = @next = nil
-    end
+    attr_accessor :previous, :next
 
     def offset
-      [self.ts, self.te]
+      [ts, te]
     end
 
     def length
-      self.te - self.ts
-    end
-
-    def next(exp = nil)
-      if exp
-        @next = exp
-      else
-        @next
-      end
-    end
-
-    def previous(exp = nil)
-      if exp
-        @previous = exp
-      else
-        @previous
-      end
+      te - ts
     end
 
     if RUBY_VERSION < '2.0.0'
       def to_h
-        hash = {}
-
-        members.each do |member|
-          hash[member.to_sym] = self.send(member.to_sym)
+        members.inject({}) do |hash, member|
+          hash[member.to_sym] = self[member]
+          hash
         end
-
-        hash
       end
     end
   end

data/lib/regexp_parser/version.rb

@@ -1,5 +1,5 @@
 class Regexp
   class Parser
-    VERSION = '0.4.13'
+    VERSION = '0.5.0'
   end
 end

data/test/expression/test_strfregexp.rb

@@ -167,6 +167,13 @@ class Expressionstrfregexp < Test::Unit::TestCase
     assert_equal root.strfregexp('%m %t'), root.strfregexp('%a')
   end
 
+  # regression test
+  def test_expression_strfregexp_conditional
+    root = RP.parse('(?<A>a)(?(<A>)b|c)', 'ruby/2.0')
+
+    assert_nothing_raised { root.strfregexp }
+  end
+
   def test_expression_strfregexp_tree
     root = RP.parse(/a[b-d]*(e(f+))?/)
 

data/test/expression/test_to_h.rb

@@ -50,4 +50,10 @@ class ExpressionToH < Test::Unit::TestCase
     }
   end
 
+  # regression test
+  def test_conditional_expression_to_h
+    root = RP.parse('(?<A>a)(?(<A>)b|c)', 'ruby/2.0')
+
+    assert_nothing_raised { root.to_h }
+  end
 end

data/test/parser/test_properties.rb

@@ -20,8 +20,6 @@ class ParserProperties < Test::Unit::TestCase
     'Xdigit',
     'XPosixPunct',
 
-    'Newline',
-
     'Any',
     'Assigned',
 
@@ -368,14 +366,14 @@ class ParserProperties < Test::Unit::TestCase
            "Expected Script property, but got #{t.expressions[1].class.name}"
   end
 
-  def test_parse_property_script_v193
+  def test_parse_property_script_V1_9_3
     t = RP.parse 'ab\p{Brahmi}cd', 'ruby/1.9.3'
 
     assert t.expressions[1].is_a?(UnicodeProperty::Script),
            "Expected Script property, but got #{t.expressions[1].class.name}"
   end
 
-  def test_parse_property_script_v220
+  def test_parse_property_script_V2_2_0
     t = RP.parse 'ab\p{Caucasian_Albanian}cd', 'ruby/2.2'
 
     assert t.expressions[1].is_a?(UnicodeProperty::Script),
@@ -395,4 +393,14 @@ class ParserProperties < Test::Unit::TestCase
     assert t.expressions[2].is_a?(Literal),
            "Expected Literal, but got #{t.expressions[2].class.name}"
   end
+
+  def test_parse_abandoned_newline_property
+    t = RP.parse '\p{newline}', 'ruby/1.9'
+    assert t.expressions.last.is_a?(UnicodeProperty::Base),
+           "Expected property, but got #{t.expressions.last.class.name}"
+
+    assert_raise(Regexp::Syntax::NotImplementedError) {
+      RP.parse('\p{newline}', 'ruby/2.0')
+    }
+  end
 end

data/test/support/warning_extractor.rb

@@ -22,7 +22,9 @@ module RegexpParserTest
 
         yield
 
-        assert_no_warnings($stderr.warnings)
+        if Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2.0.0')
+          assert_no_warnings($stderr.warnings)
+        end
       ensure
         $stderr = original
       end

data/test/syntax/test_all.rb

@@ -1,4 +1,4 @@
 require File.expand_path("../../helpers", __FILE__)
 
 require File.expand_path("../test_syntax", __FILE__)
-require File.expand_path("../ruby/test_all", __FILE__)
+require File.expand_path("../versions/test_all", __FILE__)

data/test/syntax/test_syntax.rb

@@ -9,7 +9,7 @@ class TestSyntax < Test::Unit::TestCase
   end
 
   def test_syntax_new
-    assert_instance_of Regexp::Syntax::Ruby::V193,
+    assert_instance_of Regexp::Syntax::V1_9_3,
                        Regexp::Syntax.new('ruby/1.9.3')
   end
 
@@ -23,10 +23,6 @@ class TestSyntax < Test::Unit::TestCase
     assert_equal false, Regexp::Syntax.supported?('ruby/1.1.1')
     assert_equal true, Regexp::Syntax.supported?('ruby/2.4.3')
     assert_equal true, Regexp::Syntax.supported?('ruby/2.5')
-
-    Regexp::Syntax::VERSIONS.each do |version|
-      assert_equal true, Regexp::Syntax.supported?(version)
-    end
   end
 
   def test_syntax_invalid_version
@@ -40,18 +36,18 @@ class TestSyntax < Test::Unit::TestCase
   end
 
   def test_syntax_version_class_tiny_version
-    assert_equal Regexp::Syntax::Ruby::V193,
+    assert_equal Regexp::Syntax::V1_9_3,
                  Regexp::Syntax.version_class('ruby/1.9.3')
 
-    assert_equal Regexp::Syntax::Ruby::V231,
+    assert_equal Regexp::Syntax::V2_3_1,
                  Regexp::Syntax.version_class('ruby/2.3.1')
   end
 
   def test_syntax_version_class_minor_version
-    assert_equal Regexp::Syntax::Ruby::V19,
+    assert_equal Regexp::Syntax::V1_9,
                  Regexp::Syntax.version_class('ruby/1.9')
 
-    assert_equal Regexp::Syntax::Ruby::V23,
+    assert_equal Regexp::Syntax::V2_3,
                  Regexp::Syntax.version_class('ruby/2.3')
   end
 

data/test/syntax/{ruby → versions}/test_1.8.rb

@@ -1,6 +1,6 @@
 require File.expand_path("../../../helpers", __FILE__)
 
-class TestSyntaxRuby_V18 < Test::Unit::TestCase
+class TestSyntaxV1_8 < Test::Unit::TestCase
   include Regexp::Syntax::Token
 
   def setup
@@ -8,29 +8,29 @@ class TestSyntaxRuby_V18 < Test::Unit::TestCase
   end
 
   tests = {
-    :implements => {
-      :assertion    => [Assertion::Lookahead].flatten,
-      :backref      => [:number],
-      :escape       => [Escape::All].flatten,
-      :group        => [Group::All].flatten,
-      :quantifier   => [
+    implements: {
+      assertion:    [Assertion::Lookahead].flatten,
+      backref:      [:number],
+      escape:       [Escape::All].flatten,
+      group:        [Group::All].flatten,
+      quantifier:   [
           Quantifier::Greedy + Quantifier::Reluctant +
           Quantifier::Interval + Quantifier::IntervalReluctant
       ].flatten,
     },
 
-    :excludes => {
-      :assertion    => [Assertion::Lookbehind].flatten,
+    excludes: {
+      assertion: [Assertion::Lookbehind].flatten,
 
-      :backref => [
+      backref: [
         Backreference::All - [:number] + SubexpressionCall::All
       ].flatten,
 
-      :quantifier => [
+      quantifier: [
         Quantifier::Possessive
       ].flatten,
 
-      :subset => nil
+      subset: nil
     },
   }
 
@@ -39,12 +39,12 @@ class TestSyntaxRuby_V18 < Test::Unit::TestCase
 
     types.each do |type, tokens|
       if tokens.nil? or tokens.empty?
-        define_method "test_syntax_ruby_v18_#{method}_#{type}" do
+        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_ruby_v18_#{method}_#{type}_#{token}" do
+          define_method "test_syntax_V1_8_#{method}_#{type}_#{token}" do
             assert_equal expected, @syntax.implements?(type, token)
           end
         end