regexp_parser 2.6.2 → 2.8.0

data/lib/regexp_parser/parser.rb

@@ -18,11 +18,11 @@ class Regexp::Parser
     end
   end
 
-  def self.parse(input, syntax = "ruby/#{RUBY_VERSION}", options: nil, &block)
+  def self.parse(input, syntax = nil, options: nil, &block)
     new.parse(input, syntax, options: options, &block)
   end
 
-  def parse(input, syntax = "ruby/#{RUBY_VERSION}", options: nil, &block)
+  def parse(input, syntax = nil, options: nil, &block)
     root = Root.construct(options: extract_options(input, options))
 
     self.root = root
@@ -35,7 +35,7 @@ class Regexp::Parser
 
     self.captured_group_counts = Hash.new(0)
 
-    Regexp::Lexer.scan(input, syntax, options: options) do |token|
+    Regexp::Lexer.scan(input, syntax, options: options, collect_tokens: false) do |token|
       parse_token(token)
     end
 
@@ -232,7 +232,7 @@ class Regexp::Parser
       node << Backreference::NameRecursionLevel.new(token, active_opts)
     when :name_call
       node << Backreference::NameCall.new(token, active_opts)
-    when :number, :number_ref
+    when :number, :number_ref # TODO: split in v3.0.0
       node << Backreference::Number.new(token, active_opts)
     when :number_recursion_ref
       node << Backreference::NumberRecursionLevel.new(token, active_opts).tap do |exp|
@@ -272,9 +272,9 @@ class Regexp::Parser
       nest_conditional(Conditional::Expression.new(token, active_opts))
     when :condition
       conditional_nesting.last.condition = Conditional::Condition.new(token, active_opts)
-      conditional_nesting.last.add_sequence(active_opts)
+      conditional_nesting.last.add_sequence(active_opts, { ts: token.te })
     when :separator
-      conditional_nesting.last.add_sequence(active_opts)
+      conditional_nesting.last.add_sequence(active_opts, { ts: token.te })
       self.node = conditional_nesting.last.branches.last
     when :close
       conditional_nesting.pop
@@ -322,6 +322,7 @@ class Regexp::Parser
 
     when :control
       if token.text =~ /\A(?:\\C-\\M|\\c\\M)/
+        # TODO: emit :meta_control_sequence token in v3.0.0
         node << EscapeSequence::MetaControl.new(token, active_opts)
       else
         node << EscapeSequence::Control.new(token, active_opts)
@@ -329,6 +330,7 @@ class Regexp::Parser
 
     when :meta_sequence
       if token.text =~ /\A\\M-\\[Cc]/
+        # TODO: emit :meta_control_sequence token in v3.0.0:
         node << EscapeSequence::MetaControl.new(token, active_opts)
       else
         node << EscapeSequence::Meta.new(token, active_opts)
@@ -349,11 +351,7 @@ class Regexp::Parser
     when :comment
       node << Comment.new(token, active_opts)
     when :whitespace
-      if node.last.is_a?(WhiteSpace)
-        node.last.merge(WhiteSpace.new(token, active_opts))
-      else
-        node << WhiteSpace.new(token, active_opts)
-      end
+      node << WhiteSpace.new(token, active_opts)
     else
       raise UnknownTokenError.new('FreeSpace', token)
     end
@@ -379,98 +377,98 @@ class Regexp::Parser
   end
 
   def sequence_operation(klass, token)
-    unless node.is_a?(klass)
+    unless node.instance_of?(klass)
       operator = klass.new(token, active_opts)
-      sequence = operator.add_sequence(active_opts)
+      sequence = operator.add_sequence(active_opts, { ts: token.ts })
       sequence.expressions = node.expressions
       node.expressions = []
       nest(operator)
     end
-    node.add_sequence(active_opts)
+    node.add_sequence(active_opts, { ts: token.te })
   end
 
   def posixclass(token)
     node << PosixClass.new(token, active_opts)
   end
 
