regexp_parser 2.1.1 → 2.5.0

data/lib/regexp_parser/syntax/any.rb

@@ -1,15 +1,10 @@
 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 # rubocop:disable Lint/MissingSuper
-      @implements = { :* => [:*] }
-    end
+    implements :*, [:*]
 
-    def implements?(_type, _token) true end
-    def implements!(_type, _token) true end
+    def self.implements?(_type, _token) true end
   end
-
 end

data/lib/regexp_parser/syntax/base.rb

@@ -1,9 +1,7 @@
-require 'set'
-
 module Regexp::Syntax
   class NotImplementedError < Regexp::Syntax::SyntaxError
     def initialize(syntax, type, token)
-      super "#{syntax.class.name} does not implement: [#{type}:#{token}]"
+      super "#{syntax} does not implement: [#{type}:#{token}]"
     end
   end
 
@@ -11,85 +9,112 @@ module Regexp::Syntax
   class Base
     include Regexp::Syntax::Token
 
-    def initialize
-      @implements = {}
+    class << self
+      attr_accessor :features
 
-      implements Token::Literal::Type,   Token::Literal::All
-      implements Token::FreeSpace::Type, Token::FreeSpace::All
-    end
+      # automatically inherit features through the syntax class hierarchy
+      def inherited(subclass)
+        super
+        subclass.features = features.to_h.map { |k, v| [k, v.dup] }.to_h
+      end
 
-    def features
-      @implements
-    end
+      def implements(type, tokens)
+        (features[type] ||= []).concat(tokens)
+        added_features[type] = tokens
+      end
 
-    def implementations(type)
-      @implements[type] ||= Set.new
-    end
+      def excludes(type, tokens)
+        tokens.each { |tok| features[type].delete(tok) }
+        removed_features[type] = tokens
+      end
 
-    def implements(type, tokens)
-      implementations(type).merge(Array(tokens))
-    end
+      def implements?(type, token)
+        implementations(type).include?(token)
+      end
+      alias :check? :implements?
 
-    def excludes(type, tokens)
-      implementations(type).subtract(Array(tokens))
-    end
+      def implementations(type)
+        features[type] || []
+      end
 
-    def implements?(type, token)
-      implementations(type).include?(token)
-    end
-    alias :check? :implements?
+      def implements!(type, token)
+        raise NotImplementedError.new(self, type, token) unless
+          implements?(type, token)
+      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]
+      def added_features
+        @added_features ||= {}
       end
-    end
 
-    def normalize_group(type, token)
-      case token
-      when :named_ab, :named_sq
-        [:group, :named]
-      else
-        [type, token]
+      def removed_features
+        @removed_features ||= {}
       end
+
+      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
+          %i[group named]
+        else
+          [type, token]
+        end
+      end
+
+      def normalize_backref(type, token)
+        case token
+        when :name_ref_ab, :name_ref_sq
+          %i[backref name_ref]
+        when :name_call_ab, :name_call_sq
+          %i[backref name_call]
+        when :name_recursion_ref_ab, :name_recursion_ref_sq
+          %i[backref name_recursion_ref]
+        when :number_ref_ab, :number_ref_sq
+          %i[backref number_ref]
+        when :number_call_ab, :number_call_sq
+          %i[backref number_call]
+        when :number_rel_ref_ab, :number_rel_ref_sq
+          %i[backref number_rel_ref]
+        when :number_rel_call_ab, :number_rel_call_sq
+          %i[backref number_rel_call]
+        when :number_recursion_ref_ab, :number_recursion_ref_sq
+          %i[backref number_recursion_ref]
+        else
+          [type, token]
+        end
+      end
+    end
+
+    # TODO: drop this backwards compatibility code in v3.0.0, do `private :new`
+    def initialize
+      warn 'Using instances of Regexp::Parser::Syntax is deprecated ' \
+           "and will no longer be supported in v3.0.0."
     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_recursion_ref_ab, :name_recursion_ref_sq
