regexp_parser 0.3.6 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8da248406d9077139763f419cc18d846dc9f9f62
-  data.tar.gz: 24a0dd00c5a9e4bddfc9188d1c70ccaf4ec599b5
+  metadata.gz: 64caf66c58a7f537eb616c36ebe39525c9977a42
+  data.tar.gz: abfa9f49bd37d2f03ad790244dfebf0ed6a2e6de
 SHA512:
-  metadata.gz: 4feff69d68352e80320d745b9e0162682c15646f7747236b65a7d5cc2f8a82678083449cbb053a8e28f4df57f9bd0974c7c2715d0d7fb6c280acbe49945b9c4c
-  data.tar.gz: 5f52cbf231bbf43241526579310a20f2c394b7090f07ffbb5181114f3c2179dce9bb1857743d231dee12d90cb7e699a48c1d0e6df56987b34683e72de7b8bce9
+  metadata.gz: 96b55ce29f554b59027180962f26ce6b02725142495cbd637eec47f24c7f6866f5ba676105f5f1d689c8f35fe6923e3110032737642a3bf3b92a7277b23b4ab9
+  data.tar.gz: edf5a0c7288a929318ce0c9451d934a992ab794fc8baf0e4ded0ad3761a65a6a8127485378033c1bdefa0447b7d07363b0dea7949a4c306495e736dabc1532aa

data/ChangeLog