-  include Regexp::Expression::UnicodeProperty
-  UPTokens = Regexp::Syntax::Token::UnicodeProperty
+  UP = Regexp::Expression::Property
+  UPTokens = Regexp::Syntax::Token::Property
 
   def property(token)
     case token.token
-    when :alnum;                  node << Alnum.new(token, active_opts)
-    when :alpha;                  node << Alpha.new(token, active_opts)
-    when :ascii;                  node << Ascii.new(token, active_opts)
-    when :blank;                  node << Blank.new(token, active_opts)
-    when :cntrl;                  node << Cntrl.new(token, active_opts)
-    when :digit;                  node << Digit.new(token, active_opts)
-    when :graph;                  node << Graph.new(token, active_opts)
-    when :lower;                  node << Lower.new(token, active_opts)
-    when :print;                  node << Print.new(token, active_opts)
-    when :punct;                  node << Punct.new(token, active_opts)
-    when :space;                  node << Space.new(token, active_opts)
-    when :upper;                  node << Upper.new(token, active_opts)
-    when :word;                   node << Word.new(token, active_opts)
-    when :xdigit;                 node << Xdigit.new(token, active_opts)
-    when :xposixpunct;            node << XPosixPunct.new(token, active_opts)
+    when :alnum;                  node << UP::Alnum.new(token, active_opts)
+    when :alpha;                  node << UP::Alpha.new(token, active_opts)
+    when :ascii;                  node << UP::Ascii.new(token, active_opts)
+    when :blank;                  node << UP::Blank.new(token, active_opts)
+    when :cntrl;                  node << UP::Cntrl.new(token, active_opts)
+    when :digit;                  node << UP::Digit.new(token, active_opts)
+    when :graph;                  node << UP::Graph.new(token, active_opts)
+    when :lower;                  node << UP::Lower.new(token, active_opts)
+    when :print;                  node << UP::Print.new(token, active_opts)
+    when :punct;                  node << UP::Punct.new(token, active_opts)
+    when :space;                  node << UP::Space.new(token, active_opts)
+    when :upper;                  node << UP::Upper.new(token, active_opts)
+    when :word;                   node << UP::Word.new(token, active_opts)
+    when :xdigit;                 node << UP::Xdigit.new(token, active_opts)
+    when :xposixpunct;            node << UP::XPosixPunct.new(token, active_opts)
 
     # only in Oniguruma (old rubies)
