lazy_record 0.2.1 → 0.2.2

data/vendor/bundle/gems/coderay-1.1.1/lib/coderay/scanners/python.rb

@@ -1,287 +0,0 @@
-module CodeRay
-module Scanners
-  
-  # Scanner for Python. Supports Python 3.
-  # 
-  # Based on pygments' PythonLexer, see
-  # http://dev.pocoo.org/projects/pygments/browser/pygments/lexers/agile.py.
-  class Python < Scanner
-    
-    register_for :python
-    file_extension 'py'
-    
-    KEYWORDS = [
-      'and', 'as', 'assert', 'break', 'class', 'continue', 'def',
-      'del', 'elif', 'else', 'except', 'finally', 'for',
-      'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not',
-      'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield',
-      'nonlocal',  # new in Python 3
-    ]  # :nodoc:
-    
-    OLD_KEYWORDS = [
-      'exec', 'print',  # gone in Python 3
-    ]  # :nodoc:
-    
-    PREDEFINED_METHODS_AND_TYPES = %w[
-      __import__ abs all any apply basestring bin bool buffer
-      bytearray bytes callable chr classmethod cmp coerce compile
-      complex delattr dict dir divmod enumerate eval execfile exit
-      file filter float frozenset getattr globals hasattr hash hex id
-      input int intern isinstance issubclass iter len list locals
-      long map max min next object oct open ord pow property range
-      raw_input reduce reload repr reversed round set setattr slice
-      sorted staticmethod str sum super tuple type unichr unicode
-      vars xrange zip
-    ]  # :nodoc:
-    
-    PREDEFINED_EXCEPTIONS = %w[
-      ArithmeticError AssertionError AttributeError
-      BaseException DeprecationWarning EOFError EnvironmentError
-      Exception FloatingPointError FutureWarning GeneratorExit IOError
-      ImportError ImportWarning IndentationError IndexError KeyError
-      KeyboardInterrupt LookupError MemoryError NameError
-      NotImplemented NotImplementedError OSError OverflowError
-      OverflowWarning PendingDeprecationWarning ReferenceError
-      RuntimeError RuntimeWarning StandardError StopIteration
-      SyntaxError SyntaxWarning SystemError SystemExit TabError
-      TypeError UnboundLocalError UnicodeDecodeError
-      UnicodeEncodeError UnicodeError UnicodeTranslateError
-      UnicodeWarning UserWarning ValueError Warning ZeroDivisionError
-    ]  # :nodoc:
-    
-    PREDEFINED_VARIABLES_AND_CONSTANTS = [
-      'False', 'True', 'None',  # "keywords" since Python 3
-      'self', 'Ellipsis', 'NotImplemented',
-    ]  # :nodoc:
-    
-    IDENT_KIND = WordList.new(:ident).
-      add(KEYWORDS, :keyword).
-      add(OLD_KEYWORDS, :old_keyword).
-      add(PREDEFINED_METHODS_AND_TYPES, :predefined).
-      add(PREDEFINED_VARIABLES_AND_CONSTANTS, :predefined_constant).
-      add(PREDEFINED_EXCEPTIONS, :exception)  # :nodoc:
-    
-    NAME = / [[:alpha:]_] \w* /x  # :nodoc:
-    ESCAPE = / [abfnrtv\n\\'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} /x  # :nodoc:
-    UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} | U[a-fA-F0-9]{8} | N\{[-\w ]+\} /x  # :nodoc:
-    
-    OPERATOR = /
-      \.\.\. |          # ellipsis
-      \.(?!\d) |        # dot but not decimal point
-      [,;:()\[\]{}] |   # simple delimiters
-      \/\/=? | \*\*=? | # special math
-      [-+*\/%&|^]=? |   # ordinary math and binary logic
-      [~`] |            # binary complement and inspection
-      <<=? | >>=? | [<>=]=? | !=  # comparison and assignment
-    /x  # :nodoc:
-    
-    STRING_DELIMITER_REGEXP = Hash.new { |h, delimiter|
-      h[delimiter] = Regexp.union delimiter  # :nodoc:
-    }
-    
-    STRING_CONTENT_REGEXP = Hash.new { |h, delimiter|
-      h[delimiter] = / [^\\\n]+? (?= \\ | $ | #{Regexp.escape(delimiter)} ) /x  # :nodoc:
-    }
-    
-    DEF_NEW_STATE = WordList.new(:initial).
-      add(%w(def), :def_expected).
-      add(%w(import from), :include_expected).
-      add(%w(class), :class_expected)  # :nodoc:
-    
-    DESCRIPTOR = /
-      #{NAME}
-      (?: \. #{NAME} )*
-      | \*
-    /x  # :nodoc:
-    
-    DOCSTRING_COMING = /
-      [ \t]* u?r? ("""|''')
-    /x  # :nodoc:
-    
-  protected
-    
-    def scan_tokens encoder, options
-      
-      state = :initial
-      string_delimiter = nil
-      string_raw = false
-      string_type = nil
-      docstring_coming = match?(/#{DOCSTRING_COMING}/o)
-      last_token_dot = false
-      unicode = string.respond_to?(:encoding) && string.encoding.name == 'UTF-8'
-      from_import_state = []
-      
-      until eos?
-        
-        if state == :string
-          if match = scan(STRING_DELIMITER_REGEXP[string_delimiter])
-            encoder.text_token match, :delimiter
-            encoder.end_group string_type
-            string_type = nil
-            state = :initial
-            next
-          elsif string_delimiter.size == 3 && match = scan(/\n/)
-            encoder.text_token match, :content
-          elsif match = scan(STRING_CONTENT_REGEXP[string_delimiter])
-            encoder.text_token match, :content
-          elsif !string_raw && match = scan(/ \\ #{ESCAPE} /ox)
-            encoder.text_token match, :char
-          elsif match = scan(/ \\ #{UNICODE_ESCAPE} /ox)
-            encoder.text_token match, :char
-          elsif match = scan(/ \\ . /x)
-            encoder.text_token match, :content
-          elsif match = scan(/ \\ | $ /x)
-            encoder.end_group string_type
-            string_type = nil
-            encoder.text_token match, :error unless match.empty?
-            state = :initial
-          else
-            raise_inspect "else case \" reached; %p not handled." % peek(1), encoder, state
-          end
-        
-        elsif match = scan(/ [ \t]+ | \\?\n /x)
-          encoder.text_token match, :space
-          if match == "\n"
-            state = :initial if state == :include_expected
-            docstring_coming = true if match?(/#{DOCSTRING_COMING}/o)
-          end
-          next
-        
-        elsif match = scan(/ \# [^\n]* /mx)
-          encoder.text_token match, :comment
-          next
-        
-        elsif state == :initial
-          
-          if match = scan(/#{OPERATOR}/o)
-            encoder.text_token match, :operator
-          
-          elsif match = scan(/(u?r?|b)?("""|"|'''|')/i)
-            modifiers = self[1]
-            string_delimiter = self[2]
-            string_type = docstring_coming ? :docstring : (modifiers == 'b' ? :binary : :string)
-            docstring_coming = false if docstring_coming
-            encoder.begin_group string_type
-            string_raw = false
-            unless modifiers.empty?
-              string_raw = !!modifiers.index(?r)
-              encoder.text_token modifiers, :modifier
-              match = string_delimiter
-            end
-            state = :string
-            encoder.text_token match, :delimiter
-          
-          # TODO: backticks
-          
-          elsif match = scan(unicode ? /#{NAME}/uo : /#{NAME}/o)
-            kind = IDENT_KIND[match]
-            # TODO: keyword arguments
-            kind = :ident if last_token_dot
-            if kind == :old_keyword
-              kind = check(/\(/) ? :ident : :keyword
-            elsif kind == :predefined && check(/ *=/)
-              kind = :ident
-            elsif kind == :keyword
-              state = DEF_NEW_STATE[match]
-              from_import_state << match.to_sym if state == :include_expected
-            end
-            encoder.text_token match, kind
-          
-          elsif match = scan(/@[a-zA-Z0-9_.]+[lL]?/)
-            encoder.text_token match, :decorator
-          
-          elsif match = scan(/0[xX][0-9A-Fa-f]+[lL]?/)
-            encoder.text_token match, :hex
-          
-          elsif match = scan(/0[bB][01]+[lL]?/)
-            encoder.text_token match, :binary
-          
-          elsif match = scan(/(?:\d*\.\d+|\d+\.\d*)(?:[eE][+-]?\d+)?|\d+[eE][+-]?\d+/)
-            if scan(/[jJ]/)
-              match << matched
-              encoder.text_token match, :imaginary
-            else
-              encoder.text_token match, :float
-            end
-          
-          elsif match = scan(/0[oO][0-7]+|0[0-7]+(?![89.eE])[lL]?/)
-            encoder.text_token match, :octal
-          
-          elsif match = scan(/\d+([lL])?/)
-            if self[1] == nil && scan(/[jJ]/)
-              match << matched
-              encoder.text_token match, :imaginary
-            else
-              encoder.text_token match, :integer
-            end
-          
-          else
-            encoder.text_token getch, :error
-          
-          end
-            
-        elsif state == :def_expected
-          state = :initial
-          if match = scan(unicode ? /#{NAME}/uo : /#{NAME}/o)
-            encoder.text_token match, :method
-          else
-            next
-          end
-        
-        elsif state == :class_expected
-          state = :initial
-          if match = scan(unicode ? /#{NAME}/uo : /#{NAME}/o)
-            encoder.text_token match, :class
-          else
-            next
-          end
-          
-        elsif state == :include_expected
-          if match = scan(unicode ? /#{DESCRIPTOR}/uo : /#{DESCRIPTOR}/o)
-            if match == 'as'
-              encoder.text_token match, :keyword
-              from_import_state << :as
-            elsif from_import_state.first == :from && match == 'import'
-              encoder.text_token match, :keyword
-              from_import_state << :import
-            elsif from_import_state.last == :as
-              # encoder.text_token match, match[0,1][unicode ? /[[:upper:]]/u : /[[:upper:]]/] ? :class : :method
-              encoder.text_token match, :ident
-              from_import_state.pop
-            elsif IDENT_KIND[match] == :keyword
-              unscan
-              match = nil
-              state = :initial
-              next
-            else
-              encoder.text_token match, :include
-            end
-          elsif match = scan(/,/)
-            from_import_state.pop if from_import_state.last == :as
-            encoder.text_token match, :operator
-          else
-            from_import_state = []
-            state = :initial
-            next
-          end
-          
-        else
-          raise_inspect 'Unknown state', encoder, state
-          
-        end
-        
-        last_token_dot = match == '.'
-        
-      end
-      
-      if state == :string
-        encoder.end_group string_type
-      end
-      
-      encoder
-    end
-    
-  end
-  
-end
-end

data/vendor/bundle/gems/coderay-1.1.1/lib/coderay/scanners/raydebug.rb

@@ -1,75 +0,0 @@
-require 'set'
-
-module CodeRay
-module Scanners
-  
-  # = Raydebug Scanner
-  # 
-  # Highlights the output of the Encoders::Debug encoder.
-  class Raydebug < Scanner
-    
-    register_for :raydebug
-    file_extension 'raydebug'
-    title 'CodeRay Token Dump'
-    
-  protected
-    
-    def setup
-      super
-      @known_token_kinds = TokenKinds.keys.map(&:to_s).to_set
-    end
-    
-    def scan_tokens encoder, options
-      
-      opened_tokens = []
-      
-      until eos?
-        
-        if match = scan(/\s+/)
-          encoder.text_token match, :space
-          
-        elsif match = scan(/ (\w+) \( ( [^\)\\]* ( \\. [^\)\\]* )* ) /x)
-          kind = self[1]
-          encoder.text_token kind, :class
-          encoder.text_token '(', :operator
-          match = self[2]
-          unless match.empty?
-            if @known_token_kinds.include? kind
-              encoder.text_token match, kind.to_sym
-            else
-              encoder.text_token match, :plain
-            end
-          end
-          encoder.text_token match, :operator if match = scan(/\)/)
-          
-        elsif match = scan(/ (\w+) ([<\[]) /x)
-          encoder.text_token self[1], :class
-          if @known_token_kinds.include? self[1]
-            kind = self[1].to_sym
-          else
-            kind = :unknown
-          end
-          opened_tokens << kind
-          encoder.begin_group kind
-          encoder.text_token self[2], :operator
-          
-        elsif !opened_tokens.empty? && match = scan(/ [>\]] /x)
-          encoder.text_token match, :operator
-          encoder.end_group opened_tokens.pop
-          
-        else
-          encoder.text_token getch, :space
-          
-        end
-        
-      end
-      
-      encoder.end_group opened_tokens.pop until opened_tokens.empty?
-      
-      encoder
-    end
-    
-  end
-  
-end
-end

data/vendor/bundle/gems/coderay-1.1.1/lib/coderay/scanners/ruby.rb

@@ -1,477 +0,0 @@
-module CodeRay
-module Scanners
-  
-  # This scanner is really complex, since Ruby _is_ a complex language!
-  #
-  # It tries to highlight 100% of all common code,
-  # and 90% of strange codes.
-  #
-  # It is optimized for HTML highlighting, and is not very useful for
-  # parsing or pretty printing.
-  class Ruby < Scanner
-    
-    register_for :ruby
-    file_extension 'rb'
-    
-    autoload :Patterns,    CodeRay.coderay_path('scanners', 'ruby', 'patterns')
-    autoload :StringState, CodeRay.coderay_path('scanners', 'ruby', 'string_state')
-    
-    def interpreted_string_state
-      StringState.new :string, true, '"'
-    end
-    
-  protected
-    
-    def setup
-      @state = :initial
-    end
-    
-    def scan_tokens encoder, options
-      state, heredocs = options[:state] || @state
-      heredocs = heredocs.dup if heredocs.is_a?(Array)
-      
-      if state && state.instance_of?(StringState)
-        encoder.begin_group state.type
-      end
-      
-      last_state = nil
-      
-      method_call_expected = false
-      value_expected = true
-      
-      inline_block_stack = nil
-      inline_block_curly_depth = 0
-      
-      if heredocs
-        state = heredocs.shift
-        encoder.begin_group state.type
-        heredocs = nil if heredocs.empty?
-      end
-      
-      # def_object_stack = nil
-      # def_object_paren_depth = 0
-      
-      patterns = Patterns  # avoid constant lookup
-      
-      unicode = string.respond_to?(:encoding) && string.encoding.name == 'UTF-8'
-      
-      until eos?
-        
-        if state.instance_of? ::Symbol
-          
-          if match = scan(/[ \t\f\v]+/)
-            encoder.text_token match, :space
-            
-          elsif match = scan(/\n/)
-            if heredocs
-              unscan  # heredoc scanning needs \n at start
-              state = heredocs.shift
-              encoder.begin_group state.type
-              heredocs = nil if heredocs.empty?
-            else
-              state = :initial if state == :undef_comma_expected
-              encoder.text_token match, :space
-              value_expected = true
-            end
-            
-          elsif match = scan(bol? ? / \#(!)?.* | #{patterns::RUBYDOC_OR_DATA} /ox : /\#.*/)
-            encoder.text_token match, self[1] ? :doctype : :comment
-            
-          elsif match = scan(/\\\n/)
-            if heredocs
-              unscan  # heredoc scanning needs \n at start
-              encoder.text_token scan(/\\/), :space
-              state = heredocs.shift
-              encoder.begin_group state.type
-              heredocs = nil if heredocs.empty?
-            else
-              encoder.text_token match, :space
-            end
-            
-          elsif state == :initial
-            
-            # IDENTS #
-            if !method_call_expected &&
-               match = scan(unicode ? /#{patterns::METHOD_NAME}/uo :
-                                      /#{patterns::METHOD_NAME}/o)
-              
-              kind = patterns::IDENT_KIND[match]
-              if value_expected != :colon_expected && scan(/:(?!:)/)
-                value_expected = true
-                encoder.text_token match, :key
-                encoder.text_token ':',   :operator
-              else
-                value_expected = false
-                if kind == :ident
-                  if match[/\A[A-Z]/] && !(match[/[!?]$/] || match?(/\(/))
-                    kind = :constant
-                  end
-                elsif kind == :keyword
-                  state = patterns::KEYWORD_NEW_STATE[match]
-                  if patterns::KEYWORDS_EXPECTING_VALUE[match]
-                    value_expected = match == 'when' ? :colon_expected : true
-                  end
-                end
-                value_expected = true if !value_expected && check(/#{patterns::VALUE_FOLLOWS}/o)
-                encoder.text_token match, kind
-              end
-              
-            elsif method_call_expected &&
-               match = scan(unicode ? /#{patterns::METHOD_AFTER_DOT}/uo :
-                                      /#{patterns::METHOD_AFTER_DOT}/o)
-              if method_call_expected == '::' && match[/\A[A-Z]/] && !match?(/\(/)
-                encoder.text_token match, :constant
-              else
-                encoder.text_token match, :ident
-              end
-              method_call_expected = false
-              value_expected = check(/#{patterns::VALUE_FOLLOWS}/o)
-              
-            # OPERATORS #
-            elsif !method_call_expected && match = scan(/ (\.(?!\.)|::) | ( \.\.\.? | ==?=? | [,\(\[\{] ) | [\)\]\}] /x)
-              method_call_expected = self[1]
-              value_expected = !method_call_expected && !!self[2]
-              if inline_block_stack
-                case match
-                when '{'
-                  inline_block_curly_depth += 1
-                when '}'
-                  inline_block_curly_depth -= 1
-                  if inline_block_curly_depth == 0  # closing brace of inline block reached
-                    state, inline_block_curly_depth, heredocs = inline_block_stack.pop
-                    inline_block_stack = nil if inline_block_stack.empty?
-                    heredocs = nil if heredocs && heredocs.empty?
-                    encoder.text_token match, :inline_delimiter
-                    encoder.end_group :inline
-                    next
-                  end
-                end
-              end
-              encoder.text_token match, :operator
-              
-            elsif match = scan(unicode ? /#{patterns::SYMBOL}/uo :
-                                         /#{patterns::SYMBOL}/o)
-              case delim = match[1]
-              when ?', ?"
-                encoder.begin_group :symbol
-                encoder.text_token ':', :symbol
-                match = delim.chr
-                encoder.text_token match, :delimiter
-                state = self.class::StringState.new :symbol, delim == ?", match
-              else
-                encoder.text_token match, :symbol
-                value_expected = false
-              end
-              
-            elsif match = scan(/ ' (?:(?>[^'\\]*) ')? | " (?:(?>[^"\\\#]*) ")? /mx)
-              if match.size == 1
-                kind = check(self.class::StringState.simple_key_pattern(match)) ? :key : :string
-                encoder.begin_group kind
-                encoder.text_token match, :delimiter
-                state = self.class::StringState.new kind, match == '"', match  # important for streaming
-              else
-                kind = value_expected == true && scan(/:/) ? :key : :string
-                encoder.begin_group kind
-                encoder.text_token match[0,1], :delimiter
-                encoder.text_token match[1..-2], :content if match.size > 2
-                encoder.text_token match[-1,1], :delimiter
-                encoder.end_group kind
-                encoder.text_token ':', :operator if kind == :key
-                value_expected = false
-              end
-              
-            elsif match = scan(unicode ? /#{patterns::INSTANCE_VARIABLE}/uo :
-                                         /#{patterns::INSTANCE_VARIABLE}/o)
-              value_expected = false
-              encoder.text_token match, :instance_variable
-              
-            elsif value_expected && match = scan(/\//)
-              encoder.begin_group :regexp
-              encoder.text_token match, :delimiter
-              state = self.class::StringState.new :regexp, true, '/'
-              
-            elsif match = scan(value_expected ? /[-+]?#{patterns::NUMERIC}/o : /#{patterns::NUMERIC}/o)
-              if method_call_expected
-                encoder.text_token match, :error
-                method_call_expected = false
-              else
-                kind = self[1] ? :float : :integer  # TODO: send :hex/:octal/:binary
-                match << 'r' if match !~ /e/i && scan(/r/)
-                match << 'i' if scan(/i/)
-                encoder.text_token match, kind
-              end
-              value_expected = false
-              
-            elsif match = scan(/ [-+!~^\/]=? | [:;] | &\. | [*|&]{1,2}=? | >>? /x)
-              value_expected = true
-              encoder.text_token match, :operator
-              
-            elsif value_expected && match = scan(/#{patterns::HEREDOC_OPEN}/o)
-              quote = self[3]
-              delim = self[quote ? 4 : 2]
-              kind = patterns::QUOTE_TO_TYPE[quote]
-              encoder.begin_group kind
-              encoder.text_token match, :delimiter
-              encoder.end_group kind
-              heredocs ||= []  # create heredocs if empty
-              heredocs << self.class::StringState.new(kind, quote != "'", delim,
-                self[1] ? :indented : :linestart)
-              value_expected = false
-              
-            elsif value_expected && match = scan(/#{patterns::FANCY_STRING_START}/o)
-              kind = patterns::FANCY_STRING_KIND[self[1]]
-              encoder.begin_group kind
-              state = self.class::StringState.new kind, patterns::FANCY_STRING_INTERPRETED[self[1]], self[2]
-              encoder.text_token match, :delimiter
-              
-            elsif value_expected && match = scan(/#{patterns::CHARACTER}/o)
-              value_expected = false
-              encoder.text_token match, :integer
-              
-            elsif match = scan(/ %=? | <(?:<|=>?)? | \? /x)
-              value_expected = match == '?' ? :colon_expected : true
-              encoder.text_token match, :operator
-              
-            elsif match = scan(/`/)
-              encoder.begin_group :shell
-              encoder.text_token match, :delimiter
-              state = self.class::StringState.new :shell, true, match
-              
-            elsif match = scan(unicode ? /#{patterns::GLOBAL_VARIABLE}/uo :
-                                         /#{patterns::GLOBAL_VARIABLE}/o)
-              encoder.text_token match, :global_variable
-              value_expected = false
-              
-            elsif match = scan(unicode ? /#{patterns::CLASS_VARIABLE}/uo :
-                                         /#{patterns::CLASS_VARIABLE}/o)
-              encoder.text_token match, :class_variable
-              value_expected = false
-              
-            elsif match = scan(/\\\z/)
-              encoder.text_token match, :space
-              
-            else
-              if method_call_expected
-                method_call_expected = false
-                next
-              end
-              unless unicode
-                # check for unicode
-                $DEBUG_BEFORE, $DEBUG = $DEBUG, false
-                begin
-                  if check(/./mu).size > 1
-                    # seems like we should try again with unicode
-                    unicode = true
-                  end
-                rescue
-                  # bad unicode char; use getch
-                ensure
-                  $DEBUG = $DEBUG_BEFORE
-                end
-                next if unicode
-              end
-              
-              encoder.text_token getch, :error
-              
-            end
-            
-            if last_state
-              state = last_state unless state.is_a?(StringState)  # otherwise, a simple 'def"' results in unclosed tokens
-              last_state = nil
-            end
-            
-          elsif state == :def_expected
-            if match = scan(unicode ? /(?>#{patterns::METHOD_NAME_EX})(?!\.|::)/uo :
-                                      /(?>#{patterns::METHOD_NAME_EX})(?!\.|::)/o)
-              encoder.text_token match, :method
-              state = :initial
-            else
-              last_state = :dot_expected
-              state = :initial
-            end
-            
-          elsif state == :dot_expected
-            if match = scan(/\.|::/)
-              # invalid definition
-              state = :def_expected
-              encoder.text_token match, :operator
-            else
-              state = :initial
-            end
-            
-          elsif state == :module_expected
-            if match = scan(/<</)
-              encoder.text_token match, :operator
-            else
-              state = :initial
-              if match = scan(unicode ? / (?:#{patterns::IDENT}::)* #{patterns::IDENT} /oux :
-                                        / (?:#{patterns::IDENT}::)* #{patterns::IDENT} /ox)
-                encoder.text_token match, :class
-              end
-            end
-            
-          elsif state == :undef_expected
-            state = :undef_comma_expected
-            if match = scan(unicode ? /(?>#{patterns::METHOD_NAME_EX})(?!\.|::)/uo :
-                                      /(?>#{patterns::METHOD_NAME_EX})(?!\.|::)/o)
-              encoder.text_token match, :method
-            elsif match = scan(/#{patterns::SYMBOL}/o)
-              case delim = match[1]
-              when ?', ?"
-                encoder.begin_group :symbol
-                encoder.text_token ':', :symbol
-                match = delim.chr
-                encoder.text_token match, :delimiter
-                state = self.class::StringState.new :symbol, delim == ?", match
-                state.next_state = :undef_comma_expected
-              else
-                encoder.text_token match, :symbol
-              end
-            else
-              state = :initial
-            end
-            
-          elsif state == :undef_comma_expected
-            if match = scan(/,/)
-              encoder.text_token match, :operator
-              state = :undef_expected
-            else
-              state = :initial
-            end
-            
-          elsif state == :alias_expected
-            match = scan(unicode ? /(#{patterns::METHOD_NAME_OR_SYMBOL})([ \t]+)(#{patterns::METHOD_NAME_OR_SYMBOL})/uo :
-                                   /(#{patterns::METHOD_NAME_OR_SYMBOL})([ \t]+)(#{patterns::METHOD_NAME_OR_SYMBOL})/o)
-            
-            if match
-              encoder.text_token self[1], (self[1][0] == ?: ? :symbol : :method)
-              encoder.text_token self[2], :space
-              encoder.text_token self[3], (self[3][0] == ?: ? :symbol : :method)
-            end
-            state = :initial
-            
-          else
-            #:nocov:
-            raise_inspect 'Unknown state: %p' % [state], encoder
-            #:nocov:
-          end
-          
-        else  # StringState
-          
-          match = scan_until(state.pattern) || scan_rest
-          unless match.empty?
-            encoder.text_token match, :content
-            break if eos?
-          end
-          
-          if state.heredoc && self[1]  # end of heredoc
-            match = getch
-            match << scan_until(/$/) unless eos?
-            encoder.text_token match, :delimiter unless match.empty?
-            encoder.end_group state.type
-            state = state.next_state
-            next
-          end
-          
-          case match = getch
-          
-          when state.delim
-            if state.paren_depth
-              state.paren_depth -= 1
-              if state.paren_depth > 0
-                encoder.text_token match, :content
-                next
-              end
-            end
-            encoder.text_token match, :delimiter
-            if state.type == :regexp && !eos?
-              match = scan(/#{patterns::REGEXP_MODIFIERS}/o)
-              encoder.text_token match, :modifier unless match.empty?
-            end
-            encoder.end_group state.type
-            value_expected = false
-            state = state.next_state
-            
-          when '\\'
-            if state.interpreted
-              if esc = scan(/#{patterns::ESCAPE}/o)
-                encoder.text_token match + esc, :char
-              else
-                encoder.text_token match, :error
-              end
-            else
-              case esc = getch
-              when nil
-                encoder.text_token match, :content
-              when state.delim, '\\'
-                encoder.text_token match + esc, :char
-              else
-                encoder.text_token match + esc, :content
-              end
-            end
-            
-          when '#'
-            case peek(1)
-            when '{'
-              inline_block_stack ||= []
-              inline_block_stack << [state, inline_block_curly_depth, heredocs]
-              value_expected = true
-              state = :initial
-              inline_block_curly_depth = 1
-              encoder.begin_group :inline
-              encoder.text_token match + getch, :inline_delimiter
-            when '$', '@'
-              encoder.text_token match, :escape
-              last_state = state
-              state = :initial
-            else
-              #:nocov:
-              raise_inspect 'else-case # reached; #%p not handled' % [peek(1)], encoder
-              #:nocov:
-            end
-            
-          when state.opening_paren
-            state.paren_depth += 1
-            encoder.text_token match, :content
-            
-          else
-            #:nocov
-            raise_inspect 'else-case " reached; %p not handled, state = %p' % [match, state], encoder
-            #:nocov:
-            
-          end
-          
-        end
-        
-      end
-      
-      # cleaning up
-      if state.is_a? StringState
-        encoder.end_group state.type
-      end
-      
-      if options[:keep_state]
-        if state.is_a?(StringState) && state.heredoc
-          (heredocs ||= []).unshift state
-          state = :initial
-        elsif heredocs && heredocs.empty?
-          heredocs = nil
-        end
-        @state = state, heredocs
-      end
-      
-      if inline_block_stack
-        until inline_block_stack.empty?
-          state, = *inline_block_stack.pop
-          encoder.end_group :inline
-          encoder.end_group state.type
-        end
-      end
-      
-      encoder
-    end
-    
-  end
-  
-end
-end