regexp_parser 0.4.13 → 0.5.0

data/lib/regexp_parser/scanner/scanner.rl

@@ -143,8 +143,8 @@
   }
 
   # group (nesting) and set open/close actions
-  action group_opened { @group_depth += 1; @in_group = true }
-  action group_closed { @group_depth -= 1; @in_group = @group_depth > 0 ? true : false }
+  action group_opened { self.group_depth = group_depth + 1; in_group = true }
+  action group_closed { self.group_depth = group_depth - 1; in_group = group_depth > 0 ? true : false }
 
   # Character set scanner, continues consuming characters until it meets the
   # closing bracket of the set.
@@ -179,7 +179,7 @@
 
     '^' {
       text = text(data, ts, te).first
-      if @tokens.last[1] == :open
+      if tokens.last[1] == :open
         emit(set_type, :negate, text, ts, te)
       else
         emit(set_type, :member, text, ts, te)
@@ -449,7 +449,7 @@
 
     alternation {
       if in_conditional and conditional_stack.length > 0 and
-         conditional_stack.last[1] == @group_depth
+         conditional_stack.last[1] == group_depth
         emit(:conditional, :separator, *text(data, ts, te))
       else
         emit(:meta, :alternation, *text(data, ts, te))
@@ -528,7 +528,7 @@
 
       in_conditional = true unless in_conditional
       conditional_depth += 1
-      conditional_stack << [conditional_depth, @group_depth]
+      conditional_stack << [conditional_depth, group_depth]
 
       emit(:conditional, :open, text[0..-2], ts, te-1)
       emit(:conditional, :condition_open, '(', te-1, te)
@@ -612,7 +612,7 @@
 
     group_close @group_closed {
       if in_conditional and conditional_stack.last and
-         conditional_stack.last[1] == (@group_depth + 1)
+         conditional_stack.last[1] == (group_depth + 1)
 
         emit(:conditional, :close, *text(data, ts, te))
         conditional_stack.pop
@@ -621,11 +621,11 @@
           in_conditional = false
         end
       else
-        if @spacing_stack.length > 1 and
-          @spacing_stack.last[:depth] == (@group_depth + 1)
-          @spacing_stack.pop
+        if spacing_stack.length > 1 and
+          spacing_stack.last[:depth] == (group_depth + 1)
+          spacing_stack.pop
 
-          @free_spacing = @spacing_stack.last[:free_spacing]
+          self.free_spacing = spacing_stack.last[:free_spacing]
         end
 
         emit(:group, :close, *text(data, ts, te))
@@ -741,7 +741,7 @@
     };
 
     comment {
-      if @free_spacing
+      if free_spacing
         emit(:free_space, :comment, *text(data, ts, te))
       else
         append_literal(data, ts, te)
@@ -749,7 +749,7 @@
     };
 
     space+ {
-      if @free_spacing
+      if free_spacing
         emit(:free_space, :whitespace, *text(data, ts, te))
       else
         append_literal(data, ts, te)
@@ -837,27 +837,29 @@ class Regexp::Scanner
   end
 
   def scan(input_object, &block)
-    @literal, stack = nil, []
+    self.literal = nil
+    stack = []
 
     if input_object.is_a?(Regexp)
-      input    = input_object.source
-      @free_spacing  = (input_object.options & Regexp::EXTENDED != 0)
+      input = input_object.source
+      self.free_spacing = (input_object.options & Regexp::EXTENDED != 0)
     else
-      input   = input_object
-      @free_spacing = false
+      input = input_object
+      self.free_spacing = false
     end
 
 
     data  = input.unpack("c*") if input.is_a?(String)
     eof   = data.length
 
-    @tokens = []
-    @block  = block_given? ? block : nil
+    self.tokens = []
+    self.block  = block_given? ? block : nil
 
-    @in_group, @group_depth = false, 0
-    @spacing_stack = [{:free_spacing => @free_spacing, :depth => 0}]
+    self.in_group = false
+    self.group_depth = 0
+    self.spacing_stack = [{:free_spacing => free_spacing, :depth => 0}]
 
-    in_set,   set_depth, set_type   = false, 0, :set
+    in_set, set_depth, set_type = false, 0, :set
     in_conditional, conditional_depth, conditional_stack = false, 0, []
 
     %% write data;
@@ -870,31 +872,35 @@ class Regexp::Scanner
     end
 
     raise PrematureEndError.new("(missing group closing paranthesis) "+
-          "[#{@in_group}:#{@group_depth}]") if @in_group
+          "[#{in_group}:#{group_depth}]") if in_group
     raise PrematureEndError.new("(missing set closing bracket) "+
           "[#{in_set}:#{set_depth}]") if in_set
 
     # when the entire expression is a literal run
-    emit_literal if @literal
+    emit_literal if literal
 
-    @tokens
+    tokens
   end
 
   # Emits an array with the details of the scanned pattern
   def emit(type, token, text, ts, te)
     #puts "EMIT: type: #{type}, token: #{token}, text: #{text}, ts: #{ts}, te: #{te}"
 
-    emit_literal if @literal
+    emit_literal if literal
 
-    if @block
-      @block.call type, token, text, ts, te
+    if block
+      block.call type, token, text, ts, te
     end
 
-    @tokens << [type, token, text, ts, te]
+    tokens << [type, token, text, ts, te]
   end
 
   private
 
+  attr_accessor :tokens, :literal, :block,
+                :in_group, :group_depth,
+                :free_spacing, :spacing_stack
+
   # Ragel's regex-based scan of the group options introduced a lot of
   # ambiguity, so we just ask it to find the beginning of what looks
   # like an options run and handle the rest in here.
@@ -963,19 +969,19 @@ class Regexp::Scanner
   # Appends one or more characters to the literal buffer, to be emitted later
   # by a call to emit_literal. Contents can be a mix of ASCII and UTF-8.
   def append_literal(data, ts, te)
-    @literal ||= []
-    @literal << text(data, ts, te)
+    self.literal = literal || []
+    literal << text(data, ts, te)
   end
 
   # Emits the literal run collected by calls to the append_literal method,
   # using the total start (ts) and end (te) offsets of the run.
   def emit_literal
-    ts, te = @literal.first[1], @literal.last[2]
-    text = @literal.map {|t| t[0]}.join
+    ts, te = literal.first[1], literal.last[2]
+    text = literal.map {|t| t[0]}.join
 
     text.force_encoding('utf-8') if text.respond_to?(:force_encoding)
 
-    @literal = nil
+    self.literal = nil
     emit(:literal, :literal, text, ts, te)
   end
 
@@ -984,20 +990,20 @@ class Regexp::Scanner
       positive, negative, group_local = $1, $2, $3
 
       if positive.include?('x')
-        @free_spacing = true
+        self.free_spacing = true
       end
 
       # If the x appears in both, treat it like ruby does, the second cancels
       # the first.
       if negative.include?('x')
-        @free_spacing = false
+        self.free_spacing = false
       end
 
       if group_local
-        @spacing_stack << {:free_spacing => @free_spacing, :depth => @group_depth}
+        spacing_stack << {:free_spacing => free_spacing, :depth => group_depth}
       else
         # switch for parent group level
-        @spacing_stack.last[:free_spacing] = @free_spacing
+        spacing_stack.last[:free_spacing] = free_spacing
       end
     end
 

data/lib/regexp_parser/syntax.rb

@@ -1,60 +1,9 @@
 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/version_lookup', __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
-    end
-  end
-
-  class UnknownSyntaxNameError < SyntaxError
-    def initialize(name)
-      super "Unknown syntax name '#{name}'."
-    end
-  end
-
-  class InvalidVersionNameError < SyntaxError
-    def initialize(name)
-      super "Invalid version name '#{name}'. Expected format is '#{VERSION_FORMAT}'"
-    end
-  end
-
-  # 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 )
-
-    raise UnknownSyntaxNameError.new(name) unless supported?(name)
-
-    version_class(name).new
-  end
-
-  def self.supported?(name)
-    VERSIONS.include?(name)
-  end
-
-  def self.version_class(version)
-    raise InvalidVersionNameError.new(version) unless
-      version =~ VERSION_REGEXP
-
-    version_const_name = version.scan(/\d+/).join
-
-    const_name = "Regexp::Syntax::Ruby::V#{version_const_name}"
-
-    if RUBY_VERSION >= '2.0.0'
-      Kernel.const_get(const_name)
-    else
-      Object.module_eval(const_name, __FILE__, __LINE__)
-    end
-  end
-
+  class SyntaxError < StandardError; end
 end

data/lib/regexp_parser/syntax/base.rb

@@ -1,5 +1,6 @@
-module Regexp::Syntax
+require 'set'
 
+module Regexp::Syntax
   class NotImplementedError < SyntaxError
     def initialize(syntax, type, token)
       super "#{syntax.class.name} does not implement: [#{type}:#{token}]"
@@ -8,6 +9,8 @@ module Regexp::Syntax
 
   # A lookup map of supported types and tokens in a given syntax
   class Base
+    include Regexp::Syntax::Token
+
     def initialize
       @implements = {}
 
@@ -15,37 +18,20 @@ module Regexp::Syntax
       implements Token::FreeSpace::Type, Token::FreeSpace::All
     end
 
-    def implementation
-      @implements
+    def implementations(type)
+      @implements[type] ||= Set.new
     end
 
     def implements(type, tokens)
-      if @implements[type]
-        @implements[type] = (@implements[type] + tokens).uniq
-      else
-        @implements[type] = tokens
-      end
+      implementations(type).merge(Array(tokens))
     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
+      implementations(type).subtract(Array(tokens))
     end
 
     def implements?(type, token)
-      return true if @implements[type] and @implements[type].include?(token)
-      false
+      implementations(type).include?(token)
     end
     alias :check? :implements?
 
@@ -97,6 +83,9 @@ module Regexp::Syntax
         [type, token]
       end
     end
-  end
 
+    def self.inspect
+      "#{super} (feature set of #{ancestors[1].to_s.split('::').last})"
+    end
+  end
 end

data/lib/regexp_parser/syntax/tokens/character_class.rb

@@ -0,0 +1,16 @@
+module Regexp::Syntax
+  module Token
+    module CharacterClass
+      Standard  = [:alnum, :alpha, :blank, :cntrl, :digit, :graph,
+                   :lower, :print, :punct, :space, :upper, :xdigit]
+
+      Extensions = [:ascii, :word]
+
+      All = Standard + Extensions
+      Type = :class
+      NonType = :nonclass
+    end
+    Map[CharacterClass::Type]    = CharacterClass::All
+    Map[CharacterClass::NonType] = CharacterClass::All
+  end
+end

data/lib/regexp_parser/syntax/tokens/unicode_property.rb

@@ -2,10 +2,10 @@ module Regexp::Syntax
   module Token
 
     module UnicodeProperty
-      CharType_V190 = [:alnum, :alpha, :ascii, :blank, :cntrl, :digit, :graph,
+      CharType_V1_9_0 = [:alnum, :alpha, :ascii, :blank, :cntrl, :digit, :graph,
                        :lower, :print, :punct, :space, :upper, :word, :xdigit]
 
-      CharType_V250 = [:xposixpunct]
+      CharType_V2_5_0 = [:xposixpunct]
 
       POSIX  = [:any, :assigned, :newline]
 
@@ -37,24 +37,24 @@ module Regexp::Syntax
       end
 
       # As of ruby version 1.9.3
-      Age_V193 = [:age_1_1, :age_2_0, :age_2_1, :age_3_0, :age_3_1,
-                  :age_3_2, :age_4_0, :age_4_1, :age_5_0, :age_5_1,
-                  :age_5_2, :age_6_0]
+      Age_V1_9_3 = [:age_1_1, :age_2_0, :age_2_1, :age_3_0, :age_3_1,
+                    :age_3_2, :age_4_0, :age_4_1, :age_5_0, :age_5_1,
+                    :age_5_2, :age_6_0]
 
-      Age_V200 = [:age_6_1]
+      Age_V2_0_0 = [:age_6_1]
 
       # These were merged (from Onigmo) in the branch for 2.2.0
-      Age_V220 = [:age_6_2, :age_6_3, :age_7_0]
+      Age_V2_2_0 = [:age_6_2, :age_6_3, :age_7_0]
 
-      Age_V230 = [:age_8_0]
+      Age_V2_3_0 = [:age_8_0]
 
-      Age_V240 = [:age_9_0]
+      Age_V2_4_0 = [:age_9_0]
 
-      Age_V250 = [:age_10_0]
+      Age_V2_5_0 = [:age_10_0]
 
-      Age = Age_V193 + Age_V200 + Age_V220 + Age_V230 + Age_V240 + Age_V250
+      Age = Age_V1_9_3 + Age_V2_0_0 + Age_V2_2_0 + Age_V2_3_0 + Age_V2_4_0 + Age_V2_5_0
 
-      Derived_V190 = [
+      Derived_V1_9_0 = [
         :ascii_hex,
         :alphabetic,
         :cased,
@@ -108,13 +108,13 @@ module Regexp::Syntax
         :xid_continue,
       ]
 
-      Derived_V250 = [
+      Derived_V2_5_0 = [
         :regional_indicator
       ]
 
-      Derived = Derived_V190 + Derived_V250
+      Derived = Derived_V1_9_0 + Derived_V2_5_0
 
-      Script_V190 = [
+      Script_V1_9_0 = [
         :script_arabic,
         :script_imperial_aramaic,
         :script_armenian,
@@ -211,9 +211,9 @@ module Regexp::Syntax
         :script_unknown
       ]
 
-      Script_V193 = [:script_brahmi, :script_batak, :script_mandaic]
+      Script_V1_9_3 = [:script_brahmi, :script_batak, :script_mandaic]
 
-      Script_V220 = [
+      Script_V2_2_0 = [
         :script_caucasian_albanian,
         :script_bassa_vah,
         :script_duployan,
@@ -239,7 +239,7 @@ module Regexp::Syntax
         :script_warang_citi
       ]
 
-      Script = Script_V190 + Script_V193 + Script_V220
+      Script = Script_V1_9_0 + Script_V1_9_3 + Script_V2_2_0
 
       UnicodeBlock = [
         :block_inalphabetic_presentation_forms,
@@ -357,20 +357,20 @@ module Regexp::Syntax
         :emoji_presentation,
       ]
 
-      V190 = CharType_V190 + POSIX + Category::All + Derived_V190 + Script_V190 + UnicodeBlock
-      V193 = Age_V193 + Script_V193
+      V1_9_0 = CharType_V1_9_0 + POSIX + Category::All + Derived_V1_9_0 + Script_V1_9_0 + UnicodeBlock
+      V1_9_3 = Age_V1_9_3 + Script_V1_9_3
 
-      V200 = Age_V200
+      V2_0_0 = Age_V2_0_0
 
-      V220 = Age_V220 + Script_V220
+      V2_2_0 = Age_V2_2_0 + Script_V2_2_0
 
-      V230 = Age_V230
+      V2_3_0 = Age_V2_3_0
 
-      V240 = Age_V240
+      V2_4_0 = Age_V2_4_0
 
-      V250 = Age_V250 + CharType_V250 + Derived_V250 + Emoji
+      V2_5_0 = Age_V2_5_0 + CharType_V2_5_0 + Derived_V2_5_0 + Emoji
 
-      All  = V190 + V193 + V200 + V220 + V230 + V240 + V250
+      All  = V1_9_0 + V1_9_3 + V2_0_0 + V2_2_0 + V2_3_0 + V2_4_0 + V2_5_0
 
       Type = :property
       NonType = :nonproperty