-    when :newline;                node << Newline.new(token, active_opts)
-
-    when :any;                    node << Any.new(token, active_opts)
-    when :assigned;               node << Assigned.new(token, active_opts)
-
-    when :letter;                 node << Letter::Any.new(token, active_opts)
-    when :cased_letter;           node << Letter::Cased.new(token, active_opts)
-    when :uppercase_letter;       node << Letter::Uppercase.new(token, active_opts)
-    when :lowercase_letter;       node << Letter::Lowercase.new(token, active_opts)
-    when :titlecase_letter;       node << Letter::Titlecase.new(token, active_opts)
-    when :modifier_letter;        node << Letter::Modifier.new(token, active_opts)
-    when :other_letter;           node << Letter::Other.new(token, active_opts)
-
-    when :mark;                   node << Mark::Any.new(token, active_opts)
-    when :combining_mark;         node << Mark::Combining.new(token, active_opts)
-    when :nonspacing_mark;        node << Mark::Nonspacing.new(token, active_opts)
-    when :spacing_mark;           node << Mark::Spacing.new(token, active_opts)
-    when :enclosing_mark;         node << Mark::Enclosing.new(token, active_opts)
-
-    when :number;                 node << Number::Any.new(token, active_opts)
-    when :decimal_number;         node << Number::Decimal.new(token, active_opts)
-    when :letter_number;          node << Number::Letter.new(token, active_opts)
-    when :other_number;           node << Number::Other.new(token, active_opts)
-
-    when :punctuation;            node << Punctuation::Any.new(token, active_opts)
-    when :connector_punctuation;  node << Punctuation::Connector.new(token, active_opts)
-    when :dash_punctuation;       node << Punctuation::Dash.new(token, active_opts)
-    when :open_punctuation;       node << Punctuation::Open.new(token, active_opts)
-    when :close_punctuation;      node << Punctuation::Close.new(token, active_opts)
-    when :initial_punctuation;    node << Punctuation::Initial.new(token, active_opts)
-    when :final_punctuation;      node << Punctuation::Final.new(token, active_opts)
-    when :other_punctuation;      node << Punctuation::Other.new(token, active_opts)
-
-    when :separator;              node << Separator::Any.new(token, active_opts)
-    when :space_separator;        node << Separator::Space.new(token, active_opts)
-    when :line_separator;         node << Separator::Line.new(token, active_opts)
-    when :paragraph_separator;    node << Separator::Paragraph.new(token, active_opts)
-
-    when :symbol;                 node << Symbol::Any.new(token, active_opts)
-    when :math_symbol;            node << Symbol::Math.new(token, active_opts)
-    when :currency_symbol;        node << Symbol::Currency.new(token, active_opts)
-    when :modifier_symbol;        node << Symbol::Modifier.new(token, active_opts)
-    when :other_symbol;           node << Symbol::Other.new(token, active_opts)
-
-    when :other;                  node << Codepoint::Any.new(token, active_opts)
-    when :control;                node << Codepoint::Control.new(token, active_opts)
-    when :format;                 node << Codepoint::Format.new(token, active_opts)
-    when :surrogate;              node << Codepoint::Surrogate.new(token, active_opts)
-    when :private_use;            node << Codepoint::PrivateUse.new(token, active_opts)
-    when :unassigned;             node << Codepoint::Unassigned.new(token, active_opts)
-
-    when *UPTokens::Age;          node << Age.new(token, active_opts)
-    when *UPTokens::Derived;      node << Derived.new(token, active_opts)
-    when *UPTokens::Emoji;        node << Emoji.new(token, active_opts)
-    when *UPTokens::Script;       node << Script.new(token, active_opts)
-    when *UPTokens::UnicodeBlock; node << Block.new(token, active_opts)
+    when :newline;                node << UP::Newline.new(token, active_opts)
+
+    when :any;                    node << UP::Any.new(token, active_opts)
+    when :assigned;               node << UP::Assigned.new(token, active_opts)
+
+    when :letter;                 node << UP::Letter::Any.new(token, active_opts)
+    when :cased_letter;           node << UP::Letter::Cased.new(token, active_opts)
+    when :uppercase_letter;       node << UP::Letter::Uppercase.new(token, active_opts)
+    when :lowercase_letter;       node << UP::Letter::Lowercase.new(token, active_opts)
+    when :titlecase_letter;       node << UP::Letter::Titlecase.new(token, active_opts)
+    when :modifier_letter;        node << UP::Letter::Modifier.new(token, active_opts)
+    when :other_letter;           node << UP::Letter::Other.new(token, active_opts)
+
+    when :mark;                   node << UP::Mark::Any.new(token, active_opts)
+    when :combining_mark;         node << UP::Mark::Combining.new(token, active_opts)
+    when :nonspacing_mark;        node << UP::Mark::Nonspacing.new(token, active_opts)
+    when :spacing_mark;           node << UP::Mark::Spacing.new(token, active_opts)
+    when :enclosing_mark;         node << UP::Mark::Enclosing.new(token, active_opts)
+
+    when :number;                 node << UP::Number::Any.new(token, active_opts)
+    when :decimal_number;         node << UP::Number::Decimal.new(token, active_opts)
+    when :letter_number;          node << UP::Number::Letter.new(token, active_opts)
+    when :other_number;           node << UP::Number::Other.new(token, active_opts)
+
+    when :punctuation;            node << UP::Punctuation::Any.new(token, active_opts)
+    when :connector_punctuation;  node << UP::Punctuation::Connector.new(token, active_opts)
+    when :dash_punctuation;       node << UP::Punctuation::Dash.new(token, active_opts)
+    when :open_punctuation;       node << UP::Punctuation::Open.new(token, active_opts)
+    when :close_punctuation;      node << UP::Punctuation::Close.new(token, active_opts)
+    when :initial_punctuation;    node << UP::Punctuation::Initial.new(token, active_opts)
+    when :final_punctuation;      node << UP::Punctuation::Final.new(token, active_opts)
+    when :other_punctuation;      node << UP::Punctuation::Other.new(token, active_opts)
+
+    when :separator;              node << UP::Separator::Any.new(token, active_opts)
+    when :space_separator;        node << UP::Separator::Space.new(token, active_opts)
+    when :line_separator;         node << UP::Separator::Line.new(token, active_opts)
+    when :paragraph_separator;    node << UP::Separator::Paragraph.new(token, active_opts)
+
+    when :symbol;                 node << UP::Symbol::Any.new(token, active_opts)
+    when :math_symbol;            node << UP::Symbol::Math.new(token, active_opts)
+    when :currency_symbol;        node << UP::Symbol::Currency.new(token, active_opts)
+    when :modifier_symbol;        node << UP::Symbol::Modifier.new(token, active_opts)
+    when :other_symbol;           node << UP::Symbol::Other.new(token, active_opts)
+
+    when :other;                  node << UP::Codepoint::Any.new(token, active_opts)
+    when :control;                node << UP::Codepoint::Control.new(token, active_opts)
+    when :format;                 node << UP::Codepoint::Format.new(token, active_opts)
+    when :surrogate;              node << UP::Codepoint::Surrogate.new(token, active_opts)
+    when :private_use;            node << UP::Codepoint::PrivateUse.new(token, active_opts)
+    when :unassigned;             node << UP::Codepoint::Unassigned.new(token, active_opts)
+
+    when *UPTokens::Age;          node << UP::Age.new(token, active_opts)
+    when *UPTokens::Derived;      node << UP::Derived.new(token, active_opts)
+    when *UPTokens::Emoji;        node << UP::Emoji.new(token, active_opts)
+    when *UPTokens::Script;       node << UP::Script.new(token, active_opts)
+    when *UPTokens::UnicodeBlock; node << UP::Block.new(token, active_opts)
 
     else
       raise UnknownTokenError.new('UnicodeProperty', token)
