rouge 3.1.0 → 3.18.0

data/lib/rouge/lexers/console.rb

@@ -1,17 +1,53 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
+    # The {ConsoleLexer} class is intended to lex content that represents the
+    # text that would display in a console/terminal. As distinct from the
+    # {Shell} lexer, {ConsoleLexer} will try to parse out the prompt from each
+    # line before passing the remainder of the line to the language lexer for
+    # the shell (by default, the {Shell} lexer).
+    #
+    # The {ConsoleLexer} class accepts five options:
+    # 1. **lang**: the shell language to lex (default: `shell`);
+    # 2. **output**: the output language (default: `plaintext?token=Generic.Output`);
+    # 3. **prompt**: comma-separated list of strings that indicate the end of a
+    #    prompt (default: `$,#,>,;`);
+    # 4. **comments**: whether to enable comments.
+    # 5. **error**: comma-separated list of strings that indicate the start of an
+    #    error message
+    #
+    # The comments option, if enabled, will lex lines that begin with a `#` as a
+    # comment. Please note that this option will only work if the prompt is
+    # either not manually specified or, if manually specified, does not include
+    # the `#` character.
+    #
+    # Most Markdown lexers that recognise GitHub-Flavored Markdown syntax, will
+    # pass the language string to Rouge as written in the original document.
+    # This allows an end user to pass options to {ConsoleLexer} by passing them
+    # as CGI-style parameters as in the example below.
+    #
+    # @example
+    # <pre>Here's some regular text.
+    #
+    # ```console?comments=true
+    # # This is a comment
+    # $ cp foo bar
+    # ```
+    #
+    # Some more regular text.</pre>
     class ConsoleLexer < Lexer
       tag 'console'
       aliases 'terminal', 'shell_session', 'shell-session'
       filenames '*.cap'
-      desc 'A generic lexer for shell sessions. Accepts ?lang and ?output lexer options, a ?prompt option, and ?comments to enable # comments.'
+      desc 'A generic lexer for shell sessions. Accepts ?lang and ?output lexer options, a ?prompt option, ?comments to enable # comments, and ?error to handle error messages.'
 
       option :lang, 'the shell language to lex (default: shell)'
       option :output, 'the output language (default: plaintext?token=Generic.Output)'
       option :prompt, 'comma-separated list of strings that indicate the end of a prompt. (default: $,#,>,;)'
       option :comments, 'enable hash-comments at the start of a line - otherwise interpreted as a prompt. (default: false, implied by ?prompt not containing `#`)'
+      option :error, 'comma-separated list of strings that indicate the start of an error message'
 
       def initialize(*)
         super
@@ -19,20 +55,7 @@ module Rouge
         @lang = lexer_option(:lang) { 'shell' }
         @output = lexer_option(:output) { PlainText.new(token: Generic::Output) }
         @comments = bool_option(:comments) { :guess }
