regexp_parser 2.7.0 → 2.8.0

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

@@ -20,7 +20,7 @@
       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)
 

data/lib/regexp_parser/scanner/scanner.rl

@@ -30,11 +30,6 @@
 
   class_posix           = ('[:' . '^'? . [^\[\]]* . ':]');
 
-
-  # these are not supported in ruby at the moment
-  collating_sequence    = '[.' . (alpha | [\-])+ . '.]';
-  character_equivalent  = '[=' . alpha . '=]';
-
   line_anchor           = beginning_of_line | end_of_line;
   anchor_char           = [AbBzZG];
 
@@ -83,10 +78,9 @@
   # try to treat every other group head as options group, like Ruby
   group_options         = '?' . ( [^!#'():<=>~]+ . ':'? ) ?;
 
-  group_ref             = [gk];
   group_name_id_ab      = ([^!0-9\->] | utf8_multibyte) . ([^>] | utf8_multibyte)*;
   group_name_id_sq      = ([^0-9\-']  | utf8_multibyte) . ([^'] | utf8_multibyte)*;
-  group_number          = '-'? . [1-9] . [0-9]*;
+  group_number          = '-'? . [0-9]+;
   group_level           = [+\-] . [0-9]+;
 
   group_name            = ('<' . group_name_id_ab? . '>') |
@@ -95,15 +89,11 @@
 
   group_named           = ('?' . group_name );
 
-  group_name_backref    = 'k' . (('<' . group_name_id_ab? . group_level? '>') |
-                                 ("'" . group_name_id_sq? . group_level? "'"));
-  group_name_call       = 'g' . (('<' . group_name_id_ab? . group_level? '>') |
-                                 ("'" . group_name_id_sq? . group_level? "'"));
+  group_ref_body        = (('<' . (group_name_id_ab? | group_number) . group_level? '>') |
+                           ("'" . (group_name_id_sq? | group_number) . group_level? "'"));
 
-  group_number_backref  = 'k' . (('<' . group_number . group_level? '>') |
-                                 ("'" . group_number . group_level? "'"));
-  group_number_call     = 'g' . (('<' . ((group_number . group_level?) | '0') '>') |
-                                 ("'" . ((group_number . group_level?) | '0') "'"));
+  group_ref             = 'k' . group_ref_body;
+  group_call            = 'g' . group_ref_body;
 
   group_type            = group_atomic | group_passive | group_absence | group_named;
 
@@ -134,13 +124,13 @@
   # EOF error, used where it can be detected
   action premature_end_error {
     text = copy(data, ts ? ts-1 : 0, -1)
-    raise PrematureEndError.new( text )
+    raise PrematureEndError.new(text)
   }
 
   # Invalid sequence error, used from sequences, like escapes and sets
   action invalid_sequence_error {
     text = copy(data, ts ? ts-1 : 0, -1)
-    validation_error(:sequence, 'sequence', text)
+    raise ValidationError.for(:sequence, 'sequence', text)
   }
 
   # group (nesting) and set open/close actions
@@ -221,20 +211,12 @@
       end
 
       unless self.class.posix_classes.include?(class_name)
-        validation_error(:posix_class, text)
+        raise ValidationError.for(:posix_class, text)
       end
 
       emit(type, class_name.to_sym, text)
     };
 
-    # These are not supported in ruby at the moment. Enable them if they are.
-    # collating_sequence >(open_bracket, 1) @set_closed @eof(premature_end_error) {
-    #   emit(:set, :collation, copy(data, ts, te))
-    # };
-    # character_equivalent >(open_bracket, 1) @set_closed @eof(premature_end_error) {
-    #   emit(:set, :equivalent, copy(data, ts, te))
-    # };
-
     meta_char > (set_meta, 1) {
       emit(:literal, :literal, copy(data, ts, te))
     };
@@ -457,10 +439,9 @@
 
     # (?#...) comments: parsed as a single expression, without introducing a
     # new nesting level. Comments may not include parentheses, escaped or not.
-    # special case for close, action performed on all transitions to get the
-    # correct closing count.
+    # special case for close to get the correct closing count.
     # ------------------------------------------------------------------------
-    group_open . group_comment $group_closed {
+    (group_open . group_comment) @group_closed {
       emit(:group, :comment, copy(data, ts, te))
     };
 
@@ -475,10 +456,10 @@
     #
     #   (?imxdau-imx:subexp)  option on/off for subexp
     # ------------------------------------------------------------------------
-    group_open . group_options >group_opened {
+    (group_open . group_options) >group_opened {
       text = copy(data, ts, te)
       if text[2..-1] =~ /([^\-mixdau:]|^$)|-.*([dau])/
-        validation_error(:group_option, $1 || "-#{$2}", text)
+        raise ValidationError.for(:group_option, $1 || "-#{$2}", text)
       end
       emit_options(text)
     };
@@ -489,7 +470,7 @@
     #   (?<=subexp)         look-behind
     #   (?<!subexp)         negative look-behind
     # ------------------------------------------------------------------------
-    group_open . assertion_type >group_opened {
+    (group_open . assertion_type) >group_opened {
       case text = copy(data, ts, te)
       when '(?=';  emit(:assertion, :lookahead,    text)
       when '(?!';  emit(:assertion, :nlookahead,   text)
@@ -506,14 +487,14 @@
     #   (?'name'subexp)     named group (single quoted version)
     #   (subexp)            captured group
     # ------------------------------------------------------------------------
-    group_open . group_type >group_opened {
+    (group_open . group_type) >group_opened {
       case text = copy(data, ts, te)
       when '(?:';  emit(:group, :passive,      text)
       when '(?>';  emit(:group, :atomic,       text)
       when '(?~';  emit(:group, :absence,      text)
 
       when /^\(\?(?:<>|'')/
-        validation_error(:group, 'named group', 'name is empty')
+        raise ValidationError.for(:group, 'named group', 'name is empty')
 
       when /^\(\?<[^>]+>/
         emit(:group, :named_ab,  text)
@@ -533,7 +514,7 @@
       if conditional_stack.last == group_depth + 1
         conditional_stack.pop
         emit(:conditional, :close, ')')
-      else
+      elsif group_depth >= 0
         if spacing_stack.length > 1 &&
            spacing_stack.last[:depth] == group_depth + 1
           spacing_stack.pop
@@ -541,41 +522,43 @@
         end
 
         emit(:group, :close, ')')
+      else
+        raise ValidationError.for(:group, 'group', 'unmatched close parenthesis')
       end
     };
 
 
     # Group backreference, named and numbered
     # ------------------------------------------------------------------------
-    backslash . (group_name_backref | group_number_backref) > (backslashed, 4) {
+    backslash . (group_ref) > (backslashed, 4) {
       case text = copy(data, ts, te)
-      when /^\\k(<>|'')/
-        validation_error(:backref, 'backreference', 'ref ID is empty')
-      when /^\\k(.)[^\p{digit}\-][^+\-]*\D$/
+      when /^\\k(.)[^0-9\-][^+\-]*['>]$/
         emit(:backref, $1 == '<' ? :name_ref_ab : :name_ref_sq, text)
-      when /^\\k(.)\d+\D$/
+      when /^\\k(.)[1-9]\d*['>]$/
         emit(:backref, $1 == '<' ? :number_ref_ab : :number_ref_sq, text)
-      when /^\\k(.)-\d+\D$/
+      when /^\\k(.)-[1-9]\d*['>]$/
         emit(:backref, $1 == '<' ? :number_rel_ref_ab : :number_rel_ref_sq, text)
-      when /^\\k(.)[^\p{digit}\-].*[+\-]\d+\D$/
+      when /^\\k(.)[^0-9\-].*[+\-]\d+['>]$/
         emit(:backref, $1 == '<' ? :name_recursion_ref_ab : :name_recursion_ref_sq, text)
-      when /^\\k(.)-?\d+[+\-]\d+\D$/
+      when /^\\k(.)-?[1-9]\d*[+\-]\d+['>]$/
         emit(:backref, $1 == '<' ? :number_recursion_ref_ab : :number_recursion_ref_sq, text)
+      else
+        raise ValidationError.for(:backref, 'backreference', 'invalid ref ID')
       end
     };
 
     # Group call, named and numbered
     # ------------------------------------------------------------------------
-    backslash . (group_name_call | group_number_call) > (backslashed, 4) {
+    backslash . (group_call) > (backslashed, 4) {
       case text = copy(data, ts, te)
-      when /^\\g(<>|'')/
-        validation_error(:backref, 'subexpression call', 'ref ID is empty')
-      when /^\\g(.)[^\p{digit}+\->][^+\-]*/
+      when /^\\g(.)[^0-9+\-].*['>]$/
         emit(:backref, $1 == '<' ? :name_call_ab : :name_call_sq, text)
-      when /^\\g(.)\d+\D$/
+      when /^\\g(.)\d+['>]$/
         emit(:backref, $1 == '<' ? :number_call_ab : :number_call_sq, text)
       when /^\\g(.)[+-]\d+/
         emit(:backref, $1 == '<' ? :number_rel_call_ab : :number_rel_call_sq, text)
+      else
+        raise ValidationError.for(:backref, 'subexpression call', 'invalid ref ID')
       end
     };
 
@@ -649,72 +632,11 @@
   *|;
 }%%
 
-# THIS IS A GENERATED FILE, DO NOT EDIT DIRECTLY
-# This file was generated from lib/regexp_parser/scanner/scanner.rl
-
-require 'regexp_parser/error'
+require 'regexp_parser/scanner/errors/scanner_error'
+require 'regexp_parser/scanner/errors/premature_end_error'
+require 'regexp_parser/scanner/errors/validation_error'
 
 class Regexp::Scanner
-  # General scanner error (catch all)
-  class ScannerError < Regexp::Parser::Error; end
-
-  # Base for all scanner validation errors
-  class ValidationError < Regexp::Parser::Error
-    def initialize(reason)
-      super reason
-    end
-  end
-
-  # Unexpected end of pattern
-  class PrematureEndError < ScannerError
-    def initialize(where = '')
-      super "Premature end of pattern at #{where}"
-    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
-
   # Scans the given regular expression text, or Regexp object and collects the
   # emitted token into an array that gets returned at the end. If a block is
   # given, it gets called for each emitted token.
@@ -891,24 +813,8 @@ class Regexp::Scanner
 
   def emit_meta_control_sequence(data, ts, te, token)
     if data.last < 0x00 || data.last > 0x7F
-      validation_error(:sequence, 'escape', token.to_s)
+      raise ValidationError.for(:sequence, 'escape', token.to_s)
     end
     emit(:escape, token, copy(data, ts-1, te))
   end
-
-  # Centralizes and unifies the handling of validation related
-  # errors.
-  def validation_error(type, what, reason = nil)
-    error =
-      case type
-      when :backref      then InvalidBackrefError.new(what, reason)
-      when :group        then InvalidGroupError.new(what, reason)
-      when :group_option then InvalidGroupOption.new(what, reason)
-      when :posix_class  then UnknownPosixClassError.new(what)
-      when :property     then UnknownUnicodePropertyError.new(what)
-      when :sequence     then InvalidSequenceError.new(what, reason)
-      end
-
-    raise error # unless @@config.validation_ignore
-  end
 end # module Regexp::Scanner