@@ -478,8 +476,7 @@ class Regexp::Parser
   end
 
   def quantifier(token)
-    target_node = node.expressions.reverse.find { |exp| !exp.is_a?(FreeSpace) }
-    target_node or raise ParserError, "No valid target found for '#{token.text}'"
+    target_node = node.extract_quantifier_target(token.text)
 
     # in case of chained quantifiers, wrap target in an implicit passive group
     # description of the problem: https://github.com/ammar/regexp_parser/issues/3
@@ -527,6 +524,8 @@ class Regexp::Parser
   end
 
   def open_set(token)
+    # TODO: this and Quantifier are the only cases where Expression#token
+    # does not match the scanner/lexer output. Fix in v3.0.0.
     token.token = :character
     nest(CharacterSet.new(token, active_opts))
   end
@@ -541,7 +540,7 @@ class Regexp::Parser
 
   def range(token)
     exp = CharacterSet::Range.new(token, active_opts)
-    scope = node.last.is_a?(CharacterSet::IntersectedSequence) ? node.last : node
+    scope = node.last.instance_of?(CharacterSet::IntersectedSequence) ? node.last : node
     exp << scope.expressions.pop
     nest(exp)
   end
@@ -568,7 +567,7 @@ class Regexp::Parser
   end
 
   def close_completed_character_set_range