@@ -1,3 +1,9 @@
+Sun Nov 20 2016 Ammar Ali <ammarabuali@gmail.com>
+
+	* Added Syntax.supported? method
+	* Updated ruby versions for latest releases; 2.1.10, 2.2.6, and 2.3.2
+	* Bumped version to 0.4.0
+
 Wed Jun 8 2016 Ammar Ali <ammarabuali@gmail.com>
 
 	* Thanks to John Backus (https://github.com/backus):

data/lib/regexp_parser/syntax.rb

@@ -1,7 +1,13 @@
 require File.expand_path('../syntax/tokens', __FILE__)
+require File.expand_path('../syntax/base', __FILE__)
+require File.expand_path('../syntax/any', __FILE__)
+require File.expand_path('../syntax/versions', __FILE__)
 
 module Regexp::Syntax
 
+  VERSION_FORMAT = '\Aruby/\d+\.\d+(\.\d+)?\z'
+  VERSION_REGEXP = /#{VERSION_FORMAT}/
+
   class SyntaxError < StandardError
     def initialize(what)
       super what
@@ -14,205 +20,41 @@ module Regexp::Syntax
     end
   end
 
-  class MissingSyntaxSpecError < SyntaxError
+  class InvalidVersionNameError < SyntaxError
     def initialize(name)
-      super "Missing syntax specification file for '#{name}'"
+      super "Invalid version name '#{name}'. Expected format is '#{VERSION_FORMAT}'"
     end
   end
 
-  class NotImplementedError < SyntaxError
-    def initialize(syntax, type, token)
-      super "#{syntax.class.name} does not implement: [#{type}:#{token}]"
-    end
-  end
-
-  SYNTAX_SPEC_ROOT = File.expand_path('../syntax', __FILE__)
-
-  # Loads, and instantiates an instance of the syntax specification class for
-  # the given syntax flavor name. The special names 'any' and '*' returns a
-  # instance of Syntax::Any. See below for more details.
+  # 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 self.new(name)
     return Regexp::Syntax::Any.new if
       ['*', 'any'].include?( name.to_s )
 
-    self.load(name)
-    self.instantiate(name)
-  end
-
-  def self.instantiate(name)
-    case name
-      # Ruby 1.8.x (NOTE: 1.8.6 is no longer a supported runtime,
-      # but its regex features are still recognized.)
-      when 'ruby/1.8.6';  syntax = Regexp::Syntax::Ruby::V186.new
-      when 'ruby/1.8.7';  syntax = Regexp::Syntax::Ruby::V187.new
-
-      # alias for the latest 1.8 implementation
-      when 'ruby/1.8';    syntax = Regexp::Syntax::Ruby::V18.new
-
-      # Ruby 1.9.x
-      when 'ruby/1.9.1';  syntax = Regexp::Syntax::Ruby::V191.new
-      when 'ruby/1.9.2';  syntax = Regexp::Syntax::Ruby::V192.new
-      when 'ruby/1.9.3';  syntax = Regexp::Syntax::Ruby::V193.new
-
-      # alias for the latest 1.9 implementation
-      when 'ruby/1.9';    syntax = Regexp::Syntax::Ruby::V19.new
+    raise UnknownSyntaxNameError.new(name) unless supported?(name)
 
-      # Ruby 2.0.x
-      when 'ruby/2.0.0';  syntax = Regexp::Syntax::Ruby::V200.new
-
-      # aliases for the latest 2.0 implementations
-      when 'ruby/2.0';    syntax = Regexp::Syntax::Ruby::V20.new
-
-      # Ruby 2.1.x
-      when 'ruby/2.1.0';  syntax = Regexp::Syntax::Ruby::V210.new
-      when 'ruby/2.1.2';  syntax = Regexp::Syntax::Ruby::V212.new
-      when 'ruby/2.1.3';  syntax = Regexp::Syntax::Ruby::V213.new
-      when 'ruby/2.1.4';  syntax = Regexp::Syntax::Ruby::V214.new
-      when 'ruby/2.1.5';  syntax = Regexp::Syntax::Ruby::V215.new
-      when 'ruby/2.1.6';  syntax = Regexp::Syntax::Ruby::V216.new
-      when 'ruby/2.1.7';  syntax = Regexp::Syntax::Ruby::V217.new
-      when 'ruby/2.1.8';  syntax = Regexp::Syntax::Ruby::V218.new
-      when 'ruby/2.1.9';  syntax = Regexp::Syntax::Ruby::V219.new
-
-      # aliases for the latest 2.1 implementations
-      when 'ruby/2.1';    syntax = Regexp::Syntax::Ruby::V21.new
-
-      # Ruby 2.2.x
-      when 'ruby/2.2.0';  syntax = Regexp::Syntax::Ruby::V220.new
-      when 'ruby/2.2.1';  syntax = Regexp::Syntax::Ruby::V221.new
-      when 'ruby/2.2.2';  syntax = Regexp::Syntax::Ruby::V222.new
-      when 'ruby/2.2.3';  syntax = Regexp::Syntax::Ruby::V223.new
-      when 'ruby/2.2.4';  syntax = Regexp::Syntax::Ruby::V224.new
-      when 'ruby/2.2.5';  syntax = Regexp::Syntax::Ruby::V225.new
-
-      # aliases for the latest 2.2 implementations
-      when 'ruby/2.2';    syntax = Regexp::Syntax::Ruby::V22.new
-
-      # Ruby 2.3.x
-      when 'ruby/2.3.0';  syntax = Regexp::Syntax::Ruby::V230.new
-      when 'ruby/2.3.1';  syntax = Regexp::Syntax::Ruby::V231.new
-
-      # alias for the latest 2.3 implementation
-      when 'ruby/2.3';    syntax = Regexp::Syntax::Ruby::V23.new
-
-      else
-        raise UnknownSyntaxNameError.new(name)
-    end
+    version_class(name).new
   end
 
-  # Checks if the named syntax has a specification class file, and requires
-  # it if it does. Downcases names, and adds the .rb extension if omitted.
-  def self.load(name)
-    full = "#{SYNTAX_SPEC_ROOT}/#{name.downcase}"
-    full = (full[-1, 3] == '.rb') ? full : "#{full}.rb"
-
-    raise MissingSyntaxSpecError.new(name) unless File.exist?(full)
-    require full
+  def self.supported?(name)
+    VERSIONS.include?(name)
   end
 
-  # A lookup map of supported types and tokens in a given syntax
-  class Base
-    def initialize
-      @implements = {}
+  def self.version_class(version)
+    raise InvalidVersionNameError.new(version) unless
+      version =~ VERSION_REGEXP
 
-      implements Token::Literal::Type,   Token::Literal::All
-      implements Token::FreeSpace::Type, Token::FreeSpace::All
-    end
-
-    def implementation
-      @implements
-    end
-
-    def implements(type, tokens)
-      if @implements[type]
-        @implements[type] = (@implements[type] + tokens).uniq
-      else
-        @implements[type] = tokens
-      end
-    end
+    version_const_name = version.scan(/\d+/).join
 
-    # removes
-    def excludes(type, tokens)
-      if tokens
-        tokens = [tokens] unless tokens.is_a?(Array)
-      end
+    const_name = "Regexp::Syntax::Ruby::V#{version_const_name}"
 
-      if @implements[type]
-        if tokens
-          @implements[type] = @implements[type] - tokens
-          @implements[type] = nil if @implements[type].empty?
-        else
-          @implements[type] = nil
-        end
-      end
+    if RUBY_VERSION >= '2.0.0'
+      Kernel.const_get(const_name)
+    else
+      Object.module_eval(const_name, __FILE__, __LINE__)
     end
-
-    def implements?(type, token)
-      return true if @implements[type] and @implements[type].include?(token)
-      false
-    end
-    alias :check? :implements?
-
-    def implements!(type, token)
-      raise NotImplementedError.new(self, type, token) unless
-        implements?(type, token)
-    end
-    alias :check! :implements!
-
-    def normalize(type, token)
-      case type
-      when :group
-        normalize_group(type, token)
-      when :backref
-        normalize_backref(type, token)
-      else
-        [type, token]
-      end
-    end
-
-    def normalize_group(type, token)
-      case token
-      when :named_ab, :named_sq
-        [:group, :named]
-      else
-        [type, token]
-      end
-    end
-
-    def normalize_backref(type, token)
-      case token
-      when :name_ref_ab, :name_ref_sq
-        [:backref, :name_ref]
-      when :name_call_ab, :name_call_sq
-        [:backref, :name_call]
-      when :name_nest_ref_ab, :name_nest_ref_sq
-        [:backref, :name_nest_ref]
-      when :number_ref_ab, :number_ref_sq
-        [:backref, :number_ref]
-      when :number_call_ab, :number_call_sq
-        [:backref, :number_call]
-      when :number_rel_ref_ab, :number_rel_ref_sq
-        [:backref, :number_rel_ref]
-      when :number_rel_call_ab, :number_rel_call_sq
-        [:backref, :number_rel_call]
-      when :number_nest_ref_ab, :number_nest_ref_sq
-        [:backref, :number_nest_ref]
-      else
-        [type, token]
-      end
-    end
-  end
-
-  # A syntax that always returns true, passing all tokens as implemented. This
-  # is useful during development, testing, and should be useful for some types
-  # of transformations as well.
-  class Any < Base
-    def initialize
-      @implements = { :* => [:*] }
-    end
-
-    def implements?(type, token) true end
-    def implements!(type, token) true end
   end
 
 end

data/lib/regexp_parser/syntax/any.rb

@@ -0,0 +1,15 @@
+module Regexp::Syntax
+
+  # A syntax that always returns true, passing all tokens as implemented. This
+  # is useful during development, testing, and should be useful for some types
+  # of transformations as well.
+  class Any < Base
+    def initialize
+      @implements = { :* => [:*] }
+    end
+
+    def implements?(type, token) true end
+    def implements!(type, token) true end
+  end
+
+end

data/lib/regexp_parser/syntax/base.rb

@@ -0,0 +1,102 @@
+module Regexp::Syntax
+
+  class NotImplementedError < SyntaxError
+    def initialize(syntax, type, token)
+      super "#{syntax.class.name} does not implement: [#{type}:#{token}]"
+    end
+  end
+
+  # A lookup map of supported types and tokens in a given syntax
+  class Base
+    def initialize
+      @implements = {}
+
+      implements Token::Literal::Type,   Token::Literal::All
+      implements Token::FreeSpace::Type, Token::FreeSpace::All
+    end
+
+    def implementation
+      @implements
+    end
+
+    def implements(type, tokens)
+      if @implements[type]
+        @implements[type] = (@implements[type] + tokens).uniq
+      else
+        @implements[type] = tokens
+      end
+    end
+
+    # removes
+    def excludes(type, tokens)
+      if tokens
+        tokens = [tokens] unless tokens.is_a?(Array)
+      end
+
+      if @implements[type]
+        if tokens
+          @implements[type] = @implements[type] - tokens
+          @implements[type] = nil if @implements[type].empty?
+        else
+          @implements[type] = nil
+        end
+      end
+    end
+
+    def implements?(type, token)
+      return true if @implements[type] and @implements[type].include?(token)
+      false
+    end
+    alias :check? :implements?
+
+    def implements!(type, token)
+      raise NotImplementedError.new(self, type, token) unless
+        implements?(type, token)
+    end
+    alias :check! :implements!
+
+    def normalize(type, token)
+      case type
+      when :group
+        normalize_group(type, token)
+      when :backref
+        normalize_backref(type, token)
+      else
+        [type, token]
+      end
+    end
+
+    def normalize_group(type, token)
+      case token
+      when :named_ab, :named_sq
+        [:group, :named]
+      else
+        [type, token]
+      end
+    end
+
+    def normalize_backref(type, token)
+      case token
+      when :name_ref_ab, :name_ref_sq
+        [:backref, :name_ref]
+      when :name_call_ab, :name_call_sq
+        [:backref, :name_call]
+      when :name_nest_ref_ab, :name_nest_ref_sq
+        [:backref, :name_nest_ref]
+      when :number_ref_ab, :number_ref_sq
+        [:backref, :number_ref]
+      when :number_call_ab, :number_call_sq
+        [:backref, :number_call]
+      when :number_rel_ref_ab, :number_rel_ref_sq
+        [:backref, :number_rel_ref]
+      when :number_rel_call_ab, :number_rel_call_sq
+        [:backref, :number_rel_call]
+      when :number_nest_ref_ab, :number_nest_ref_sq
+        [:backref, :number_nest_ref]
+      else
+        [type, token]
+      end
+    end
+  end
+
+end

data/lib/regexp_parser/syntax/ruby/2.1.10.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../2.1.9', __FILE__)
+
+module Regexp::Syntax
+  module Ruby
+
+    class V2110 < Regexp::Syntax::Ruby::V219
+      def initialize
+        super
+      end
+    end
+
+  end
+end

data/lib/regexp_parser/syntax/ruby/2.1.rb

@@ -1,8 +1,8 @@
-require File.expand_path('../2.1.9', __FILE__)
+require File.expand_path('../2.1.10', __FILE__)
 
 module Regexp::Syntax
   module Ruby
     # uses the latest 2.1 release
-    class V21 < Regexp::Syntax::Ruby::V219; end
+    class V21 < Regexp::Syntax::Ruby::V2110; end
   end
 end

data/lib/regexp_parser/syntax/ruby/2.2.6.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../2.2.5', __FILE__)
+
+module Regexp::Syntax
+  module Ruby
+
+    class V226 < Regexp::Syntax::Ruby::V225
+      def initialize
+        super
+      end
+    end
+
+  end
+end

data/lib/regexp_parser/syntax/ruby/2.2.rb

@@ -1,8 +1,8 @@
-require File.expand_path('../2.2.5', __FILE__)
+require File.expand_path('../2.2.6', __FILE__)
 
 module Regexp::Syntax
   module Ruby
     # uses the latest 2.2 release
-    class V22 < Regexp::Syntax::Ruby::V225; end
+    class V22 < Regexp::Syntax::Ruby::V226; end
   end
 end

data/lib/regexp_parser/syntax/ruby/2.3.2.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../2.3.1', __FILE__)
+
+module Regexp::Syntax
+  module Ruby
+
+    class V232 < Regexp::Syntax::Ruby::V231
+      def initialize
+        super
+      end
+    end
+
+  end
+end

data/lib/regexp_parser/syntax/ruby/2.3.rb

@@ -1,8 +1,8 @@
-require File.expand_path('../2.3.1', __FILE__)
+require File.expand_path('../2.3.2', __FILE__)
 
 module Regexp::Syntax
   module Ruby
     # uses the latest 2.3 release
-    class V23 < Regexp::Syntax::Ruby::V231; end
+    class V23 < Regexp::Syntax::Ruby::V232; end
   end
 end

data/lib/regexp_parser/syntax/versions.rb

@@ -0,0 +1,66 @@
+module Regexp::Syntax
+
+  VERSIONS = [
+    # Ruby 1.8.x (NOTE: 1.8.6 is no longer a supported runtime,
+    # but its regex features are still recognized.)
+    'ruby/1.8.6',
+    'ruby/1.8.7',
+
+    # alias for the latest 1.8 implementation
+    'ruby/1.8',
+
+    # Ruby 1.9.x
+    'ruby/1.9.1',
+    'ruby/1.9.2',
+    'ruby/1.9.3',
+
+    # alias for the latest 1.9 implementation
+    'ruby/1.9',
+
+    # Ruby 2.0.x
+    'ruby/2.0.0',
+
+    # alias for the latest 2.0 implementations
+    'ruby/2.0',
+
+    # Ruby 2.1.x
+    'ruby/2.1.0',
+    'ruby/2.1.2',
+    'ruby/2.1.3',
+    'ruby/2.1.4',
+    'ruby/2.1.5',
+    'ruby/2.1.6',
+    'ruby/2.1.7',
+    'ruby/2.1.8',
+    'ruby/2.1.9',
+    'ruby/2.1.10',
+
+    # alias for the latest 2.1 implementations
+    'ruby/2.1',
+
+    # Ruby 2.2.x
+    'ruby/2.2.0',
+    'ruby/2.2.1',
+    'ruby/2.2.2',
+    'ruby/2.2.3',
+    'ruby/2.2.4',
+    'ruby/2.2.5',
+    'ruby/2.2.6',
+
+    # alias for the latest 2.2 implementations
+    'ruby/2.2',
+
+    # Ruby 2.3.x
+    'ruby/2.3.0',
+    'ruby/2.3.1',
+    'ruby/2.3.2',
+
+    # alias for the latest 2.3 implementation
+    'ruby/2.3',
+  ]
+
+end
+
+Regexp::Syntax::VERSIONS.each do |version|
+  require File.expand_path("../#{version}", __FILE__)
+end

data/lib/regexp_parser/version.rb

@@ -1,5 +1,5 @@
 class Regexp
   module Parser
-    VERSION = '0.3.6'
+    VERSION = '0.4.0'
   end
 end

data/test/syntax/ruby/test_files.rb

@@ -118,10 +118,17 @@ class TestSyntaxFiles < Test::Unit::TestCase
     assert syntax.kind_of?(Regexp::Syntax::Ruby::V219)
   end
 
+  def test_syntax_file_2_1_10
+    syntax = Regexp::Syntax.new 'ruby/2.1.10'
+
+    assert syntax.kind_of?(Regexp::Syntax::Ruby::V219)
+    assert syntax.kind_of?(Regexp::Syntax::Ruby::V2110)
+  end
+
   def test_syntax_file_2_1_alias
     syntax = Regexp::Syntax.new 'ruby/2.1'
 
-    assert syntax.kind_of?(Regexp::Syntax::Ruby::V219)
+    assert syntax.kind_of?(Regexp::Syntax::Ruby::V2110)
   end
 
 
@@ -163,10 +170,17 @@ class TestSyntaxFiles < Test::Unit::TestCase
     assert syntax.kind_of?(Regexp::Syntax::Ruby::V225)
   end
 
+  def test_syntax_file_2_2_6
+    syntax = Regexp::Syntax.new 'ruby/2.2.6'
+
+    assert syntax.kind_of?(Regexp::Syntax::Ruby::V225)
+    assert syntax.kind_of?(Regexp::Syntax::Ruby::V226)
+  end
+
   def test_syntax_file_2_2_alias
     syntax = Regexp::Syntax.new 'ruby/2.2'
 
-    assert syntax.kind_of?(Regexp::Syntax::Ruby::V225)
+    assert syntax.kind_of?(Regexp::Syntax::Ruby::V226)
   end
 
   # 2.3 syntax files
@@ -184,9 +198,16 @@ class TestSyntaxFiles < Test::Unit::TestCase
     assert syntax.kind_of?(Regexp::Syntax::Ruby::V231)
   end
 
+  def test_syntax_file_2_3_2
+    syntax = Regexp::Syntax.new 'ruby/2.3.2'
+
+    assert syntax.kind_of?(Regexp::Syntax::Ruby::V231)
+    assert syntax.kind_of?(Regexp::Syntax::Ruby::V232)
+  end
+
   def test_syntax_file_2_3_alias
     syntax = Regexp::Syntax.new 'ruby/2.3'
 
-    assert syntax.kind_of?(Regexp::Syntax::Ruby::V231)
+    assert syntax.kind_of?(Regexp::Syntax::Ruby::V232)
   end
 end

data/test/syntax/test_all.rb

@@ -1,25 +1,4 @@
 require File.expand_path("../../helpers", __FILE__)
 
+require File.expand_path("../test_syntax", __FILE__)
 require File.expand_path("../ruby/test_all", __FILE__)
-
-class TestSyntax < Test::Unit::TestCase
-
-  def test_syntax_unknown_name
-    assert_raise( Regexp::Syntax::UnknownSyntaxNameError ) {
-      Regexp::Syntax.instantiate('ruby/1.0')
-    }
-  end
-
-  def test_syntax_missing_spec
-    assert_raise( Regexp::Syntax::MissingSyntaxSpecError ) {
-      RL.scan('abc', 'ruby/1.6')
-    }
-  end
-
-  def test_syntax_not_implemented
-    assert_raise( Regexp::Syntax::NotImplementedError ) {
-      RP.parse('\p{alpha}', 'ruby/1.8')
-    }
-  end
-
-end

data/test/syntax/test_syntax.rb

@@ -0,0 +1,56 @@
+require File.expand_path("../../helpers", __FILE__)
+
+class TestSyntax < Test::Unit::TestCase
+
+  def test_syntax_unknown_name
+    assert_raise( Regexp::Syntax::UnknownSyntaxNameError ) {
+      Regexp::Syntax.new('ruby/1.0')
+    }
+  end
+
+  def test_syntax_new
+    assert_instance_of Regexp::Syntax::Ruby::V193,
+                       Regexp::Syntax.new('ruby/1.9.3')
+  end
+
+  def test_syntax_not_implemented
+    assert_raise( Regexp::Syntax::NotImplementedError ) {
+      RP.parse('\p{alpha}', 'ruby/1.8')
+    }
+  end
+
+  def test_syntax_supported?
+    assert_equal false, Regexp::Syntax.supported?('ruby/1.1.1')
+
+    Regexp::Syntax::VERSIONS.each do |version|
+      assert_equal true, Regexp::Syntax.supported?(version)
+    end
+  end
+
+  def test_syntax_invalid_version
+    assert_raise( Regexp::Syntax::InvalidVersionNameError ) {
+      Regexp::Syntax.version_class('2.0.0')
+    }
+
+    assert_raise( Regexp::Syntax::InvalidVersionNameError ) {
+      Regexp::Syntax.version_class('ruby/20')
+    }
+  end
+
+  def test_syntax_version_class_tiny_version
+    assert_equal Regexp::Syntax::Ruby::V193,
+                 Regexp::Syntax.version_class('ruby/1.9.3')
+
+    assert_equal Regexp::Syntax::Ruby::V231,
+                 Regexp::Syntax.version_class('ruby/2.3.1')
+  end
+
+  def test_syntax_version_class_minor_version
+    assert_equal Regexp::Syntax::Ruby::V19,
+                 Regexp::Syntax.version_class('ruby/1.9')
+
+    assert_equal Regexp::Syntax::Ruby::V23,
+                 Regexp::Syntax.version_class('ruby/2.3')
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: regexp_parser
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.4.0
 platform: ruby
 authors:
 - Ammar Ali
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-08 00:00:00.000000000 Z
+date: 2016-11-20 00:00:00.000000000 Z
 dependencies: []
 description: A library for tokenizing, lexing, and parsing Ruby regular expressions.
 email:
@@ -49,6 +49,8 @@ files:
 - lib/regexp_parser/scanner/property.rl
 - lib/regexp_parser/scanner/scanner.rl
 - lib/regexp_parser/syntax.rb
+- lib/regexp_parser/syntax/any.rb
+- lib/regexp_parser/syntax/base.rb
 - lib/regexp_parser/syntax/ruby/1.8.6.rb
 - lib/regexp_parser/syntax/ruby/1.8.7.rb
 - lib/regexp_parser/syntax/ruby/1.8.rb
@@ -59,6 +61,7 @@ files:
 - lib/regexp_parser/syntax/ruby/2.0.0.rb
 - lib/regexp_parser/syntax/ruby/2.0.rb
 - lib/regexp_parser/syntax/ruby/2.1.0.rb
+- lib/regexp_parser/syntax/ruby/2.1.10.rb
 - lib/regexp_parser/syntax/ruby/2.1.2.rb
 - lib/regexp_parser/syntax/ruby/2.1.3.rb
 - lib/regexp_parser/syntax/ruby/2.1.4.rb
@@ -74,9 +77,11 @@ files:
 - lib/regexp_parser/syntax/ruby/2.2.3.rb
 - lib/regexp_parser/syntax/ruby/2.2.4.rb
 - lib/regexp_parser/syntax/ruby/2.2.5.rb
+- lib/regexp_parser/syntax/ruby/2.2.6.rb
 - lib/regexp_parser/syntax/ruby/2.2.rb
 - lib/regexp_parser/syntax/ruby/2.3.0.rb
 - lib/regexp_parser/syntax/ruby/2.3.1.rb
+- lib/regexp_parser/syntax/ruby/2.3.2.rb
 - lib/regexp_parser/syntax/ruby/2.3.rb
 - lib/regexp_parser/syntax/tokens.rb
 - lib/regexp_parser/syntax/tokens/anchor.rb
@@ -91,6 +96,7 @@ files:
 - 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/versions.rb
 - lib/regexp_parser/token.rb
 - lib/regexp_parser/version.rb
 - regexp_parser.gemspec
@@ -155,6 +161,7 @@ files:
 - test/syntax/ruby/test_all.rb
 - test/syntax/ruby/test_files.rb
 - test/syntax/test_all.rb
+- test/syntax/test_syntax.rb
 - test/test_all.rb
 - test/token/test_all.rb
 - test/token/test_token.rb
@@ -247,6 +254,7 @@ test_files:
 - test/syntax/ruby/test_all.rb
 - test/syntax/ruby/test_files.rb
 - test/syntax/test_all.rb
+- test/syntax/test_syntax.rb
 - test/test_all.rb
 - test/token/test_all.rb
 - test/token/test_token.rb