-      end
-
-      def prompt_regex
-        @prompt_regex ||= begin
-          /^#{prompt_prefix_regex}(?:#{end_chars.map(&Regexp.method(:escape)).join('|')})/
-        end
-      end
-
-      def end_chars
-        @end_chars ||= if @prompt.any?
-          @prompt.reject { |c| c.empty? }
-        else
-          %w($ # > ;)
-        end
+        @error = list_option(:error) { nil }
       end
 
       # whether to allow comments. if manually specifying a prompt that isn't
@@ -46,11 +69,23 @@ module Rouge
         end
       end
 
-      def prompt_prefix_regex
-        if allow_comments?
-          /[^<#]*?/m
+      def comment_regex
+        /\A\s*?#/
+      end
+
+      def end_chars
+        @end_chars ||= if @prompt.any?
+          @prompt.reject { |c| c.empty? }
+        elsif allow_comments?
+          %w($ > ;)
         else
-          /.*?/m
+          %w($ # > ;)
+        end
+      end
+
+      def error_regex
+        @error_regex ||= if @error.any?
+          /^(?:#{@error.map(&Regexp.method(:escape)).join('|')})/
         end
       end
 
@@ -67,6 +102,10 @@ module Rouge
         end
       end
 
+      def line_regex
+        /(\\.|[^\\])*?(\n|$)/m
+      end
+
       def output_lexer
         @output_lexer ||= case @output
         when nil
@@ -80,25 +119,12 @@ module Rouge
         end
       end
 
-      def line_regex
-        /(\\.|[^\\])*?(\n|$)/m
-      end
-
-      def comment_regex
-        /\A\s*?#/
-      end
-
-      def stream_tokens(input, &output)
-        input = StringScanner.new(input)
-        lang_lexer.reset!
-        output_lexer.reset!
-
-        process_line(input, &output) while !input.eos?
-      end
-
       def process_line(input, &output)
         input.scan(line_regex)
 
+        # As a nicety, support the use of elisions in input text. A user can
+        # write a line with only `<...>` or one or more `.` characters and
+        # Rouge will treat it as a comment.
         if input[0] =~ /\A\s*(?:<[.]+>|[.]+)\s*\z/
           puts "console: matched snip #{input[0].inspect}" if @debug
           output_lexer.reset!
@@ -115,22 +141,50 @@ module Rouge
           # before we pass to the lang lexer so it can determine where
           # the "real" beginning of the line is
           $' =~ /\A\s*/
-          yield Text, $& unless $&.empty?
+          yield Text::Whitespace, $& unless $&.empty?
 
-          lang_lexer.lex($', continue: true, &output)
+          lang_lexer.continue_lex($', &output)
         elsif comment_regex =~ input[0].strip
           puts "console: matched comment #{input[0].inspect}" if @debug
           output_lexer.reset!
           lang_lexer.reset!
 
           yield Comment, input[0]
+        elsif error_regex =~ input[0]
+          puts "console: matched error #{input[0].inspect}" if @debug
+          output_lexer.reset!
+          lang_lexer.reset!
+
+          yield Generic::Error, input[0]
         else
           puts "console: matched output #{input[0].inspect}" if @debug
           lang_lexer.reset!
 
-          output_lexer.lex(input[0], continue: true, &output)
+          output_lexer.continue_lex(input[0], &output)
         end
       end
+
+      def prompt_prefix_regex
+        if allow_comments?
+          /[^<#]*?/m
+        else
+          /.*?/m
+        end
+      end
+
+      def prompt_regex
+        @prompt_regex ||= begin
+          /^#{prompt_prefix_regex}(?:#{end_chars.map(&Regexp.method(:escape)).join('|')})/
+        end
+      end
+
+      def stream_tokens(input, &output)
+        input = StringScanner.new(input)
+        lang_lexer.reset!
+        output_lexer.reset!
+
+        process_line(input, &output) while !input.eos?
+      end
     end
   end
 end

data/lib/rouge/lexers/coq.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -57,7 +58,7 @@ module Rouge
 
       def self.keyopts
         @keyopts ||= Set.new %w(
-          := => -> /\\ \\/ _ ; :> :
+          := => -> /\\ \\/ _ ; :> : ⇒ → ↔ ⇔ ≔ ≡ ∀ ∃ ∧ ∨ ¬ ⊤ ⊥ ⊢ ⊨ ∈
         )
       end
 
@@ -89,8 +90,8 @@ module Rouge
       set_options = /(Set|Unset)(\s+)(Universe|Printing|Implicit|Strict)(\s+)(Polymorphism|All|Notations|Arguments|Universes|Implicit)(\s*)\./m
 
       state :root do
-        rule /[(][*](?![)])/, Comment, :comment
-        rule /\s+/m, Text::Whitespace
+        rule %r/[(][*](?![)])/, Comment, :comment
+        rule %r/\s+/m, Text::Whitespace
         rule module_type do |m|
           token Keyword , 'Module'
           token Text::Whitespace , m[1]
@@ -112,42 +113,45 @@ module Rouge
           @continue = false
           push :continue_id
         end
-        rule /\/\\/, Operator
-        rule /\\\//, Operator
-        rule operator do |m|
+        rule %r(/\\), Operator
+        rule %r/\\\//, Operator
+
+        rule %r/-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
+        rule %r/\d[\d_]*/, Num::Integer
+
+        rule %r/'(?:(\\[\\"'ntbr ])|(\\[0-9]{3})|(\\x\h{2}))'/, Str::Char
+        rule %r/'/, Keyword
+        rule %r/"/, Str::Double, :string
+        rule %r/[~?]#{id}/, Name::Variable
+
+        rule %r/./ do |m|
           match = m[0]
           if self.class.keyopts.include? match
             token Punctuation
-          else
+          elsif match =~ operator
             token Operator
+          else
+            token Error
           end
         end
-
-        rule /-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
-        rule /\d[\d_]*/, Num::Integer
-
-        rule /'(?:(\\[\\"'ntbr ])|(\\[0-9]{3})|(\\x\h{2}))'/, Str::Char
-        rule /'/, Keyword
-        rule /"/, Str::Double, :string
-        rule /[~?]#{id}/, Name::Variable
       end
 
       state :comment do
-        rule /[^(*)]+/, Comment
+        rule %r/[^(*)]+/, Comment
         rule(/[(][*]/) { token Comment; push }
-        rule /[*][)]/, Comment, :pop!
-        rule /[(*)]/, Comment
+        rule %r/[*][)]/, Comment, :pop!
+        rule %r/[(*)]/, Comment
       end
 
       state :string do