-    decrease_nesting if node.is_a?(CharacterSet::Range) && node.complete?
+    decrease_nesting if node.instance_of?(CharacterSet::Range) && node.complete?
   end
 
   def active_opts
@@ -579,17 +578,18 @@ class Regexp::Parser
   # an instance of Backreference::Number, its #referenced_expression is set to
   # the instance of Group::Capture that it refers to via its number.
   def assign_referenced_expressions
-    # find all referencable expressions
+    # find all referencable and refering expressions
     targets = { 0 => root }
+    referrers = []
     root.each_expression do |exp|
       exp.is_a?(Group::Capture) && targets[exp.identifier] = exp
+      referrers << exp if exp.referential?
     end
-    # assign them to any refering expressions
-    root.each_expression do |exp|
-      next unless exp.respond_to?(:reference)
-
+    # assign reference expression to refering expressions
+    # (in a second iteration because there might be forward references)
+    referrers.each do |exp|
       exp.referenced_expression = targets[exp.reference] ||
-        raise(ParserError, "Invalid reference: #{exp.reference}")
+        raise(ParserError, "Invalid reference #{exp.reference} at pos #{exp.ts}")
     end
   end
 end # module Regexp::Parser

data/lib/regexp_parser/scanner/errors/premature_end_error.rb

@@ -0,0 +1,8 @@
+class Regexp::Scanner
+  # Unexpected end of pattern
+  class PrematureEndError < ScannerError
+    def initialize(where = '')
+      super "Premature end of pattern at #{where}"
+    end
+  end
+end

data/lib/regexp_parser/scanner/errors/scanner_error.rb

@@ -0,0 +1,6 @@
+require 'regexp_parser/error'
+
+class Regexp::Scanner
+  # General scanner error (catch all)
+  class ScannerError < Regexp::Parser::Error; end
+end

data/lib/regexp_parser/scanner/errors/validation_error.rb

@@ -0,0 +1,63 @@
+class Regexp::Scanner
+  # Base for all scanner validation errors
+  class ValidationError < ScannerError
+    # Centralizes and unifies the handling of validation related errors.
+    def self.for(type, problem, reason = nil)
+      types.fetch(type).new(problem, reason)
+    end
+
+    def self.types
+      @types ||= {
+        backref:      InvalidBackrefError,
+        group:        InvalidGroupError,
+        group_option: InvalidGroupOption,
+        posix_class:  UnknownPosixClassError,
+        property:     UnknownUnicodePropertyError,
+        sequence:     InvalidSequenceError,
+      }
+    end
+  end
+
+  # Invalid sequence format. Used for escape sequences, mainly.
+  class InvalidSequenceError < ValidationError
+    def initialize(what = 'sequence', where = '')
+      super "Invalid #{what} at #{where}"
+    end
+  end
+
+  # Invalid group. Used for named groups.
+  class InvalidGroupError < ValidationError
+    def initialize(what, reason)
+      super "Invalid #{what}, #{reason}."
+    end
+  end
+
+  # Invalid groupOption. Used for inline options.
+  # TODO: should become InvalidGroupOptionError in v3.0.0 for consistency
+  class InvalidGroupOption < ValidationError
+    def initialize(option, text)
+      super "Invalid group option #{option} in #{text}"
+    end
+  end
+
+  # Invalid back reference. Used for name a number refs/calls.
+  class InvalidBackrefError < ValidationError
+    def initialize(what, reason)
+      super "Invalid back reference #{what}, #{reason}"
+    end
+  end
+
+  # The property name was not recognized by the scanner.
+  class UnknownUnicodePropertyError < ValidationError
+    def initialize(name, _)
+      super "Unknown unicode character property name #{name}"
+    end
+  end
+
+  # The POSIX class name was not recognized by the scanner.
+  class UnknownPosixClassError < ValidationError
+    def initialize(text, _)
+      super "Unknown POSIX class #{text}"
+    end
+  end
+end

