regexp_parser 1.7.1 → 2.2.1

data/lib/regexp_parser/syntax/any.rb

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

data/lib/regexp_parser/syntax/base.rb

@@ -1,7 +1,5 @@
-require 'set'
-
 module Regexp::Syntax
-  class NotImplementedError < SyntaxError
+  class NotImplementedError < Regexp::Syntax::SyntaxError
     def initialize(syntax, type, token)
       super "#{syntax.class.name} does not implement: [#{type}:#{token}]"
     end
@@ -23,15 +21,15 @@ module Regexp::Syntax
     end
 
     def implementations(type)
-      @implements[type] ||= Set.new
+      @implements[type] ||= []
     end
 
     def implements(type, tokens)
-      implementations(type).merge(Array(tokens))
+      implementations(type).concat(Array(tokens))
     end
 
     def excludes(type, tokens)
-      implementations(type).subtract(Array(tokens))
+      Array(tokens).each { |tok| implementations(type).delete(tok) }
     end
 
     def implements?(type, token)
@@ -59,7 +57,7 @@ module Regexp::Syntax
     def normalize_group(type, token)
       case token
       when :named_ab, :named_sq
-        [:group, :named]
+        %i[group named]
       else
         [type, token]
       end
@@ -68,21 +66,21 @@ module Regexp::Syntax
     def normalize_backref(type, token)
       case token
       when :name_ref_ab, :name_ref_sq
-        [:backref, :name_ref]
+        %i[backref name_ref]
       when :name_call_ab, :name_call_sq
-        [:backref, :name_call]
+        %i[backref name_call]
       when :name_recursion_ref_ab, :name_recursion_ref_sq
-        [:backref, :name_recursion_ref]
+        %i[backref name_recursion_ref]
       when :number_ref_ab, :number_ref_sq
-        [:backref, :number_ref]
+        %i[backref number_ref]
       when :number_call_ab, :number_call_sq
-        [:backref, :number_call]
+        %i[backref number_call]
       when :number_rel_ref_ab, :number_rel_ref_sq
-        [:backref, :number_rel_ref]
+        %i[backref number_rel_ref]
       when :number_rel_call_ab, :number_rel_call_sq
-        [:backref, :number_rel_call]
+        %i[backref number_rel_call]
       when :number_recursion_ref_ab, :number_recursion_ref_sq
-        [:backref, :number_recursion_ref]
+        %i[backref number_recursion_ref]
       else
         [type, token]
       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, on 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
+
+      All = Greedy + Reluctant + Possessive + IntervalAll
+      Type = :quantifier
+    end
+
+    Map[Quantifier::Type] = Quantifier::All
+  end
+end