-        rule /[^\\"]+/, Str::Double
+        rule %r/(?:\\")+|[^"]/, Str::Double
         mixin :escape_sequence
-        rule /\\\n/, Str::Double
-        rule /"/, Str::Double, :pop!
+        rule %r/\\\n/, Str::Double
+        rule %r/"/, Str::Double, :pop!
       end
 
       state :escape_sequence do
-        rule /\\[\\"'ntbr]/, Str::Escape
+        rule %r/\\[\\"'ntbr]/, Str::Escape
       end
 
       state :continue_id do
@@ -170,7 +174,7 @@ module Rouge
           @continue = false
           pop!
         end
-        rule // do
+        rule %r// do
           if @continue
             token Name::Constant , @name
           else

data/lib/rouge/lexers/cpp.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -16,15 +17,15 @@ module Rouge
                 '*.cc',  '*.hh',
                 '*.cxx', '*.hxx',
                 '*.pde', '*.ino',
-                '*.tpp'
+                '*.tpp', '*.h'
       mimetypes 'text/x-c++hdr', 'text/x-c++src'
 
       def self.keywords
         @keywords ||= super + Set.new(%w(
-          asm auto catch const_cast delete dynamic_cast explicit export
-          friend mutable namespace new operator private protected public
-          reinterpret_cast restrict size_of static_cast template this throw
-          throws typeid typename using virtual final override
+          asm auto catch const_cast delete dynamic_cast explicit export friend
+          mutable namespace new operator private protected public
+          reinterpret_cast restrict size_of static_cast this throw throws
+          typeid typename using virtual final override
 
           alignas alignof constexpr decltype noexcept static_assert
           thread_local try
@@ -48,7 +49,7 @@ module Rouge
 
       prepend :root do
         # Offload C++ extensions, http://offload.codeplay.com/
-        rule /(?:__offload|__blockingoffload|__outer)\b/, Keyword::Pseudo
+        rule %r/(?:__offload|__blockingoffload|__outer)\b/, Keyword::Pseudo
       end
 
       # digits with optional inner quotes
@@ -56,23 +57,33 @@ module Rouge
       dq = /\d('?\d)*/
 
       prepend :statements do
-        rule /class\b/, Keyword, :classname
+        rule %r/(class|struct)\b/, Keyword, :classname
+        rule %r/template\b/, Keyword, :template
+        rule %r/\d+(\.\d+)?(?:h|(?:min)|s|(?:ms)|(?:us)|(?:ns))/, Num::Other
         rule %r((#{dq}[.]#{dq}?|[.]#{dq})(e[+-]?#{dq}[lu]*)?)i, Num::Float
         rule %r(#{dq}e[+-]?#{dq}[lu]*)i, Num::Float
-        rule /0x\h('?\h)*[lu]*/i, Num::Hex
-        rule /0[0-7]('?[0-7])*[lu]*/i, Num::Oct
-        rule /#{dq}[lu]*/i, Num::Integer
-        rule /\bnullptr\b/, Name::Builtin
-        rule /(?:u8|u|U|L)?R"([a-zA-Z0-9_{}\[\]#<>%:;.?*\+\-\/\^&|~!=,"']{,16})\(.*?\)\1"/m, Str
+        rule %r/0x\h('?\h)*[lu]*/i, Num::Hex
+        rule %r/0b[01]+(?:_[01]+)*/, Num::Bin
+        rule %r/0[0-7]('?[0-7])*[lu]*/i, Num::Oct
+        rule %r/#{dq}[lu]*/i, Num::Integer
+        rule %r/\bnullptr\b/, Name::Builtin
+        rule %r/(?:u8|u|U|L)?R"([a-zA-Z0-9_{}\[\]#<>%:;.?*\+\-\/\^&|~!=,"']{,16})\(.*?\)\1"/m, Str
       end
 
       state :classname do
         rule id, Name::Class, :pop!
 
         # template specification
-        rule /\s*(?=>)/m, Text, :pop!
+        rule %r/\s*(?=>)/m, Text, :pop!
+        rule %r/[.]{3}/, Operator
         mixin :whitespace
       end
+
+      state :template do
+        rule %r/>/, Punctuation, :pop!
+        rule %r/typename\b/, Keyword, :classname
+        mixin :root
+      end
     end
   end
 end

data/lib/rouge/lexers/crystal.rb

@@ -0,0 +1,430 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Crystal < RegexLexer
+      title "Crystal"
+      desc "Crystal The Programming Language (crystal-lang.org)"
+      tag 'crystal'
+      aliases 'cr'
+      filenames '*.cr'
+
+      mimetypes 'text/x-crystal', 'application/x-crystal'
+
+      def self.detect?(text)
+        return true if text.shebang? 'crystal'
+      end
+
+      state :symbols do
+        # symbols
+        rule %r(
+          :  # initial :
+          @{0,2} # optional ivar, for :@foo and :@@foo
+          [a-z_]\w*[!?]? # the symbol
+        )xi, Str::Symbol
+
+        # special symbols
+        rule %r(:(?:\*\*|[-+]@|[/\%&\|^`~]|\[\]=?|<<|>>|<=?>|<=?|===?)),
+          Str::Symbol
+
+        rule %r/:'(\\\\|\\'|[^'])*'/, Str::Symbol
+        rule %r/:"/, Str::Symbol, :simple_sym
+      end
+
+      state :sigil_strings do
+        # %-sigiled strings
+        # %(abc), %[abc], %<abc>, %.abc., %r.abc., etc
+        delimiter_map = { '{' => '}', '[' => ']', '(' => ')', '<' => '>' }
+        rule %r/%([rqswQWxiI])?([^\w\s])/ do |m|
+          open = Regexp.escape(m[2])
+          close = Regexp.escape(delimiter_map[m[2]] || m[2])
+          interp = /[rQWxI]/ === m[1]
+          toktype = Str::Other
+
+          puts "    open: #{open.inspect}" if @debug
+          puts "    close: #{close.inspect}" if @debug
+
+          # regexes
+          if m[1] == 'r'
+            toktype = Str::Regex
+            push :regex_flags
+          end
+
+          token toktype
+
+          push do
+            rule %r/\\[##{open}#{close}\\]/, Str::Escape
+            # nesting rules only with asymmetric delimiters
+            if open != close
+              rule %r/#{open}/ do
+                token toktype
+                push
+              end
+            end
+            rule %r/#{close}/, toktype, :pop!
+
+            if interp
+              mixin :string_intp_escaped
+              rule %r/#/, toktype
+            else
+              rule %r/[\\#]/, toktype
+            end
+
+            rule %r/[^##{open}#{close}\\]+/m, toktype
+          end
+        end
+      end
+
+      state :strings do
+        mixin :symbols
+        rule %r/\b[a-z_]\w*?[?!]?:\s+/, Str::Symbol, :expr_start
+        rule %r/'(\\\\|\\'|[^'])*'/, Str::Single
+        rule %r/"/, Str::Double, :simple_string
+        rule %r/(?<!\.)`/, Str::Backtick, :simple_backtick
+      end
+
+      state :regex_flags do
+        rule %r/[mixounse]*/, Str::Regex, :pop!
+      end
+
+      # double-quoted string and symbol
+      [[:string, Str::Double, '"'],
+       [:sym, Str::Symbol, '"'],
+       [:backtick, Str::Backtick, '`']].each do |name, tok, fin|
+        state :"simple_#{name}" do
+          mixin :string_intp_escaped
+          rule %r/[^\\#{fin}#]+/m, tok
+          rule %r/[\\#]/, tok
+          rule %r/#{fin}/, tok, :pop!
+        end
+      end
+
+      keywords = %w(
+        BEGIN END alias begin break case defined\? do else elsif end
+        ensure for if ifdef in next redo rescue raise retry return super then
+        undef unless until when while yield lib fun type of as
+      )
+
+      keywords_pseudo = %w(
+        initialize new loop include extend raise attr_reader attr_writer
+        attr_accessor alias_method attr catch throw private module_function
+        public protected true false nil __FILE__ __LINE__
+        getter getter? getter! property property? property! struct record
+      )
+
+      builtins_g = %w(
+        abort ancestors at_exit
+        caller catch chomp chop clone constants
+        display dup eval exec exit extend fail fork format freeze
+        getc gets global_variables gsub hash id included_modules
+        inspect instance_eval instance_method instance_methods
+        lambda loop method method_missing
+        methods module_eval name object_id open p print printf
+        proc putc puts raise rand
+        readline readlines require scan select self send
+        sleep split sprintf srand sub syscall system
+        test throw to_a to_s trap warn
+      )
+
+      builtins_q = %w(
+        eql equal include is_a iterator kind_of nil
+      )
+
+      builtins_b = %w(chomp chop exit gsub sub)
+
+      start do
+        push :expr_start
+        @heredoc_queue = []
+      end
+
+      state :whitespace do
+        mixin :inline_whitespace
+        rule %r/\n\s*/m, Text, :expr_start
+        rule %r/#.*$/, Comment::Single
+
+        rule %r(=begin\b.*?\n=end\b)m, Comment::Multiline
+      end
+
+      state :inline_whitespace do
+        rule %r/[ \t\r]+/, Text
+      end
+
+      state :root do
+        mixin :whitespace
+        rule %r/__END__/, Comment::Preproc, :end_part
+
+        rule %r/0_?[0-7]+(?:_[0-7]+)*/, Num::Oct
+        rule %r/0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*/, Num::Hex
+        rule %r/0b[01]+(?:_[01]+)*/, Num::Bin
+        rule %r/\d+\.\d+(e[\+\-]?\d+)?/, Num::Float
+        rule %r/[\d]+(?:_\d+)*/, Num::Integer
+
+        rule %r/@\[([^\]]+)\]/, Name::Decorator
+
+        # names
+        rule %r/@@[a-z_]\w*/i, Name::Variable::Class
+        rule %r/@[a-z_]\w*/i, Name::Variable::Instance
+        rule %r/\$\w+/, Name::Variable::Global
+        rule %r(\$[!@&`'+~=/\\,;.<>_*\$?:"]), Name::Variable::Global
+        rule %r/\$-[0adFiIlpvw]/, Name::Variable::Global
+        rule %r/::/, Operator
+
+        mixin :strings
+
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword, :expr_start
+        rule %r/(?:#{keywords_pseudo.join('|')})\b/, Keyword::Pseudo, :expr_start
+
+        rule %r(
+          (module)
+          (\s+)
+          ([a-zA-Z_][a-zA-Z0-9_]*(::[a-zA-Z_][a-zA-Z0-9_]*)*)
+        )x do
+          groups Keyword, Text, Name::Namespace
+        end
+
+        rule %r/(def\b)(\s*)/ do
+          groups Keyword, Text
+          push :funcname
+        end
+
+        rule %r/(class\b)(\s*)/ do
+          groups Keyword, Text
+          push :classname
+        end
+
+        rule %r/(?:#{builtins_q.join('|')})[?]/, Name::Builtin, :expr_start
+        rule %r/(?:#{builtins_b.join('|')})!/,  Name::Builtin, :expr_start
+        rule %r/(?<!\.)(?:#{builtins_g.join('|')})\b/,
+          Name::Builtin, :method_call
+
+        mixin :has_heredocs
+
+        # `..` and `...` for ranges must have higher priority than `.`
+        # Otherwise, they will be parsed as :method_call
+        rule %r/\.{2,3}/, Operator, :expr_start
+
+        rule %r/[A-Z][a-zA-Z0-9_]*/, Name::Constant, :method_call
+        rule %r/(\.|::)(\s*)([a-z_]\w*[!?]?|[*%&^`~+-\/\[<>=])/ do
+          groups Punctuation, Text, Name::Function
+          push :method_call
+        end
+
+        rule %r/[a-zA-Z_]\w*[?!]/, Name, :expr_start
+        rule %r/[a-zA-Z_]\w*/, Name, :method_call
+        rule %r/\*\*|<<?|>>?|>=|<=|<=>|=~|={3}|!~|&&?|\|\||\./,
+          Operator, :expr_start
+        rule %r/[-+\/*%=<>&!^|~]=?/, Operator, :expr_start
+        rule(/[?]/) { token Punctuation; push :ternary; push :expr_start }
+        rule %r<[\[({,:\\;/]>, Punctuation, :expr_start
+        rule %r<[\])}]>, Punctuation
+      end
+
+      state :has_heredocs do
+        rule %r/(?<!\w)(<<[-~]?)(["`']?)([a-zA-Z_]\w*)(\2)/ do |m|
+          token Operator, m[1]
+          token Name::Constant, "#{m[2]}#{m[3]}#{m[4]}"
+          @heredoc_queue << [['<<-', '<<~'].include?(m[1]), m[3]]
+          push :heredoc_queue unless state? :heredoc_queue
+        end
+
+        rule %r/(<<[-~]?)(["'])(\2)/ do |m|
+          token Operator, m[1]
+          token Name::Constant, "#{m[2]}#{m[3]}#{m[4]}"
+          @heredoc_queue << [['<<-', '<<~'].include?(m[1]), '']
+          push :heredoc_queue unless state? :heredoc_queue
+        end
+      end
+
+      state :heredoc_queue do
+        rule %r/(?=\n)/ do
+          goto :resolve_heredocs
+        end
+
+        mixin :root
+      end
+
+      state :resolve_heredocs do
+        mixin :string_intp_escaped
+
+        rule %r/\n/, Str::Heredoc, :test_heredoc
+        rule %r/[#\\\n]/, Str::Heredoc
+        rule %r/[^#\\\n]+/, Str::Heredoc
+      end
+
+      state :test_heredoc do
+        rule %r/[^#\\\n]*$/ do |m|
+          tolerant, heredoc_name = @heredoc_queue.first
+          check = tolerant ? m[0].strip : m[0].rstrip
+
+          # check if we found the end of the heredoc
+          puts "    end heredoc check #{check.inspect} = #{heredoc_name.inspect}" if @debug
+          if check == heredoc_name
+            @heredoc_queue.shift
+            # if there's no more, we're done looking.
+            pop! if @heredoc_queue.empty?
+            token Name::Constant
+          else
+            token Str::Heredoc
+          end
+
+          pop!
+        end
+
+        rule(//) { pop! }
+      end
+
+      state :funcname do
+        rule %r/\s+/, Text
+        rule %r/\(/, Punctuation, :defexpr
+        rule %r(
+          (?:([a-zA-Z_]\w*)(\.))?
+          (
+            [a-zA-Z_]\w*[!?]? |
+            \*\*? | [-+]@? | [/%&\|^`~] | \[\]=? |
+            <<? | >>? | <=>? | >= | ===?
+          )
+        )x do |m|
+          puts "matches: #{[m[0], m[1], m[2], m[3]].inspect}" if @debug
+          groups Name::Class, Operator, Name::Function
+          pop!
+        end
+
+        rule(//) { pop! }
+      end
+
+      state :classname do
+        rule %r/\s+/, Text
+        rule %r/\(/ do
+          token Punctuation
+          push :defexpr
+          push :expr_start
+        end
+
+        # class << expr
+        rule %r/<</ do
+          token Operator
+          goto :expr_start
+        end
+
+        rule %r/[A-Z_]\w*/, Name::Class, :pop!
+
+        rule(//) { pop! }
+      end
+
+      state :ternary do
+        rule(/:(?!:)/) { token Punctuation; goto :expr_start }
+
+        mixin :root
+      end
+
+      state :defexpr do
+        rule %r/(\))(\.|::)?/ do
+          groups Punctuation, Operator
+          pop!
+        end
+        rule %r/\(/ do
+          token Punctuation
+          push :defexpr
+          push :expr_start
+        end
+
+        mixin :root
+      end
+
+      state :in_interp do
+        rule %r/}/, Str::Interpol, :pop!
+        mixin :root
+      end
+
+      state :string_intp do
+        rule %r/[#][{]/, Str::Interpol, :in_interp
+        rule %r/#(@@?|\$)[a-z_]\w*/i, Str::Interpol
+      end
+
+      state :string_intp_escaped do
+        mixin :string_intp
+        rule %r/\\([\\abefnrstv#"']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})/,
+          Str::Escape
+        rule %r/\\./, Str::Escape
+      end
+
+      state :method_call do
+        rule %r(/) do
+          token Operator
+          goto :expr_start
+        end
+
+        rule(/(?=\n)/) { pop! }
+
+        rule(//) { goto :method_call_spaced }
+      end
+
+      state :method_call_spaced do
+        mixin :whitespace
+
+        rule %r([%/]=) do
+          token Operator
+          goto :expr_start
+        end
+
+        rule %r((/)(?=\S|\s*/)) do
+          token Str::Regex
+          goto :slash_regex
+        end
+
+        mixin :sigil_strings
+
+        rule(%r((?=\s*/))) { pop! }
+
+        rule(/\s+/) { token Text; goto :expr_start }
+        rule(//) { pop! }
+      end
+
+      state :expr_start do
+        mixin :inline_whitespace
+
+        rule %r(/) do
+          token Str::Regex
+          goto :slash_regex
+        end
+
+        # char operator.  ?x evaulates to "x", unless there's a digit
+        # beforehand like x>=0?n[x]:""
+        rule %r(
+          [?](\\[MC]-)*     # modifiers
+          (\\([\\abefnrstv\#"']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})|\S)
+          (?!\w)
+        )x, Str::Char, :pop!
+
+        # special case for using a single space.  Ruby demands that
+        # these be in a single line, otherwise it would make no sense.
+        rule %r/(\s*)(%[rqswQWxiI]? \S* )/ do
+          groups Text, Str::Other
+          pop!
+        end
+
+        mixin :sigil_strings
+
+        rule(//) { pop! }
+      end
+
+      state :slash_regex do
+        mixin :string_intp
+        rule %r(\\\\), Str::Regex
+        rule %r(\\/), Str::Regex
+        rule %r([\\#]), Str::Regex
+        rule %r([^\\/#]+)m, Str::Regex
+        rule %r(/) do
+          token Str::Regex
+          goto :regex_flags
+        end
+      end
+
+      state :end_part do
+        # eat up the rest of the stream as Comment::Preproc
+        rule %r/.+/m, Comment::Preproc, :pop!
+      end
+    end
+  end
+end