data/lib/regexp_parser/scanner/mapping.rb

@@ -0,0 +1,89 @@
+# mapping for simple cases with a 1:1 relation between text and token
+class Regexp::Scanner
+  MAPPING = {
+    anchor: {
+      '\A' => :bos,
+      '\B' => :nonword_boundary,
+      '\G' => :match_start,
+      '\Z' => :eos_ob_eol,
+      '\b' => :word_boundary,
+      '\z' => :eos,
+    },
+    assertion: {
+      '(?='  => :lookahead,
+      '(?!'  => :nlookahead,
+      '(?<=' => :lookbehind,
+      '(?<!' => :nlookbehind,
+    },
+    conditional: {
+      '(?' => :open,
+    },
+    escape: {
+      '\.'   => :dot,
+      '\|'   => :alternation,
+      '\^'   => :bol,
+      '\$'   => :eol,
+      '\?'   => :zero_or_one,
+      '\*'   => :zero_or_more,
+      '\+'   => :one_or_more,
+      '\('   => :group_open,
+      '\)'   => :group_close,
+      '\{'   => :interval_open,
+      '\}'   => :interval_close,
+      '\['   => :set_open,
+      '\]'   => :set_close,
+      '\\\\' => :backslash,
+      '\a'   => :bell,
+      '\b'   => :backspace,
+      '\e'   => :escape,
+      '\f'   => :form_feed,
+      '\n'   => :newline,
+      '\r'   => :carriage,
+      '\t'   => :tab,
+      '\v'   => :vertical_tab,
+    },
+    group: {
+      '(?:' => :passive,
+      '(?>' => :atomic,
+      '(?~' => :absence,
+    },
+    meta: {
+      '|' => :alternation,
+      '.' => :dot,
+    },
+    quantifier: {
+      '?'  => :zero_or_one,
+      '??' => :zero_or_one_reluctant,
+      '?+' => :zero_or_one_possessive,
+      '*'  => :zero_or_more,
+      '*?' => :zero_or_more_reluctant,
+      '*+' => :zero_or_more_possessive,
+      '+'  => :one_or_more,
+      '+?' => :one_or_more_reluctant,
+      '++' => :one_or_more_possessive,
+    },
+    set: {
+      '['  => :character,
+      '-'  => :range,
+      '&&' => :intersection,
+    },
+    type: {
+      '\d' => :digit,
+      '\D' => :nondigit,
+      '\h' => :hex,
+      '\H' => :nonhex,
+      '\s' => :space,
+      '\S' => :nonspace,
+      '\w' => :word,
+      '\W' => :nonword,
+      '\R' => :linebreak,
+      '\X' => :xgrapheme,
+    }
+  }
+  ANCHOR_MAPPING     = MAPPING[:anchor]
+  ASSERTION_MAPPING  = MAPPING[:assertion]
+  ESCAPE_MAPPING     = MAPPING[:escape]
+  GROUP_MAPPING      = MAPPING[:group]
+  QUANTIFIER_MAPPING = MAPPING[:quantifier]
+  TYPE_MAPPING       = MAPPING[:type]
+end

data/lib/regexp_parser/scanner/property.rl

@@ -17,10 +17,10 @@
       text = copy(data, ts-1, te)
       type = (text[1] == 'P') ^ (text[3] == '^') ? :nonproperty : :property
 
-      name = data[ts+2..te-2].pack('c*').gsub(/[\^\s_\-]/, '').downcase
+      name = text[3..-2].gsub(/[\^\s_\-]/, '').downcase
 
       token = self.class.short_prop_map[name] || self.class.long_prop_map[name]
-      validation_error(:property, name) unless token
+      raise ValidationError.for(:property, name) unless token
 
       self.emit(type, token.to_sym, text)