-        [:backref, :name_recursion_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_recursion_ref_ab, :number_recursion_ref_sq
-        [:backref, :number_recursion_ref]
+    def method_missing(name, *args)
+      if self.class.respond_to?(name)
+        warn 'Using instances of Regexp::Parser::Syntax is deprecated ' \
+             "and will no longer be supported in v3.0.0. Please call "\
+             "methods on the class directly, e.g.: #{self.class}.#{name}"
+        self.class.send(name, *args)
       else
-        [type, token]
+        super
       end
     end
 
-    def self.inspect
-      "#{super} (feature set of #{ancestors[1].to_s.split('::').last})"
+    def respond_to_missing?(name, include_private = false)
+      self.class.respond_to?(name) || super
     end
+    # end of backwards compatibility code
   end
 end

data/lib/regexp_parser/syntax/token/anchor.rb

@@ -0,0 +1,15 @@
+module Regexp::Syntax
+  module Token
+    module Anchor
+      Basic       = %i[bol eol]
+      Extended    = Basic + %i[word_boundary nonword_boundary]
+      String      = %i[bos eos eos_ob_eol]
+      MatchStart  = %i[match_start]
+
+      All = Extended + String + MatchStart
+      Type = :anchor
+    end
+
+    Map[Anchor::Type] = Anchor::All
+  end
+end

data/lib/regexp_parser/syntax/{tokens → token}/assertion.rb

@@ -1,8 +1,8 @@
 module Regexp::Syntax
   module Token
     module Assertion
-      Lookahead = [:lookahead, :nlookahead]
-      Lookbehind = [:lookbehind, :nlookbehind]
+      Lookahead = %i[lookahead nlookahead]
+      Lookbehind = %i[lookbehind nlookbehind]
 
       All = Lookahead + Lookbehind
       Type = :assertion

data/lib/regexp_parser/syntax/token/backreference.rb

@@ -0,0 +1,30 @@
+module Regexp::Syntax
+  module Token
+    module Backreference
+      Plain     = %i[number]
+      NumberRef = %i[number_ref number_rel_ref]
+      Number    = Plain + NumberRef
+      Name      = %i[name_ref]
+
+      RecursionLevel = %i[name_recursion_ref number_recursion_ref]
+
+      V1_8_6 = Plain
+
+      V1_9_1 = Name + NumberRef + RecursionLevel
+
+      All = V1_8_6 + V1_9_1
+      Type = :backref
+    end
+
+    # Type is the same as Backreference so keeping it here, for now.
+    module SubexpressionCall
+      Name      = %i[name_call]
+      Number    = %i[number_call number_rel_call]
+
+      All = Name + Number
+    end
+
+    Map[Backreference::Type] = Backreference::All +
+                               SubexpressionCall::All
+  end
+end

data/lib/regexp_parser/syntax/{tokens → token}/character_set.rb

@@ -1,8 +1,8 @@
 module Regexp::Syntax
   module Token
     module CharacterSet
-      Basic     = [:open, :close, :negate, :range]
-      Extended  = Basic + [:intersection]
+      Basic     = %i[open close negate range]
+      Extended  = Basic + %i[intersection]
 
       All = Extended
       Type = :set

data/lib/regexp_parser/syntax/{tokens → token}/character_type.rb

@@ -2,10 +2,10 @@ module Regexp::Syntax
   module Token
     module CharacterType
       Basic     = []
-      Extended  = [:digit, :nondigit, :space, :nonspace, :word, :nonword]
-      Hex       = [:hex, :nonhex]
+      Extended  = %i[digit nondigit space nonspace word nonword]
+      Hex       = %i[hex nonhex]
 
-      Clustered = [:linebreak, :xgrapheme]
+      Clustered = %i[linebreak xgrapheme]
 
       All = Basic + Extended + Hex + Clustered
       Type = :type

data/lib/regexp_parser/syntax/{tokens → token}/conditional.rb

@@ -1,10 +1,10 @@
 module Regexp::Syntax
   module Token
     module Conditional
-      Delimiters = [:open, :close]
+      Delimiters = %i[open close]
 
-      Condition  = [:condition_open, :condition, :condition_close]
-      Separator  = [:separator]
+      Condition  = %i[condition_open condition condition_close]
+      Separator  = %i[separator]
 
       All = Conditional::Delimiters + Conditional::Condition + Conditional::Separator
 

data/lib/regexp_parser/syntax/token/escape.rb

@@ -0,0 +1,31 @@
+module Regexp::Syntax
+  module Token
+    # TODO: unify naming with RE::EscapeSequence, one way or the other, in v3.0.0
+    module Escape
+      Basic = %i[backslash literal]
+
+      Control = %i[control meta_sequence]
+
+      ASCII = %i[bell backspace escape form_feed newline carriage
+                 tab vertical_tab]
+
+      Unicode = %i[codepoint codepoint_list]
+
+      Meta  = %i[dot alternation
+                 zero_or_one zero_or_more one_or_more
+                 bol eol
+                 group_open group_close
+                 interval_open interval_close
+                 set_open set_close]
+
+      Hex   = %i[hex]
+
+      Octal = %i[octal]
+
+      All   = Basic + Control + ASCII + Unicode + Meta + Hex + Octal
+      Type  = :escape
+    end
+
+    Map[Escape::Type] = Escape::All
+  end
+end

data/lib/regexp_parser/syntax/{tokens → token}/group.rb

@@ -1,18 +1,18 @@
 module Regexp::Syntax
   module Token
     module Group
-      Basic     = [:capture, :close]
-      Extended  = Basic + [:options, :options_switch]
+      Basic     = %i[capture close]
+      Extended  = Basic + %i[options options_switch]
 
-      Named     = [:named]
-      Atomic    = [:atomic]
-      Passive   = [:passive]
-      Comment   = [:comment]
+      Named     = %i[named]
+      Atomic    = %i[atomic]
+      Passive   = %i[passive]
+      Comment   = %i[comment]
 
       V1_8_6 = Group::Extended + Group::Named + Group::Atomic +
                Group::Passive + Group::Comment
 
-      V2_4_1 = [:absence]
+      V2_4_1 = %i[absence]
 
       All = V1_8_6 + V2_4_1
       Type = :group

data/lib/regexp_parser/syntax/{tokens → token}/keep.rb

@@ -1,7 +1,7 @@
 module Regexp::Syntax
   module Token
     module Keep
-      Mark = [:mark]
+      Mark = %i[mark]
 
       All  = Mark
       Type = :keep

data/lib/regexp_parser/syntax/{tokens → token}/meta.rb

@@ -1,8 +1,8 @@
 module Regexp::Syntax
   module Token
     module Meta
-      Basic    = [:dot]
-      Extended = Basic + [:alternation]
+      Basic    = %i[dot]
+      Extended = Basic + %i[alternation]
 
       All = Extended
       Type = :meta

data/lib/regexp_parser/syntax/{tokens → token}/posix_class.rb

@@ -1,10 +1,10 @@
 module Regexp::Syntax
   module Token
     module PosixClass
-      Standard = [:alnum, :alpha, :blank, :cntrl, :digit, :graph,
-                  :lower, :print, :punct, :space, :upper, :xdigit]
+      Standard = %i[alnum alpha blank cntrl digit graph
+                    lower print punct space upper xdigit]
 
-      Extensions = [:ascii, :word]
+      Extensions = %i[ascii word]
 
       All = Standard + Extensions
       Type = :posixclass

data/lib/regexp_parser/syntax/token/quantifier.rb

@@ -0,0 +1,35 @@
+module Regexp::Syntax
+  module Token
+    module Quantifier
+      Greedy = %i[
+        zero_or_one
+        zero_or_more
+        one_or_more
+      ]
+
+      Reluctant = %i[
+        zero_or_one_reluctant
+        zero_or_more_reluctant
+        one_or_more_reluctant
+      ]
+
+      Possessive = %i[
+        zero_or_one_possessive
+        zero_or_more_possessive
+        one_or_more_possessive
+      ]
+
+      Interval             = %i[interval]
+      IntervalReluctant    = %i[interval_reluctant]
+      IntervalPossessive   = %i[interval_possessive]
+
+      IntervalAll = Interval + IntervalReluctant + IntervalPossessive
+
+      V1_8_6 = Greedy + Reluctant + Interval + IntervalReluctant
+      All = Greedy + Reluctant + Possessive + IntervalAll
+      Type = :quantifier
+    end
+
+    Map[Quantifier::Type] = Quantifier::All
+  end
+end