Update CodeRay version to 1.0 final (#4264).

git-svn-id: svn+ssh://rubyforge.org/var/svn/redmine/trunk@7618 e93f8b46-1217-0410-a6f0-8f06a7374b81

25 files changed, 0 insertions, 4795 deletions

diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/_map.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/_map.rb
deleted file mode 100644
index 01078c1a4..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/_map.rb
+++ /dev/null
@@ -1,23 +0,0 @@
-module CodeRay
-module Scanners
-
-  map \
-    :h => :c,
-    :cplusplus => :cpp,
-    :'c++' => :cpp,
-    :ecma => :java_script,
-    :ecmascript => :java_script,
-    :ecma_script => :java_script,
-    :irb => :ruby,
-    :javascript => :java_script,
-    :js => :java_script,
-    :nitro => :nitro_xhtml,
-    :pascal => :delphi,
-    :plain => :plaintext,
-    :xhtml => :html,
-    :yml => :yaml
-
-  default :plain
-
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/c.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/c.rb
deleted file mode 100644
index d7f2be7c3..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/c.rb
+++ /dev/null
@@ -1,203 +0,0 @@
-module CodeRay
-module Scanners
-
-  class C < Scanner
-
-    include Streamable
-    
-    register_for :c
-    file_extension 'c'
-
-    RESERVED_WORDS = [
-      'asm', 'break', 'case', 'continue', 'default', 'do',
-      'else', 'enum', 'for', 'goto', 'if', 'return',
-      'sizeof', 'struct', 'switch', 'typedef', 'union', 'while',
-      'restrict',  # added in C99
-    ]
-
-    PREDEFINED_TYPES = [
-      'int', 'long', 'short', 'char',
-      'signed', 'unsigned', 'float', 'double',
-      'bool', 'complex',  # added in C99
-    ]
-
-    PREDEFINED_CONSTANTS = [
-      'EOF', 'NULL',
-      'true', 'false',  # added in C99
-    ]
-    DIRECTIVES = [
-      'auto', 'extern', 'register', 'static', 'void',
-      'const', 'volatile',  # added in C89
-      'inline',  # added in C99
-    ]
-
-    IDENT_KIND = WordList.new(:ident).
-      add(RESERVED_WORDS, :reserved).
-      add(PREDEFINED_TYPES, :pre_type).
-      add(DIRECTIVES, :directive).
-      add(PREDEFINED_CONSTANTS, :pre_constant)
-
-    ESCAPE = / [rbfntv\n\\'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} /x
-    UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} | U[a-fA-F0-9]{8} /x
-
-    def scan_tokens tokens, options
-
-      state = :initial
-      label_expected = true
-      case_expected = false
-      label_expected_before_preproc_line = nil
-      in_preproc_line = false
-
-      until eos?
-
-        kind = nil
-        match = nil
-        
-        case state
-
-        when :initial
-
-          if match = scan(/ \s+ | \\\n /x)
-            if in_preproc_line && match != "\\\n" && match.index(?\n)
-              in_preproc_line = false
-              label_expected = label_expected_before_preproc_line
-            end
-            tokens << [match, :space]
-            next
-
-          elsif scan(%r! // [^\n\\]* (?: \\. [^\n\\]* )* | /\* (?: .*? \*/ | .* ) !mx)
-            kind = :comment
-
-          elsif match = scan(/ \# \s* if \s* 0 /x)
-            match << scan_until(/ ^\# (?:elif|else|endif) .*? $ | \z /xm) unless eos?
-            kind = :comment
-
-          elsif match = scan(/ [-+*=<>?:;,!&^|()\[\]{}~%]+ | \/=? | \.(?!\d) /x)
-            label_expected = match =~ /[;\{\}]/
-            if case_expected
-              label_expected = true if match == ':'
-              case_expected = false
-            end
-            kind = :operator
-
-          elsif match = scan(/ [A-Za-z_][A-Za-z_0-9]* /x)
-            kind = IDENT_KIND[match]
-            if kind == :ident && label_expected && !in_preproc_line && scan(/:(?!:)/)
-              kind = :label
-              match << matched
-            else
-              label_expected = false
-              if kind == :reserved
-                case match
-                when 'case', 'default'
-                  case_expected = true
-                end
-              end
-            end
-
-          elsif scan(/\$/)
-            kind = :ident
-          
-          elsif match = scan(/L?"/)
-            tokens << [:open, :string]
-            if match[0] == ?L
-              tokens << ['L', :modifier]
-              match = '"'
-            end
-            state = :string
-            kind = :delimiter
-
-          elsif scan(/#[ \t]*(\w*)/)
-            kind = :preprocessor
-            in_preproc_line = true
-            label_expected_before_preproc_line = label_expected
-            state = :include_expected if self[1] == 'include'
-
-          elsif scan(/ L?' (?: [^\'\n\\] | \\ #{ESCAPE} )? '? /ox)
-            label_expected = false
-            kind = :char
-
-          elsif scan(/0[xX][0-9A-Fa-f]+/)
-            label_expected = false
-            kind = :hex
-
-          elsif scan(/(?:0[0-7]+)(?![89.eEfF])/)
-            label_expected = false
-            kind = :oct
-
-          elsif scan(/(?:\d+)(?![.eEfF])L?L?/)
-            label_expected = false
-            kind = :integer
-
-          elsif scan(/\d[fF]?|\d*\.\d+(?:[eE][+-]?\d+)?[fF]?|\d+[eE][+-]?\d+[fF]?/)
-            label_expected = false
-            kind = :float
-
-          else
-            getch
-            kind = :error
-
-          end
-
-        when :string
-          if scan(/[^\\\n"]+/)
-            kind = :content
-          elsif scan(/"/)
-            tokens << ['"', :delimiter]
-            tokens << [:close, :string]
-            state = :initial
-            label_expected = false
-            next
-          elsif scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
-            kind = :char
-          elsif scan(/ \\ | $ /x)
-            tokens << [:close, :string]
-            kind = :error
-            state = :initial
-            label_expected = false
-          else
-            raise_inspect "else case \" reached; %p not handled." % peek(1), tokens
-          end
-
-        when :include_expected
-          if scan(/<[^>\n]+>?|"[^"\n\\]*(?:\\.[^"\n\\]*)*"?/)
-            kind = :include
-            state = :initial
-
-          elsif match = scan(/\s+/)
-            kind = :space
-            state = :initial if match.index ?\n
-
-          else
-            state = :initial
-            next
-
-          end
-
-        else
-          raise_inspect 'Unknown state', tokens
-
-        end
-
-        match ||= matched
-        if $CODERAY_DEBUG and not kind
-          raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens
-        end
-        raise_inspect 'Empty token', tokens unless match
-
-        tokens << [match, kind]
-
-      end
-
-      if state == :string
-        tokens << [:close, :string]
-      end
-
-      tokens
-    end
-
-  end
-
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/cpp.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/cpp.rb
deleted file mode 100644
index c29083a40..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/cpp.rb
+++ /dev/null
@@ -1,228 +0,0 @@
-module CodeRay
-module Scanners
-
-  class CPlusPlus < Scanner
-
-    include Streamable
-    
-    register_for :cpp
-    file_extension 'cpp'
-    title 'C++'
-    
-    # http://www.cppreference.com/wiki/keywords/start
-    RESERVED_WORDS = [
-      'and', 'and_eq', 'asm', 'bitand', 'bitor', 'break',
-      'case', 'catch', 'class', 'compl', 'const_cast',
-      'continue', 'default', 'delete', 'do', 'dynamic_cast', 'else',
-      'enum', 'export', 'for', 'goto', 'if', 'namespace', 'new',
-      'not', 'not_eq', 'or', 'or_eq', 'reinterpret_cast', 'return',
-      'sizeof', 'static_cast', 'struct', 'switch', 'template',
-      'throw', 'try', 'typedef', 'typeid', 'typename', 'union',
-      'while', 'xor', 'xor_eq'
-    ]
-
-    PREDEFINED_TYPES = [
-      'bool', 'char', 'double', 'float', 'int', 'long',
-      'short', 'signed', 'unsigned', 'wchar_t', 'string'
-    ]
-    PREDEFINED_CONSTANTS = [
-      'false', 'true',
-      'EOF', 'NULL',
-    ]
-    PREDEFINED_VARIABLES = [
-      'this'
-    ]
-    DIRECTIVES = [
-      'auto', 'const', 'explicit', 'extern', 'friend', 'inline', 'mutable', 'operator',
-      'private', 'protected', 'public', 'register', 'static', 'using', 'virtual', 'void',
-      'volatile'
-    ]
-
-    IDENT_KIND = WordList.new(:ident).
-      add(RESERVED_WORDS, :reserved).
-      add(PREDEFINED_TYPES, :pre_type).
-      add(PREDEFINED_VARIABLES, :local_variable).
-      add(DIRECTIVES, :directive).
-      add(PREDEFINED_CONSTANTS, :pre_constant)
-
-    ESCAPE = / [rbfntv\n\\'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} /x
-    UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} | U[a-fA-F0-9]{8} /x
-
-    def scan_tokens tokens, options
-
-      state = :initial
-      label_expected = true
-      case_expected = false
-      label_expected_before_preproc_line = nil
-      in_preproc_line = false
-
-      until eos?
-
-        kind = nil
-        match = nil
-        
-        case state
-
-        when :initial
-
-          if match = scan(/ \s+ | \\\n /x)
-            if in_preproc_line && match != "\\\n" && match.index(?\n)
-              in_preproc_line = false
-              label_expected = label_expected_before_preproc_line
-            end
-            tokens << [match, :space]
-            next
-
-          elsif scan(%r! // [^\n\\]* (?: \\. [^\n\\]* )* | /\* (?: .*? \*/ | .* ) !mx)
-            kind = :comment
-
-          elsif match = scan(/ \# \s* if \s* 0 /x)
-            match << scan_until(/ ^\# (?:elif|else|endif) .*? $ | \z /xm) unless eos?
-            kind = :comment
-
-          elsif match = scan(/ [-+*=<>?:;,!&^|()\[\]{}~%]+ | \/=? | \.(?!\d) /x)
-            label_expected = match =~ /[;\{\}]/
-            if case_expected
-              label_expected = true if match == ':'
-              case_expected = false
-            end
-            kind = :operator
-
-          elsif match = scan(/ [A-Za-z_][A-Za-z_0-9]* /x)
-            kind = IDENT_KIND[match]
-            if kind == :ident && label_expected && !in_preproc_line && scan(/:(?!:)/)
-              kind = :label
-              match << matched
-            else
-              label_expected = false
-              if kind == :reserved
-                case match
-                when 'class'
-                  state = :class_name_expected
-                when 'case', 'default'
-                  case_expected = true
-                end
-              end
-            end
-
-          elsif scan(/\$/)
-            kind = :ident
-          
-          elsif match = scan(/L?"/)
-            tokens << [:open, :string]
-            if match[0] == ?L
-              tokens << ['L', :modifier]
-              match = '"'
-            end
-            state = :string
-            kind = :delimiter
-
-          elsif scan(/#[ \t]*(\w*)/)
-            kind = :preprocessor
-            in_preproc_line = true
-            label_expected_before_preproc_line = label_expected
-            state = :include_expected if self[1] == 'include'
-
-          elsif scan(/ L?' (?: [^\'\n\\] | \\ #{ESCAPE} )? '? /ox)
-            label_expected = false
-            kind = :char
-
-          elsif scan(/0[xX][0-9A-Fa-f]+/)
-            label_expected = false
-            kind = :hex
-
-          elsif scan(/(?:0[0-7]+)(?![89.eEfF])/)
-            label_expected = false
-            kind = :oct
-
-          elsif scan(/(?:\d+)(?![.eEfF])L?L?/)
-            label_expected = false
-            kind = :integer
-
-          elsif scan(/\d[fF]?|\d*\.\d+(?:[eE][+-]?\d+)?[fF]?|\d+[eE][+-]?\d+[fF]?/)
-            label_expected = false
-            kind = :float
-
-          else
-            getch
-            kind = :error
-
-          end
-
-        when :string
-          if scan(/[^\\"]+/)
-            kind = :content
-          elsif scan(/"/)
-            tokens << ['"', :delimiter]
-            tokens << [:close, :string]
-            state = :initial
-            label_expected = false
-            next
-          elsif scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
-            kind = :char
-          elsif scan(/ \\ | $ /x)
-            tokens << [:close, :string]
-            kind = :error
-            state = :initial
-            label_expected = false
-          else
-            raise_inspect "else case \" reached; %p not handled." % peek(1), tokens
-          end
-
-        when :include_expected
-          if scan(/<[^>\n]+>?|"[^"\n\\]*(?:\\.[^"\n\\]*)*"?/)
-            kind = :include
-            state = :initial
-
-          elsif match = scan(/\s+/)
-            kind = :space
-            state = :initial if match.index ?\n
-
-          else
-            state = :initial
-            next
-
-          end
-        
-        when :class_name_expected
-          if scan(/ [A-Za-z_][A-Za-z_0-9]* /x)
-            kind = :class
-            state = :initial
-
-          elsif match = scan(/\s+/)
-            kind = :space
-
-          else
-            getch
-            kind = :error
-            state = :initial
-
-          end
-          
-        else
-          raise_inspect 'Unknown state', tokens
-
-        end
-
-        match ||= matched
-        if $CODERAY_DEBUG and not kind
-          raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens
-        end
-        raise_inspect 'Empty token', tokens unless match
-
-        tokens << [match, kind]
-
-      end
-
-      if state == :string
-        tokens << [:close, :string]
-      end
-
-      tokens
-    end
-
-  end
-
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/css.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/css.rb
deleted file mode 100644
index 08ecbb18c..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/css.rb
+++ /dev/null
@@ -1,209 +0,0 @@
-module CodeRay
-module Scanners
-
-  class CSS < Scanner
-
-    register_for :css
-
-    KINDS_NOT_LOC = [
-      :comment,
-      :class, :pseudo_class, :type,
-      :constant, :directive,
-      :key, :value, :operator, :color, :float,
-      :error, :important,
-    ]
-    
-    module RE
-      Hex = /[0-9a-fA-F]/
-      Unicode = /\\#{Hex}{1,6}(?:\r\n|\s)?/ # differs from standard because it allows uppercase hex too
-      Escape = /#{Unicode}|\\[^\r\n\f0-9a-fA-F]/
-      NMChar = /[-_a-zA-Z0-9]|#{Escape}/
-      NMStart = /[_a-zA-Z]|#{Escape}/
-      NL = /\r\n|\r|\n|\f/
-      String1 = /"(?:[^\n\r\f\\"]|\\#{NL}|#{Escape})*"?/  # FIXME: buggy regexp
-      String2 = /'(?:[^\n\r\f\\']|\\#{NL}|#{Escape})*'?/  # FIXME: buggy regexp
-      String = /#{String1}|#{String2}/
-
-      HexColor = /#(?:#{Hex}{6}|#{Hex}{3})/
-      Color = /#{HexColor}/
-
-      Num = /-?(?:[0-9]+|[0-9]*\.[0-9]+)/
-      Name = /#{NMChar}+/
-      Ident = /-?#{NMStart}#{NMChar}*/
-      AtKeyword = /@#{Ident}/
-      Percentage = /#{Num}%/
-
-      reldimensions = %w[em ex px]
-      absdimensions = %w[in cm mm pt pc]
-      Unit = Regexp.union(*(reldimensions + absdimensions))
-
-      Dimension = /#{Num}#{Unit}/
-
-      Comment = %r! /\* (?: .*? \*/ | .* ) !mx
-      Function = /(?:url|alpha)\((?:[^)\n\r\f]|\\\))*\)?/
-
-      Id = /##{Name}/
-      Class = /\.#{Name}/
-      PseudoClass = /:#{Name}/
-      AttributeSelector = /\[[^\]]*\]?/
-
-    end
-
-    def scan_tokens tokens, options
-      
-      value_expected = nil
-      states = [:initial]
-
-      until eos?
-
-        kind = nil
-        match = nil
-
-        if scan(/\s+/)
-          kind = :space
-
-        elsif case states.last
-          when :initial, :media
-            if scan(/(?>#{RE::Ident})(?!\()|\*/ox)
-              kind = :type
-            elsif scan RE::Class
-              kind = :class
-            elsif scan RE::Id
-              kind = :constant
-            elsif scan RE::PseudoClass
-              kind = :pseudo_class
-            elsif match = scan(RE::AttributeSelector)
-              # TODO: Improve highlighting inside of attribute selectors.
-              tokens << [:open, :string]
-              tokens << [match[0,1], :delimiter]
-              tokens << [match[1..-2], :content] if match.size > 2
-              tokens << [match[-1,1], :delimiter] if match[-1] == ?]
-              tokens << [:close, :string]
-              next
-            elsif match = scan(/@media/)
-              kind = :directive
-              states.push :media_before_name
-            end
-          
-          when :block
-            if scan(/(?>#{RE::Ident})(?!\()/ox)
-              if value_expected
-                kind = :value
-              else
-                kind = :key
-              end
-            end
-
-          when :media_before_name
-            if scan RE::Ident
-              kind = :type
-              states[-1] = :media_after_name
-            end
-          
-          when :media_after_name
-            if scan(/\{/)
-              kind = :operator
-              states[-1] = :media
-            end
-          
-          when :comment
-            if scan(/(?:[^*\s]|\*(?!\/))+/)
-              kind = :comment
-            elsif scan(/\*\//)
-              kind = :comment
-              states.pop
-            elsif scan(/\s+/)
-              kind = :space
-            end
-
-          else
-            raise_inspect 'Unknown state', tokens
-
-          end
-
-        elsif scan(/\/\*/)
-          kind = :comment
-          states.push :comment
-
-        elsif scan(/\{/)
-          value_expected = false
-          kind = :operator
-          states.push :block
-
-        elsif scan(/\}/)
-          value_expected = false
-          if states.last == :block || states.last == :media
-            kind = :operator
-            states.pop
-          else
-            kind = :error
-          end
-
-        elsif match = scan(/#{RE::String}/o)
-          tokens << [:open, :string]
-          tokens << [match[0, 1], :delimiter]
-          tokens << [match[1..-2], :content] if match.size > 2
-          tokens << [match[-1, 1], :delimiter] if match.size >= 2
-          tokens << [:close, :string]
-          next
-
-        elsif match = scan(/#{RE::Function}/o)
-          tokens << [:open, :string]
-          start = match[/^\w+\(/]
-          tokens << [start, :delimiter]
-          if match[-1] == ?)
-            tokens << [match[start.size..-2], :content]
-            tokens << [')', :delimiter]
-          else
-            tokens << [match[start.size..-1], :content]
-          end
-          tokens << [:close, :string]
-          next
-
-        elsif scan(/(?: #{RE::Dimension} | #{RE::Percentage} | #{RE::Num} )/ox)
-          kind = :float
-
-        elsif scan(/#{RE::Color}/o)
-          kind = :color
-
-        elsif scan(/! *important/)
-          kind = :important
-
-        elsif scan(/rgb\([^()\n]*\)?/)
-          kind = :color
-
-        elsif scan(/#{RE::AtKeyword}/o)
-          kind = :directive
-
-        elsif match = scan(/ [+>:;,.=()\/] /x)
-          if match == ':'
-            value_expected = true
-          elsif match == ';'
-            value_expected = false
-          end
-          kind = :operator
-
-        else
-          getch
-          kind = :error
-
-        end
-
-        match ||= matched
-        if $CODERAY_DEBUG and not kind
-          raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens
-        end
-        raise_inspect 'Empty token', tokens unless match
-
-        tokens << [match, kind]
-
-      end
-
-      tokens
-    end
-
-  end
-
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/debug.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/debug.rb
deleted file mode 100644
index 0e78b239e..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/debug.rb
+++ /dev/null
@@ -1,62 +0,0 @@
-module CodeRay
-module Scanners
-
-  # = Debug Scanner
-  class Debug < Scanner
-
-    include Streamable
-    register_for :debug
-    file_extension 'raydebug'
-    title 'CodeRay Token Dump'
-
-  protected
-    def scan_tokens tokens, options
-
-      opened_tokens = []
-
-      until eos?
-
-        kind = nil
-        match = nil
-
-          if scan(/\s+/)
-            tokens << [matched, :space]
-            next
-            
-          elsif scan(/ (\w+) \( ( [^\)\\]* ( \\. [^\)\\]* )* ) \) /x)
-            kind = self[1].to_sym
-            match = self[2].gsub(/\\(.)/, '\1')
-            
-          elsif scan(/ (\w+) < /x)
-            kind = self[1].to_sym
-            opened_tokens << kind
-            match = :open
-            
-          elsif !opened_tokens.empty? && scan(/ > /x)
-            kind = opened_tokens.pop || :error
-            match = :close
-            
-          else
-            kind = :error
-            getch
-
-          end
-                  
-        match ||= matched
-        if $CODERAY_DEBUG and not kind
-          raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens
-        end
-        raise_inspect 'Empty token', tokens unless match
-
-        tokens << [match, kind]
-        
-      end
-      
-      tokens
-    end
-
-  end
-
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/delphi.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/delphi.rb
deleted file mode 100644
index de0ee718c..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/delphi.rb
+++ /dev/null
@@ -1,150 +0,0 @@
-module CodeRay
-module Scanners
-  
-  class Delphi < Scanner
-
-    register_for :delphi
-    file_extension 'pas'
-    
-    RESERVED_WORDS = [
-      'and', 'array', 'as', 'at', 'asm', 'at', 'begin', 'case', 'class',
-      'const', 'constructor', 'destructor', 'dispinterface', 'div', 'do',
-      'downto', 'else', 'end', 'except', 'exports', 'file', 'finalization',
-      'finally', 'for', 'function', 'goto', 'if', 'implementation', 'in',
-      'inherited', 'initialization', 'inline', 'interface', 'is', 'label',
-      'library', 'mod', 'nil', 'not', 'object', 'of', 'or', 'out', 'packed',
-      'procedure', 'program', 'property', 'raise', 'record', 'repeat',
-      'resourcestring', 'set', 'shl', 'shr', 'string', 'then', 'threadvar',
-      'to', 'try', 'type', 'unit', 'until', 'uses', 'var', 'while', 'with',
-      'xor', 'on'
-    ]
-
-    DIRECTIVES = [
-      'absolute', 'abstract', 'assembler', 'at', 'automated', 'cdecl',
-      'contains', 'deprecated', 'dispid', 'dynamic', 'export',
-      'external', 'far', 'forward', 'implements', 'local', 
-      'near', 'nodefault', 'on', 'overload', 'override',
-      'package', 'pascal', 'platform', 'private', 'protected', 'public',
-      'published', 'read', 'readonly', 'register', 'reintroduce',
-      'requires', 'resident', 'safecall', 'stdcall', 'stored', 'varargs',
-      'virtual', 'write', 'writeonly'
-    ]
-
-    IDENT_KIND = CaseIgnoringWordList.new(:ident).
-      add(RESERVED_WORDS, :reserved).
-      add(DIRECTIVES, :directive)
-    
-    NAME_FOLLOWS = CaseIgnoringWordList.new(false).
-      add(%w(procedure function .))
-
-  private
-    def scan_tokens tokens, options
-
-      state = :initial
-      last_token = ''
-
-      until eos?
-
-        kind = nil
-        match = nil
-
-        if state == :initial
-          
-          if scan(/ \s+ /x)
-            tokens << [matched, :space]
-            next
-            
-          elsif scan(%r! \{ \$ [^}]* \}? | \(\* \$ (?: .*? \*\) | .* ) !mx)
-            tokens << [matched, :preprocessor]
-            next
-            
-          elsif scan(%r! // [^\n]* | \{ [^}]* \}? | \(\* (?: .*? \*\) | .* ) !mx)
-            tokens << [matched, :comment]
-            next
-            
-          elsif match = scan(/ <[>=]? | >=? | :=? | [-+=*\/;,@\^|\(\)\[\]] | \.\. /x)
-            kind = :operator
-          
-          elsif match = scan(/\./)
-            kind = :operator
-            if last_token == 'end'
-              tokens << [match, kind]
-              next
-            end
-            
-          elsif match = scan(/ [A-Za-z_][A-Za-z_0-9]* /x)
-            kind = NAME_FOLLOWS[last_token] ? :ident : IDENT_KIND[match]
-            
-          elsif match = scan(/ ' ( [^\n']|'' ) (?:'|$) /x)
-            tokens << [:open, :char]
-            tokens << ["'", :delimiter]
-            tokens << [self[1], :content]
-            tokens << ["'", :delimiter]
-            tokens << [:close, :char]
-            next
-            
-          elsif match = scan(/ ' /x)
-            tokens << [:open, :string]
-            state = :string
-            kind = :delimiter
-            
-          elsif scan(/ \# (?: \d+ | \$[0-9A-Fa-f]+ ) /x)
-            kind = :char
-            
-          elsif scan(/ \$ [0-9A-Fa-f]+ /x)
-            kind = :hex
-            
-          elsif scan(/ (?: \d+ ) (?![eE]|\.[^.]) /x)
-            kind = :integer
-            
-          elsif scan(/ \d+ (?: \.\d+ (?: [eE][+-]? \d+ )? | [eE][+-]? \d+ ) /x)
-            kind = :float
-
-          else
-            kind = :error
-            getch
-
-          end
-          
-        elsif state == :string
-          if scan(/[^\n']+/)
-            kind = :content
-          elsif scan(/''/)
-            kind = :char
-          elsif scan(/'/)
-            tokens << ["'", :delimiter]
-            tokens << [:close, :string]
-            state = :initial
-            next
-          elsif scan(/\n/)
-            tokens << [:close, :string]
-            kind = :error
-            state = :initial
-          else
-            raise "else case \' reached; %p not handled." % peek(1), tokens
-          end
-          
-        else
-          raise 'else-case reached', tokens
-          
-        end
-        
-        match ||= matched
-        if $CODERAY_DEBUG and not kind
-          raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens, state
-        end
-        raise_inspect 'Empty token', tokens unless match
-
-        last_token = match
-        tokens << [match, kind]
-        
-      end
-      
-      tokens
-    end
-
-  end
-
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/diff.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/diff.rb
deleted file mode 100644
index 353b96691..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/diff.rb
+++ /dev/null
@@ -1,110 +0,0 @@
-module CodeRay
-module Scanners
-  
-  class Diff < Scanner
-    
-    register_for :diff
-    title 'diff output'
-    
-    def scan_tokens tokens, options
-      
-      line_kind = nil
-      state = :initial
-      
-      until eos?
-        kind = match = nil
-        
-        if match = scan(/\n/)
-          if line_kind
-            tokens << [:end_line, line_kind]
-            line_kind = nil
-          end
-          tokens << [match, :space]
-          next
-        end
-        
-        case state
-        
-        when :initial
-          if match = scan(/--- |\+\+\+ |=+|_+/)
-            tokens << [:begin_line, line_kind = :head]
-            tokens << [match, :head]
-            next unless match = scan(/.+/)
-            kind = :plain
-          elsif match = scan(/Index: |Property changes on: /)
-            tokens << [:begin_line, line_kind = :head]
-            tokens << [match, :head]
-            next unless match = scan(/.+/)
-            kind = :plain
-          elsif match = scan(/Added: /)
-            tokens << [:begin_line, line_kind = :head]
-            tokens << [match, :head]
-            next unless match = scan(/.+/)
-            kind = :plain
-            state = :added
-          elsif match = scan(/\\ /)
-            tokens << [:begin_line, line_kind = :change]
-            tokens << [match, :change]
-            next unless match = scan(/.+/)
-            kind = :plain
-          elsif match = scan(/@@(?>[^@\n]*)@@/)
-            if check(/\n|$/)
-              tokens << [:begin_line, line_kind = :change]
-            else
-              tokens << [:open, :change]
-            end
-            tokens << [match[0,2], :change]
-            tokens << [match[2...-2], :plain]
-            tokens << [match[-2,2], :change]
-            tokens << [:close, :change] unless line_kind
-            next unless match = scan(/.+/)
-            kind = :plain
-          elsif match = scan(/\+/)
-            tokens << [:begin_line, line_kind = :insert]
-            tokens << [match, :insert]
-            next unless match = scan(/.+/)
-            kind = :plain
-          elsif match = scan(/-/)
-            tokens << [:begin_line, line_kind = :delete]
-            tokens << [match, :delete]
-            next unless match = scan(/.+/)
-            kind = :plain
-          elsif scan(/ .*/)
-            kind = :comment
-          elsif scan(/.+/)
-            tokens << [:begin_line, line_kind = :comment]
-            kind = :plain
-          else
-            raise_inspect 'else case rached'
-          end
-        
-        when :added
-          if match = scan(/   \+/)
-            tokens << [:begin_line, line_kind = :insert]
-            tokens << [match, :insert]
-            next unless match = scan(/.+/)
-            kind = :plain
-          else
-            state = :initial
-            next
-          end
-        end
-        
-        match ||= matched
-        if $CODERAY_DEBUG and not kind
-          raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens
-        end
-        raise_inspect 'Empty token', tokens unless match
-        
-        tokens << [match, kind]
-      end
-      
-      tokens << [:end_line, line_kind] if line_kind
-      tokens
-    end
-    
-  end
-  
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/groovy.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/groovy.rb
deleted file mode 100644
index 17330e64c..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/groovy.rb
+++ /dev/null
@@ -1,264 +0,0 @@
-module CodeRay
-module Scanners
-
-  load :java
-
-  class Groovy < Java
-
-    include Streamable
-    register_for :groovy
-    
-    # TODO: Check this!
-    GROOVY_KEYWORDS = %w[
-      as assert def in
-    ]
-    KEYWORDS_EXPECTING_VALUE = WordList.new.add %w[
-      case instanceof new return throw typeof while as assert in
-    ]
-    GROOVY_MAGIC_VARIABLES = %w[ it ]
-    
-    IDENT_KIND = Java::IDENT_KIND.dup.
-      add(GROOVY_KEYWORDS, :keyword).
-      add(GROOVY_MAGIC_VARIABLES, :local_variable)
-    
-    ESCAPE = / [bfnrtv$\n\\'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} /x
-    UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} /x  # no 4-byte unicode chars? U[a-fA-F0-9]{8}
-    REGEXP_ESCAPE =  / [bfnrtv\n\\'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} | \d | [bBdDsSwW\/] /x
-    
-    # TODO: interpretation inside ', ", /
-    STRING_CONTENT_PATTERN = {
-      "'" => /(?>\\[^\\'\n]+|[^\\'\n]+)+/,
-      '"' => /[^\\$"\n]+/,
-      "'''" => /(?>[^\\']+|'(?!''))+/,
-      '"""' => /(?>[^\\$"]+|"(?!""))+/,
-      '/' => /[^\\$\/\n]+/,
-    }
-    
-    def scan_tokens tokens, options
-
-      state = :initial
-      inline_block_stack = []
-      inline_block_paren_depth = nil
-      string_delimiter = nil
-      import_clause = class_name_follows = last_token = after_def = false
-      value_expected = true
-
-      until eos?
-
-        kind = nil
-        match = nil
-        
-        case state
-
-        when :initial
-
-          if match = scan(/ \s+ | \\\n /x)
-            tokens << [match, :space]
-            if match.index ?\n
-              import_clause = after_def = false
-              value_expected = true unless value_expected
-            end
-            next
-          
-          elsif scan(%r! // [^\n\\]* (?: \\. [^\n\\]* )* | /\* (?: .*? \*/ | .* ) !mx)
-            value_expected = true
-            after_def = false
-            kind = :comment
-          
-          elsif bol? && scan(/ \#!.* /x)
-            kind = :doctype
-          
-          elsif import_clause && scan(/ (?!as) #{IDENT} (?: \. #{IDENT} )* (?: \.\* )? /ox)
-            after_def = value_expected = false
-            kind = :include
-          
-          elsif match = scan(/ #{IDENT} | \[\] /ox)
-            kind = IDENT_KIND[match]
-            value_expected = (kind == :keyword) && KEYWORDS_EXPECTING_VALUE[match]
-            if last_token == '.'
-              kind = :ident
-            elsif class_name_follows
-              kind = :class
-              class_name_follows = false
-            elsif after_def && check(/\s*[({]/)
-              kind = :method
-              after_def = false
-            elsif kind == :ident && last_token != '?' && check(/:/)
-              kind = :key
-            else
-              class_name_follows = true if match == 'class' || (import_clause && match == 'as')
-              import_clause = match == 'import'
-              after_def = true if match == 'def'
-            end
-          
-          elsif scan(/;/)
-            import_clause = after_def = false
-            value_expected = true
-            kind = :operator
-          
-          elsif scan(/\{/)
-            class_name_follows = after_def = false
-            value_expected = true
-            kind = :operator
-            if !inline_block_stack.empty?
-              inline_block_paren_depth += 1
-            end
-          
-          # TODO: ~'...', ~"..." and ~/.../ style regexps
-          elsif match = scan(/ \.\.<? | \*?\.(?!\d)@? | \.& | \?:? | [,?:(\[] | -[->] | \+\+ |
-              && | \|\| | \*\*=? | ==?~ | <=?>? | [-+*%^~&|>=!]=? | <<<?=? | >>>?=? /x)
-            value_expected = true
-            value_expected = :regexp if match == '~'
-            after_def = false
-            kind = :operator
-          
-          elsif match = scan(/ [)\]}] /x)
-            value_expected = after_def = false
-            if !inline_block_stack.empty? && match == '}'
-              inline_block_paren_depth -= 1
-              if inline_block_paren_depth == 0  # closing brace of inline block reached
-                tokens << [match, :inline_delimiter]
-                tokens << [:close, :inline]
-                state, string_delimiter, inline_block_paren_depth = inline_block_stack.pop
-                next
-              end
-            end
-            kind = :operator
-          
-          elsif check(/[\d.]/)
-            after_def = value_expected = false
-            if scan(/0[xX][0-9A-Fa-f]+/)
-              kind = :hex
-            elsif scan(/(?>0[0-7]+)(?![89.eEfF])/)
-              kind = :oct
-            elsif scan(/\d+[fFdD]|\d*\.\d+(?:[eE][+-]?\d+)?[fFdD]?|\d+[eE][+-]?\d+[fFdD]?/)
-              kind = :float
-            elsif scan(/\d+[lLgG]?/)
-              kind = :integer
-            end
-
-          elsif match = scan(/'''|"""/)
-            after_def = value_expected = false
-            state = :multiline_string
-            tokens << [:open, :string]
-            string_delimiter = match
-            kind = :delimiter
-          
-          # TODO: record.'name'
-          elsif match = scan(/["']/)
-            after_def = value_expected = false
-            state = match == '/' ? :regexp : :string
-            tokens << [:open, state]
-            string_delimiter = match
-            kind = :delimiter
-
-          elsif value_expected && (match = scan(/\//))
-            after_def = value_expected = false
-            tokens << [:open, :regexp]
-            state = :regexp
-            string_delimiter = '/'
-            kind = :delimiter
-
-          elsif scan(/ @ #{IDENT} /ox)
-            after_def = value_expected = false
-            kind = :annotation
-
-          elsif scan(/\//)
-            after_def = false
-            value_expected = true
-            kind = :operator
-          
-          else
-            getch
-            kind = :error
-
-          end
-
-        when :string, :regexp, :multiline_string
-          if scan(STRING_CONTENT_PATTERN[string_delimiter])
-            kind = :content
-            
-          elsif match = scan(state == :multiline_string ? /'''|"""/ : /["'\/]/)
-            tokens << [match, :delimiter]
-            if state == :regexp
-              # TODO: regexp modifiers? s, m, x, i?
-              modifiers = scan(/[ix]+/)
-              tokens << [modifiers, :modifier] if modifiers && !modifiers.empty?
-            end
-            state = :string if state == :multiline_string
-            tokens << [:close, state]
-            string_delimiter = nil
-            after_def = value_expected = false
-            state = :initial
-            next
-          
-          elsif (state == :string || state == :multiline_string) &&
-              (match = scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox))
-            if string_delimiter[0] == ?' && !(match == "\\\\" || match == "\\'")
-              kind = :content
-            else
-              kind = :char
-            end
-          elsif state == :regexp && scan(/ \\ (?: #{REGEXP_ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
-            kind = :char
-          
-          elsif match = scan(/ \$ #{IDENT} /mox)
-            tokens << [:open, :inline]
-            tokens << ['$', :inline_delimiter]
-            match = match[1..-1]
-            tokens << [match, IDENT_KIND[match]]
-            tokens << [:close, :inline]
-            next
-          elsif match = scan(/ \$ \{ /x)
-            tokens << [:open, :inline]
-            tokens << ['${', :inline_delimiter]
-            inline_block_stack << [state, string_delimiter, inline_block_paren_depth]
-            inline_block_paren_depth = 1
-            state = :initial
-            next
-          
-          elsif scan(/ \$ /mx)
-            kind = :content
-          
-          elsif scan(/ \\. /mx)
-            kind = :content
-          
-          elsif scan(/ \\ | \n /x)
-            tokens << [:close, state]
-            kind = :error
-            after_def = value_expected = false
-            state = :initial
-          
-          else
-            raise_inspect "else case \" reached; %p not handled." % peek(1), tokens
-          end
-
-        else
-          raise_inspect 'Unknown state', tokens
-
-        end
-
-        match ||= matched
-        if $CODERAY_DEBUG and not kind
-          raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens
-        end
-        raise_inspect 'Empty token', tokens unless match
-        
-        last_token = match unless [:space, :comment, :doctype].include? kind
-        
-        tokens << [match, kind]
-
-      end
-
-      if [:multiline_string, :string, :regexp].include? state
-        tokens << [:close, state]
-      end
-
-      tokens
-    end
-
-  end
-
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/html.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/html.rb
deleted file mode 100644
index 009a461d6..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/html.rb
+++ /dev/null
@@ -1,182 +0,0 @@
-module CodeRay
-module Scanners
-
-  # HTML Scanner
-  class HTML < Scanner
-
-    include Streamable
-    register_for :html
-    
-    KINDS_NOT_LOC = [
-      :comment, :doctype, :preprocessor,
-      :tag, :attribute_name, :operator,
-      :attribute_value, :delimiter, :content,
-      :plain, :entity, :error
-    ]
-
-    ATTR_NAME = /[\w.:-]+/
-    ATTR_VALUE_UNQUOTED = ATTR_NAME
-    TAG_END = /\/?>/
-    HEX = /[0-9a-fA-F]/
-    ENTITY = /
-      &
-      (?:
-        \w+
-      |
-        \#
-        (?:
-          \d+
-        |
-          x#{HEX}+
-        )
-      )
-      ;
-    /ox
-
-    PLAIN_STRING_CONTENT = {
-      "'" => /[^&'>\n]+/,
-      '"' => /[^&">\n]+/,
-    }
-
-    def reset
-      super
-      @state = :initial
-    end
-
-  private
-    def setup
-      @state = :initial
-      @plain_string_content = nil
-    end
-
-    def scan_tokens tokens, options
-
-      state = @state
-      plain_string_content = @plain_string_content
-
-      until eos?
-
-        kind = nil
-        match = nil
-
-        if scan(/\s+/m)
-          kind = :space
-
-        else
-
-          case state
-
-          when :initial
-            if scan(/<!--.*?-->/m)
-              kind = :comment
-            elsif scan(/<!DOCTYPE.*?>/m)
-              kind = :doctype
-            elsif scan(/<\?xml.*?\?>/m)
-              kind = :preprocessor
-            elsif scan(/<\?.*?\?>|<%.*?%>/m)
-              kind = :comment
-            elsif scan(/<\/[-\w.:]*>/m)
-              kind = :tag
-            elsif match = scan(/<[-\w.:]+>?/m)
-              kind = :tag
-              state = :attribute unless match[-1] == ?>
-            elsif scan(/[^<>&]+/)
-              kind = :plain
-            elsif scan(/#{ENTITY}/ox)
-              kind = :entity
-            elsif scan(/[<>&]/)
-              kind = :error
-            else
-              raise_inspect '[BUG] else-case reached with state %p' % [state], tokens
-            end
-
-          when :attribute
-            if scan(/#{TAG_END}/o)
-              kind = :tag
-              state = :initial
-            elsif scan(/#{ATTR_NAME}/o)
-              kind = :attribute_name
-              state = :attribute_equal
-            else
-              kind = :error
-              getch
-            end
-
-          when :attribute_equal
-            if scan(/=/)
-              kind = :operator
-              state = :attribute_value
-            elsif scan(/#{ATTR_NAME}/o)
-              kind = :attribute_name
-            elsif scan(/#{TAG_END}/o)
-              kind = :tag
-              state = :initial
-            elsif scan(/./)
-              kind = :error
-              state = :attribute
-            end
-
-          when :attribute_value
-            if scan(/#{ATTR_VALUE_UNQUOTED}/o)
-              kind = :attribute_value
-              state = :attribute
-            elsif match = scan(/["']/)
-              tokens << [:open, :string]
-              state = :attribute_value_string
-              plain_string_content = PLAIN_STRING_CONTENT[match]
-              kind = :delimiter
-            elsif scan(/#{TAG_END}/o)
-              kind = :tag
-              state = :initial
-            else
-              kind = :error
-              getch
-            end
-
-          when :attribute_value_string
-            if scan(plain_string_content)
-              kind = :content
-            elsif scan(/['"]/)
-              tokens << [matched, :delimiter]
-              tokens << [:close, :string]
-              state = :attribute
-              next
-            elsif scan(/#{ENTITY}/ox)
-              kind = :entity
-            elsif scan(/&/)
-              kind = :content
-            elsif scan(/[\n>]/)
-              tokens << [:close, :string]
-              kind = :error
-              state = :initial
-            end
-
-          else
-            raise_inspect 'Unknown state: %p' % [state], tokens
-
-          end
-
-        end
-
-        match ||= matched
-        if $CODERAY_DEBUG and not kind
-          raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens, state
-        end
-        raise_inspect 'Empty token', tokens unless match
-
-        tokens << [match, kind]
-      end
-
-      if options[:keep_state]
-        @state = state
-        @plain_string_content = plain_string_content
-      end
-
-      tokens
-    end
-
-  end
-
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/java.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/java.rb
deleted file mode 100644
index caf36199c..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/java.rb
+++ /dev/null
@@ -1,176 +0,0 @@
-module CodeRay
-module Scanners
-
-  class Java < Scanner
-
-    include Streamable
-    register_for :java
-    helper :builtin_types
-    
-    # http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html
-    KEYWORDS = %w[
-      assert break case catch continue default do else
-      finally for if instanceof import new package
-      return switch throw try typeof while
-      debugger export
-    ]
-    RESERVED = %w[ const goto ]
-    CONSTANTS = %w[ false null true ]
-    MAGIC_VARIABLES = %w[ this super ]
-    TYPES = %w[
-      boolean byte char class double enum float int interface long
-      short void
-    ] << '[]'  # because int[] should be highlighted as a type
-    DIRECTIVES = %w[
-      abstract extends final implements native private protected public
-      static strictfp synchronized throws transient volatile
-    ]
-    
-    IDENT_KIND = WordList.new(:ident).
-      add(KEYWORDS, :keyword).
-      add(RESERVED, :reserved).
-      add(CONSTANTS, :pre_constant).
-      add(MAGIC_VARIABLES, :local_variable).
-      add(TYPES, :type).
-      add(BuiltinTypes::List, :pre_type).
-      add(BuiltinTypes::List.select { |builtin| builtin[/(Error|Exception)$/] }, :exception).
-      add(DIRECTIVES, :directive)
-
-    ESCAPE = / [bfnrtv\n\\'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} /x
-    UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} | U[a-fA-F0-9]{8} /x
-    STRING_CONTENT_PATTERN = {
-      "'" => /[^\\']+/,
-      '"' => /[^\\"]+/,
-      '/' => /[^\\\/]+/,
-    }
-    IDENT = /[a-zA-Z_][A-Za-z_0-9]*/
-    
-    def scan_tokens tokens, options
-
-      state = :initial
-      string_delimiter = nil
-      import_clause = class_name_follows = last_token_dot = false
-
-      until eos?
-
-        kind = nil
-        match = nil
-        
-        case state
-
-        when :initial
-
-          if match = scan(/ \s+ | \\\n /x)
-            tokens << [match, :space]
-            next
-          
-          elsif match = scan(%r! // [^\n\\]* (?: \\. [^\n\\]* )* | /\* (?: .*? \*/ | .* ) !mx)
-            tokens << [match, :comment]
-            next
-          
-          elsif import_clause && scan(/ #{IDENT} (?: \. #{IDENT} )* /ox)
-            kind = :include
-          
-          elsif match = scan(/ #{IDENT} | \[\] /ox)
-            kind = IDENT_KIND[match]
-            if last_token_dot
-              kind = :ident
-            elsif class_name_follows
-              kind = :class
-              class_name_follows = false
-            else
-              import_clause = true if match == 'import'
-              class_name_follows = true if match == 'class' || match == 'interface'
-            end
-          
-          elsif scan(/ \.(?!\d) | [,?:()\[\]}] | -- | \+\+ | && | \|\| | \*\*=? | [-+*\/%^~&|<>=!]=? | <<<?=? | >>>?=? /x)
-            kind = :operator
-          
-          elsif scan(/;/)
-            import_clause = false
-            kind = :operator
-          
-          elsif scan(/\{/)
-            class_name_follows = false
-            kind = :operator
-          
-          elsif check(/[\d.]/)
-            if scan(/0[xX][0-9A-Fa-f]+/)
-              kind = :hex
-            elsif scan(/(?>0[0-7]+)(?![89.eEfF])/)
-              kind = :oct
-            elsif scan(/\d+[fFdD]|\d*\.\d+(?:[eE][+-]?\d+)?[fFdD]?|\d+[eE][+-]?\d+[fFdD]?/)
-              kind = :float
-            elsif scan(/\d+[lL]?/)
-              kind = :integer
-            end
-
-          elsif match = scan(/["']/)
-            tokens << [:open, :string]
-            state = :string
-            string_delimiter = match
-            kind = :delimiter
-
-          elsif scan(/ @ #{IDENT} /ox)
-            kind = :annotation
-
-          else
-            getch
-            kind = :error
-
-          end
-
-        when :string
-          if scan(STRING_CONTENT_PATTERN[string_delimiter])
-            kind = :content
-          elsif match = scan(/["'\/]/)
-            tokens << [match, :delimiter]
-            tokens << [:close, state]
-            string_delimiter = nil
-            state = :initial
-            next
-          elsif state == :string && (match = scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox))
-            if string_delimiter == "'" && !(match == "\\\\" || match == "\\'")
-              kind = :content
-            else
-              kind = :char
-            end
-          elsif scan(/\\./m)
-            kind = :content
-          elsif scan(/ \\ | $ /x)
-            tokens << [:close, state]
-            kind = :error
-            state = :initial
-          else
-            raise_inspect "else case \" reached; %p not handled." % peek(1), tokens
-          end
-
-        else
-          raise_inspect 'Unknown state', tokens
-
-        end
-
-        match ||= matched
-        if $CODERAY_DEBUG and not kind
-          raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens
-        end
-        raise_inspect 'Empty token', tokens unless match
-        
-        last_token_dot = match == '.'
-        
-        tokens << [match, kind]
-
-      end
-
-      if state == :string
-        tokens << [:close, state]
-      end
-
-      tokens
-    end
-
-  end
-
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/java/builtin_types.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/java/builtin_types.rb
deleted file mode 100644
index 8087edd22..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/java/builtin_types.rb
+++ /dev/null
@@ -1,419 +0,0 @@
-module CodeRay
-module Scanners
-  
-  module Java::BuiltinTypes  # :nodoc:
-    
-    List = %w[
-      AbstractAction AbstractBorder AbstractButton AbstractCellEditor AbstractCollection
-      AbstractColorChooserPanel AbstractDocument AbstractExecutorService AbstractInterruptibleChannel
-      AbstractLayoutCache AbstractList AbstractListModel AbstractMap AbstractMethodError AbstractPreferences
-      AbstractQueue AbstractQueuedSynchronizer AbstractSelectableChannel AbstractSelectionKey AbstractSelector
-      AbstractSequentialList AbstractSet AbstractSpinnerModel AbstractTableModel AbstractUndoableEdit
-      AbstractWriter AccessControlContext AccessControlException AccessController AccessException Accessible
-      AccessibleAction AccessibleAttributeSequence AccessibleBundle AccessibleComponent AccessibleContext
-      AccessibleEditableText AccessibleExtendedComponent AccessibleExtendedTable AccessibleExtendedText
-      AccessibleHyperlink AccessibleHypertext AccessibleIcon AccessibleKeyBinding AccessibleObject
-      AccessibleRelation AccessibleRelationSet AccessibleResourceBundle AccessibleRole AccessibleSelection
-      AccessibleState AccessibleStateSet AccessibleStreamable AccessibleTable AccessibleTableModelChange
-      AccessibleText AccessibleTextSequence AccessibleValue AccountException AccountExpiredException
-      AccountLockedException AccountNotFoundException Acl AclEntry AclNotFoundException Action ActionEvent
-      ActionListener ActionMap ActionMapUIResource Activatable ActivateFailedException ActivationDesc
-      ActivationException ActivationGroup ActivationGroupDesc ActivationGroupID ActivationGroup_Stub
-      ActivationID ActivationInstantiator ActivationMonitor ActivationSystem Activator ActiveEvent
-      ActivityCompletedException ActivityRequiredException Adjustable AdjustmentEvent AdjustmentListener
-      Adler32 AffineTransform AffineTransformOp AlgorithmParameterGenerator AlgorithmParameterGeneratorSpi
-      AlgorithmParameters AlgorithmParameterSpec AlgorithmParametersSpi AllPermission AlphaComposite
-      AlreadyBoundException AlreadyConnectedException AncestorEvent AncestorListener AnnotatedElement
-      Annotation AnnotationFormatError AnnotationTypeMismatchException AppConfigurationEntry Appendable Applet
-      AppletContext AppletInitializer AppletStub Arc2D Area AreaAveragingScaleFilter ArithmeticException Array
-      ArrayBlockingQueue ArrayIndexOutOfBoundsException ArrayList Arrays ArrayStoreException ArrayType
-      AssertionError AsyncBoxView AsynchronousCloseException AtomicBoolean AtomicInteger AtomicIntegerArray
-      AtomicIntegerFieldUpdater AtomicLong AtomicLongArray AtomicLongFieldUpdater AtomicMarkableReference
-      AtomicReference AtomicReferenceArray AtomicReferenceFieldUpdater AtomicStampedReference Attribute
-      AttributeChangeNotification AttributeChangeNotificationFilter AttributedCharacterIterator
-      AttributedString AttributeException AttributeInUseException AttributeList AttributeModificationException
-      AttributeNotFoundException Attributes AttributeSet AttributeSetUtilities AttributeValueExp AudioClip
-      AudioFileFormat AudioFileReader AudioFileWriter AudioFormat AudioInputStream AudioPermission AudioSystem
-      AuthenticationException AuthenticationNotSupportedException Authenticator AuthorizeCallback
-      AuthPermission AuthProvider Autoscroll AWTError AWTEvent AWTEventListener AWTEventListenerProxy
-      AWTEventMulticaster AWTException AWTKeyStroke AWTPermission BackingStoreException
-      BadAttributeValueExpException BadBinaryOpValueExpException BadLocationException BadPaddingException
-      BadStringOperationException BandCombineOp BandedSampleModel BaseRowSet BasicArrowButton BasicAttribute
-      BasicAttributes BasicBorders BasicButtonListener BasicButtonUI BasicCheckBoxMenuItemUI BasicCheckBoxUI
-      BasicColorChooserUI BasicComboBoxEditor BasicComboBoxRenderer BasicComboBoxUI BasicComboPopup
-      BasicControl BasicDesktopIconUI BasicDesktopPaneUI BasicDirectoryModel BasicEditorPaneUI
-      BasicFileChooserUI BasicFormattedTextFieldUI BasicGraphicsUtils BasicHTML BasicIconFactory
-      BasicInternalFrameTitlePane BasicInternalFrameUI BasicLabelUI BasicListUI BasicLookAndFeel
-      BasicMenuBarUI BasicMenuItemUI BasicMenuUI BasicOptionPaneUI BasicPanelUI BasicPasswordFieldUI
-      BasicPermission BasicPopupMenuSeparatorUI BasicPopupMenuUI BasicProgressBarUI BasicRadioButtonMenuItemUI
-      BasicRadioButtonUI BasicRootPaneUI BasicScrollBarUI BasicScrollPaneUI BasicSeparatorUI BasicSliderUI
-      BasicSpinnerUI BasicSplitPaneDivider BasicSplitPaneUI BasicStroke BasicTabbedPaneUI BasicTableHeaderUI
-      BasicTableUI BasicTextAreaUI BasicTextFieldUI BasicTextPaneUI BasicTextUI BasicToggleButtonUI
-      BasicToolBarSeparatorUI BasicToolBarUI BasicToolTipUI BasicTreeUI BasicViewportUI BatchUpdateException
-      BeanContext BeanContextChild BeanContextChildComponentProxy BeanContextChildSupport
-      BeanContextContainerProxy BeanContextEvent BeanContextMembershipEvent BeanContextMembershipListener
-      BeanContextProxy BeanContextServiceAvailableEvent BeanContextServiceProvider
-      BeanContextServiceProviderBeanInfo BeanContextServiceRevokedEvent BeanContextServiceRevokedListener
-      BeanContextServices BeanContextServicesListener BeanContextServicesSupport BeanContextSupport
-      BeanDescriptor BeanInfo Beans BevelBorder Bidi BigDecimal BigInteger BinaryRefAddr BindException Binding
-      BitSet Blob BlockingQueue BlockView BMPImageWriteParam Book Boolean BooleanControl Border BorderFactory
-      BorderLayout BorderUIResource BoundedRangeModel Box BoxLayout BoxView BreakIterator
-      BrokenBarrierException Buffer BufferCapabilities BufferedImage BufferedImageFilter BufferedImageOp
-      BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter BufferOverflowException
-      BufferStrategy BufferUnderflowException Button ButtonGroup ButtonModel ButtonUI Byte
-      ByteArrayInputStream ByteArrayOutputStream ByteBuffer ByteChannel ByteLookupTable ByteOrder CachedRowSet
-      CacheRequest CacheResponse Calendar Callable CallableStatement Callback CallbackHandler
-      CancelablePrintJob CancellationException CancelledKeyException CannotProceedException
-      CannotRedoException CannotUndoException Canvas CardLayout Caret CaretEvent CaretListener CellEditor
-      CellEditorListener CellRendererPane Certificate CertificateEncodingException CertificateException
-      CertificateExpiredException CertificateFactory CertificateFactorySpi CertificateNotYetValidException
-      CertificateParsingException CertPath CertPathBuilder CertPathBuilderException CertPathBuilderResult
-      CertPathBuilderSpi CertPathParameters CertPathTrustManagerParameters CertPathValidator
-      CertPathValidatorException CertPathValidatorResult CertPathValidatorSpi CertSelector CertStore
-      CertStoreException CertStoreParameters CertStoreSpi ChangedCharSetException ChangeEvent ChangeListener
-      Channel Channels Character CharacterCodingException CharacterIterator CharArrayReader CharArrayWriter
-      CharBuffer CharConversionException CharSequence Charset CharsetDecoder CharsetEncoder CharsetProvider
-      Checkbox CheckboxGroup CheckboxMenuItem CheckedInputStream CheckedOutputStream Checksum Choice
-      ChoiceCallback ChoiceFormat Chromaticity Cipher CipherInputStream CipherOutputStream CipherSpi Class
-      ClassCastException ClassCircularityError ClassDefinition ClassDesc ClassFileTransformer ClassFormatError
-      ClassLoader ClassLoaderRepository ClassLoadingMXBean ClassNotFoundException Clip Clipboard
-      ClipboardOwner Clob Cloneable CloneNotSupportedException Closeable ClosedByInterruptException
-      ClosedChannelException ClosedSelectorException CMMException CoderMalfunctionError CoderResult CodeSigner
-      CodeSource CodingErrorAction CollationElementIterator CollationKey Collator Collection
-      CollectionCertStoreParameters Collections Color ColorChooserComponentFactory ColorChooserUI
-      ColorConvertOp ColorModel ColorSelectionModel ColorSpace ColorSupported ColorType ColorUIResource
-      ComboBoxEditor ComboBoxModel ComboBoxUI ComboPopup CommunicationException Comparable Comparator
-      CompilationMXBean Compiler CompletionService Component ComponentAdapter ComponentColorModel
-      ComponentEvent ComponentInputMap ComponentInputMapUIResource ComponentListener ComponentOrientation
-      ComponentSampleModel ComponentUI ComponentView Composite CompositeContext CompositeData
-      CompositeDataSupport CompositeName CompositeType CompositeView CompoundBorder CompoundControl
-      CompoundEdit CompoundName Compression ConcurrentHashMap ConcurrentLinkedQueue ConcurrentMap
-      ConcurrentModificationException Condition Configuration ConfigurationException ConfirmationCallback
-      ConnectException ConnectIOException Connection ConnectionEvent ConnectionEventListener
-      ConnectionPendingException ConnectionPoolDataSource ConsoleHandler Constructor Container
-      ContainerAdapter ContainerEvent ContainerListener ContainerOrderFocusTraversalPolicy ContentHandler
-      ContentHandlerFactory ContentModel Context ContextNotEmptyException ContextualRenderedImageFactory
-      Control ControlFactory ControllerEventListener ConvolveOp CookieHandler Copies CopiesSupported
-      CopyOnWriteArrayList CopyOnWriteArraySet CountDownLatch CounterMonitor CounterMonitorMBean CRC32
-      CredentialException CredentialExpiredException CredentialNotFoundException CRL CRLException CRLSelector
-      CropImageFilter CSS CubicCurve2D Currency Cursor Customizer CyclicBarrier DatabaseMetaData DataBuffer
-      DataBufferByte DataBufferDouble DataBufferFloat DataBufferInt DataBufferShort DataBufferUShort
-      DataFlavor DataFormatException DatagramChannel DatagramPacket DatagramSocket DatagramSocketImpl
-      DatagramSocketImplFactory DataInput DataInputStream DataLine DataOutput DataOutputStream DataSource
-      DataTruncation DatatypeConfigurationException DatatypeConstants DatatypeFactory Date DateFormat
-      DateFormatSymbols DateFormatter DateTimeAtCompleted DateTimeAtCreation DateTimeAtProcessing
-      DateTimeSyntax DebugGraphics DecimalFormat DecimalFormatSymbols DefaultBoundedRangeModel
-      DefaultButtonModel DefaultCaret DefaultCellEditor DefaultColorSelectionModel DefaultComboBoxModel
-      DefaultDesktopManager DefaultEditorKit DefaultFocusManager DefaultFocusTraversalPolicy DefaultFormatter
-      DefaultFormatterFactory DefaultHighlighter DefaultKeyboardFocusManager DefaultListCellRenderer
-      DefaultListModel DefaultListSelectionModel DefaultLoaderRepository DefaultMenuLayout DefaultMetalTheme
-      DefaultMutableTreeNode DefaultPersistenceDelegate DefaultSingleSelectionModel DefaultStyledDocument
-      DefaultTableCellRenderer DefaultTableColumnModel DefaultTableModel DefaultTextUI DefaultTreeCellEditor
-      DefaultTreeCellRenderer DefaultTreeModel DefaultTreeSelectionModel Deflater DeflaterOutputStream Delayed
-      DelayQueue DelegationPermission Deprecated Descriptor DescriptorAccess DescriptorSupport DESedeKeySpec
-      DesignMode DESKeySpec DesktopIconUI DesktopManager DesktopPaneUI Destination Destroyable
-      DestroyFailedException DGC DHGenParameterSpec DHKey DHParameterSpec DHPrivateKey DHPrivateKeySpec
-      DHPublicKey DHPublicKeySpec Dialog Dictionary DigestException DigestInputStream DigestOutputStream
-      Dimension Dimension2D DimensionUIResource DirContext DirectColorModel DirectoryManager DirObjectFactory
-      DirStateFactory DisplayMode DnDConstants Doc DocAttribute DocAttributeSet DocFlavor DocPrintJob Document
-      DocumentBuilder DocumentBuilderFactory Documented DocumentEvent DocumentFilter DocumentListener
-      DocumentName DocumentParser DomainCombiner DOMLocator DOMResult DOMSource Double DoubleBuffer
-      DragGestureEvent DragGestureListener DragGestureRecognizer DragSource DragSourceAdapter
-      DragSourceContext DragSourceDragEvent DragSourceDropEvent DragSourceEvent DragSourceListener
-      DragSourceMotionListener Driver DriverManager DriverPropertyInfo DropTarget DropTargetAdapter
-      DropTargetContext DropTargetDragEvent DropTargetDropEvent DropTargetEvent DropTargetListener DSAKey
-      DSAKeyPairGenerator DSAParameterSpec DSAParams DSAPrivateKey DSAPrivateKeySpec DSAPublicKey
-      DSAPublicKeySpec DTD DTDConstants DuplicateFormatFlagsException Duration DynamicMBean ECField ECFieldF2m
-      ECFieldFp ECGenParameterSpec ECKey ECParameterSpec ECPoint ECPrivateKey ECPrivateKeySpec ECPublicKey
-      ECPublicKeySpec EditorKit Element ElementIterator ElementType Ellipse2D EllipticCurve EmptyBorder
-      EmptyStackException EncodedKeySpec Encoder EncryptedPrivateKeyInfo Entity Enum
-      EnumConstantNotPresentException EnumControl Enumeration EnumMap EnumSet EnumSyntax EOFException Error
-      ErrorListener ErrorManager EtchedBorder Event EventContext EventDirContext EventHandler EventListener
-      EventListenerList EventListenerProxy EventObject EventQueue EventSetDescriptor Exception
-      ExceptionInInitializerError ExceptionListener Exchanger ExecutionException Executor
-      ExecutorCompletionService Executors ExecutorService ExemptionMechanism ExemptionMechanismException
-      ExemptionMechanismSpi ExpandVetoException ExportException Expression ExtendedRequest ExtendedResponse
-      Externalizable FactoryConfigurationError FailedLoginException FeatureDescriptor Fidelity Field
-      FieldPosition FieldView File FileCacheImageInputStream FileCacheImageOutputStream FileChannel
-      FileChooserUI FileDescriptor FileDialog FileFilter FileHandler FileImageInputStream
-      FileImageOutputStream FileInputStream FileLock FileLockInterruptionException FilenameFilter FileNameMap
-      FileNotFoundException FileOutputStream FilePermission FileReader FileSystemView FileView FileWriter
-      Filter FilteredImageSource FilteredRowSet FilterInputStream FilterOutputStream FilterReader FilterWriter
-      Finishings FixedHeightLayoutCache FlatteningPathIterator FlavorEvent FlavorException FlavorListener
-      FlavorMap FlavorTable Float FloatBuffer FloatControl FlowLayout FlowView Flushable FocusAdapter
-      FocusEvent FocusListener FocusManager FocusTraversalPolicy Font FontFormatException FontMetrics
-      FontRenderContext FontUIResource Format FormatConversionProvider FormatFlagsConversionMismatchException
-      Formattable FormattableFlags Formatter FormatterClosedException FormSubmitEvent FormView Frame Future
-      FutureTask GapContent GarbageCollectorMXBean GatheringByteChannel GaugeMonitor GaugeMonitorMBean
-      GeneralPath GeneralSecurityException GenericArrayType GenericDeclaration GenericSignatureFormatError
-      GlyphJustificationInfo GlyphMetrics GlyphVector GlyphView GradientPaint GraphicAttribute Graphics
-      Graphics2D GraphicsConfigTemplate GraphicsConfiguration GraphicsDevice GraphicsEnvironment GrayFilter
-      GregorianCalendar GridBagConstraints GridBagLayout GridLayout Group Guard GuardedObject GZIPInputStream
-      GZIPOutputStream Handler HandshakeCompletedEvent HandshakeCompletedListener HasControls HashAttributeSet
-      HashDocAttributeSet HashMap HashPrintJobAttributeSet HashPrintRequestAttributeSet
-      HashPrintServiceAttributeSet HashSet Hashtable HeadlessException HierarchyBoundsAdapter
-      HierarchyBoundsListener HierarchyEvent HierarchyListener Highlighter HostnameVerifier HTML HTMLDocument
-      HTMLEditorKit HTMLFrameHyperlinkEvent HTMLWriter HttpRetryException HttpsURLConnection HttpURLConnection
-      HyperlinkEvent HyperlinkListener ICC_ColorSpace ICC_Profile ICC_ProfileGray ICC_ProfileRGB Icon
-      IconUIResource IconView Identity IdentityHashMap IdentityScope IIOByteBuffer IIOException IIOImage
-      IIOInvalidTreeException IIOMetadata IIOMetadataController IIOMetadataFormat IIOMetadataFormatImpl
-      IIOMetadataNode IIOParam IIOParamController IIOReadProgressListener IIOReadUpdateListener
-      IIOReadWarningListener IIORegistry IIOServiceProvider IIOWriteProgressListener IIOWriteWarningListener
-      IllegalAccessError IllegalAccessException IllegalArgumentException IllegalBlockingModeException
-      IllegalBlockSizeException IllegalCharsetNameException IllegalClassFormatException
-      IllegalComponentStateException IllegalFormatCodePointException IllegalFormatConversionException
-      IllegalFormatException IllegalFormatFlagsException IllegalFormatPrecisionException
-      IllegalFormatWidthException IllegalMonitorStateException IllegalPathStateException
-      IllegalSelectorException IllegalStateException IllegalThreadStateException Image ImageCapabilities
-      ImageConsumer ImageFilter ImageGraphicAttribute ImageIcon ImageInputStream ImageInputStreamImpl
-      ImageInputStreamSpi ImageIO ImageObserver ImageOutputStream ImageOutputStreamImpl ImageOutputStreamSpi
-      ImageProducer ImageReader ImageReaderSpi ImageReaderWriterSpi ImageReadParam ImageTranscoder
-      ImageTranscoderSpi ImageTypeSpecifier ImageView ImageWriteParam ImageWriter ImageWriterSpi
-      ImagingOpException IncompatibleClassChangeError IncompleteAnnotationException IndexColorModel
-      IndexedPropertyChangeEvent IndexedPropertyDescriptor IndexOutOfBoundsException Inet4Address Inet6Address
-      InetAddress InetSocketAddress Inflater InflaterInputStream InheritableThreadLocal Inherited
-      InitialContext InitialContextFactory InitialContextFactoryBuilder InitialDirContext InitialLdapContext
-      InlineView InputContext InputEvent InputMap InputMapUIResource InputMethod InputMethodContext
-      InputMethodDescriptor InputMethodEvent InputMethodHighlight InputMethodListener InputMethodRequests
-      InputMismatchException InputStream InputStreamReader InputSubset InputVerifier Insets InsetsUIResource
-      InstanceAlreadyExistsException InstanceNotFoundException InstantiationError InstantiationException
-      Instrument Instrumentation InsufficientResourcesException IntBuffer Integer IntegerSyntax InternalError
-      InternalFrameAdapter InternalFrameEvent InternalFrameFocusTraversalPolicy InternalFrameListener
-      InternalFrameUI InternationalFormatter InterruptedException InterruptedIOException
-      InterruptedNamingException InterruptibleChannel IntrospectionException Introspector
-      InvalidActivityException InvalidAlgorithmParameterException InvalidApplicationException
-      InvalidAttributeIdentifierException InvalidAttributesException InvalidAttributeValueException
-      InvalidClassException InvalidDnDOperationException InvalidKeyException InvalidKeySpecException
-      InvalidMarkException InvalidMidiDataException InvalidNameException InvalidObjectException
-      InvalidOpenTypeException InvalidParameterException InvalidParameterSpecException
-      InvalidPreferencesFormatException InvalidPropertiesFormatException InvalidRelationIdException
-      InvalidRelationServiceException InvalidRelationTypeException InvalidRoleInfoException
-      InvalidRoleValueException InvalidSearchControlsException InvalidSearchFilterException
-      InvalidTargetObjectTypeException InvalidTransactionException InvocationEvent InvocationHandler
-      InvocationTargetException IOException ItemEvent ItemListener ItemSelectable Iterable Iterator
-      IvParameterSpec JApplet JarEntry JarException JarFile JarInputStream JarOutputStream JarURLConnection
-      JButton JCheckBox JCheckBoxMenuItem JColorChooser JComboBox JComponent JdbcRowSet JDesktopPane JDialog
-      JEditorPane JFileChooser JFormattedTextField JFrame JInternalFrame JLabel JLayeredPane JList JMenu
-      JMenuBar JMenuItem JMException JMRuntimeException JMXAuthenticator JMXConnectionNotification
-      JMXConnector JMXConnectorFactory JMXConnectorProvider JMXConnectorServer JMXConnectorServerFactory
-      JMXConnectorServerMBean JMXConnectorServerProvider JMXPrincipal JMXProviderException
-      JMXServerErrorException JMXServiceURL JobAttributes JobHoldUntil JobImpressions JobImpressionsCompleted
-      JobImpressionsSupported JobKOctets JobKOctetsProcessed JobKOctetsSupported JobMediaSheets
-      JobMediaSheetsCompleted JobMediaSheetsSupported JobMessageFromOperator JobName JobOriginatingUserName
-      JobPriority JobPrioritySupported JobSheets JobState JobStateReason JobStateReasons Joinable JoinRowSet
-      JOptionPane JPanel JPasswordField JPEGHuffmanTable JPEGImageReadParam JPEGImageWriteParam JPEGQTable
-      JPopupMenu JProgressBar JRadioButton JRadioButtonMenuItem JRootPane JScrollBar JScrollPane JSeparator
-      JSlider JSpinner JSplitPane JTabbedPane JTable JTableHeader JTextArea JTextComponent JTextField
-      JTextPane JToggleButton JToolBar JToolTip JTree JViewport JWindow KerberosKey KerberosPrincipal
-      KerberosTicket Kernel Key KeyAdapter KeyAgreement KeyAgreementSpi KeyAlreadyExistsException
-      KeyboardFocusManager KeyEvent KeyEventDispatcher KeyEventPostProcessor KeyException KeyFactory
-      KeyFactorySpi KeyGenerator KeyGeneratorSpi KeyListener KeyManagementException KeyManager
-      KeyManagerFactory KeyManagerFactorySpi Keymap KeyPair KeyPairGenerator KeyPairGeneratorSpi KeyRep
-      KeySpec KeyStore KeyStoreBuilderParameters KeyStoreException KeyStoreSpi KeyStroke Label LabelUI
-      LabelView LanguageCallback LastOwnerException LayeredHighlighter LayoutFocusTraversalPolicy
-      LayoutManager LayoutManager2 LayoutQueue LDAPCertStoreParameters LdapContext LdapName
-      LdapReferralException Lease Level LimitExceededException Line Line2D LineBorder LineBreakMeasurer
-      LineEvent LineListener LineMetrics LineNumberInputStream LineNumberReader LineUnavailableException
-      LinkageError LinkedBlockingQueue LinkedHashMap LinkedHashSet LinkedList LinkException LinkLoopException
-      LinkRef List ListCellRenderer ListDataEvent ListDataListener ListenerNotFoundException ListIterator
-      ListModel ListResourceBundle ListSelectionEvent ListSelectionListener ListSelectionModel ListUI ListView
-      LoaderHandler Locale LocateRegistry Lock LockSupport Logger LoggingMXBean LoggingPermission LoginContext
-      LoginException LoginModule LogManager LogRecord LogStream Long LongBuffer LookAndFeel LookupOp
-      LookupTable Mac MacSpi MalformedInputException MalformedLinkException MalformedObjectNameException
-      MalformedParameterizedTypeException MalformedURLException ManagementFactory ManagementPermission
-      ManageReferralControl ManagerFactoryParameters Manifest Map MappedByteBuffer MarshalException
-      MarshalledObject MaskFormatter Matcher MatchResult Math MathContext MatteBorder MBeanAttributeInfo
-      MBeanConstructorInfo MBeanException MBeanFeatureInfo MBeanInfo MBeanNotificationInfo MBeanOperationInfo
-      MBeanParameterInfo MBeanPermission MBeanRegistration MBeanRegistrationException MBeanServer
-      MBeanServerBuilder MBeanServerConnection MBeanServerDelegate MBeanServerDelegateMBean MBeanServerFactory
-      MBeanServerForwarder MBeanServerInvocationHandler MBeanServerNotification MBeanServerNotificationFilter
-      MBeanServerPermission MBeanTrustPermission Media MediaName MediaPrintableArea MediaSize MediaSizeName
-      MediaTracker MediaTray Member MemoryCacheImageInputStream MemoryCacheImageOutputStream MemoryHandler
-      MemoryImageSource MemoryManagerMXBean MemoryMXBean MemoryNotificationInfo MemoryPoolMXBean MemoryType
-      MemoryUsage Menu MenuBar MenuBarUI MenuComponent MenuContainer MenuDragMouseEvent MenuDragMouseListener
-      MenuElement MenuEvent MenuItem MenuItemUI MenuKeyEvent MenuKeyListener MenuListener MenuSelectionManager
-      MenuShortcut MessageDigest MessageDigestSpi MessageFormat MetaEventListener MetalBorders MetalButtonUI
-      MetalCheckBoxIcon MetalCheckBoxUI MetalComboBoxButton MetalComboBoxEditor MetalComboBoxIcon
-      MetalComboBoxUI MetalDesktopIconUI MetalFileChooserUI MetalIconFactory MetalInternalFrameTitlePane
-      MetalInternalFrameUI MetalLabelUI MetalLookAndFeel MetalMenuBarUI MetalPopupMenuSeparatorUI
-      MetalProgressBarUI MetalRadioButtonUI MetalRootPaneUI MetalScrollBarUI MetalScrollButton
-      MetalScrollPaneUI MetalSeparatorUI MetalSliderUI MetalSplitPaneUI MetalTabbedPaneUI MetalTextFieldUI
-      MetalTheme MetalToggleButtonUI MetalToolBarUI MetalToolTipUI MetalTreeUI MetaMessage Method
-      MethodDescriptor MGF1ParameterSpec MidiChannel MidiDevice MidiDeviceProvider MidiEvent MidiFileFormat
-      MidiFileReader MidiFileWriter MidiMessage MidiSystem MidiUnavailableException MimeTypeParseException
-      MinimalHTMLWriter MissingFormatArgumentException MissingFormatWidthException MissingResourceException
-      Mixer MixerProvider MLet MLetMBean ModelMBean ModelMBeanAttributeInfo ModelMBeanConstructorInfo
-      ModelMBeanInfo ModelMBeanInfoSupport ModelMBeanNotificationBroadcaster ModelMBeanNotificationInfo
-      ModelMBeanOperationInfo ModificationItem Modifier Monitor MonitorMBean MonitorNotification
-      MonitorSettingException MouseAdapter MouseDragGestureRecognizer MouseEvent MouseInfo MouseInputAdapter
-      MouseInputListener MouseListener MouseMotionAdapter MouseMotionListener MouseWheelEvent
-      MouseWheelListener MultiButtonUI MulticastSocket MultiColorChooserUI MultiComboBoxUI MultiDesktopIconUI
-      MultiDesktopPaneUI MultiDoc MultiDocPrintJob MultiDocPrintService MultiFileChooserUI
-      MultiInternalFrameUI MultiLabelUI MultiListUI MultiLookAndFeel MultiMenuBarUI MultiMenuItemUI
-      MultiOptionPaneUI MultiPanelUI MultiPixelPackedSampleModel MultipleDocumentHandling MultipleMaster
-      MultiPopupMenuUI MultiProgressBarUI MultiRootPaneUI MultiScrollBarUI MultiScrollPaneUI MultiSeparatorUI
-      MultiSliderUI MultiSpinnerUI MultiSplitPaneUI MultiTabbedPaneUI MultiTableHeaderUI MultiTableUI
-      MultiTextUI MultiToolBarUI MultiToolTipUI MultiTreeUI MultiViewportUI MutableAttributeSet
-      MutableComboBoxModel MutableTreeNode Name NameAlreadyBoundException NameCallback NameClassPair
-      NameNotFoundException NameParser NamespaceChangeListener NamespaceContext Naming NamingEnumeration
-      NamingEvent NamingException NamingExceptionEvent NamingListener NamingManager NamingSecurityException
-      NavigationFilter NegativeArraySizeException NetPermission NetworkInterface NoClassDefFoundError
-      NoConnectionPendingException NodeChangeEvent NodeChangeListener NoInitialContextException
-      NoninvertibleTransformException NonReadableChannelException NonWritableChannelException
-      NoPermissionException NoRouteToHostException NoSuchAlgorithmException NoSuchAttributeException
-      NoSuchElementException NoSuchFieldError NoSuchFieldException NoSuchMethodError NoSuchMethodException
-      NoSuchObjectException NoSuchPaddingException NoSuchProviderException NotActiveException
-      NotBoundException NotCompliantMBeanException NotContextException Notification NotificationBroadcaster
-      NotificationBroadcasterSupport NotificationEmitter NotificationFilter NotificationFilterSupport
-      NotificationListener NotificationResult NotOwnerException NotSerializableException NotYetBoundException
-      NotYetConnectedException NullCipher NullPointerException Number NumberFormat NumberFormatException
-      NumberFormatter NumberOfDocuments NumberOfInterveningJobs NumberUp NumberUpSupported NumericShaper
-      OAEPParameterSpec Object ObjectChangeListener ObjectFactory ObjectFactoryBuilder ObjectInput
-      ObjectInputStream ObjectInputValidation ObjectInstance ObjectName ObjectOutput ObjectOutputStream
-      ObjectStreamClass ObjectStreamConstants ObjectStreamException ObjectStreamField ObjectView ObjID
-      Observable Observer OceanTheme OpenDataException OpenMBeanAttributeInfo OpenMBeanAttributeInfoSupport
-      OpenMBeanConstructorInfo OpenMBeanConstructorInfoSupport OpenMBeanInfo OpenMBeanInfoSupport
-      OpenMBeanOperationInfo OpenMBeanOperationInfoSupport OpenMBeanParameterInfo
-      OpenMBeanParameterInfoSupport OpenType OperatingSystemMXBean Operation OperationNotSupportedException
-      OperationsException Option OptionalDataException OptionPaneUI OrientationRequested OutOfMemoryError
-      OutputDeviceAssigned OutputKeys OutputStream OutputStreamWriter OverlappingFileLockException
-      OverlayLayout Override Owner Pack200 Package PackedColorModel Pageable PageAttributes
-      PagedResultsControl PagedResultsResponseControl PageFormat PageRanges PagesPerMinute PagesPerMinuteColor
-      Paint PaintContext PaintEvent Panel PanelUI Paper ParagraphView ParameterBlock ParameterDescriptor
-      ParameterizedType ParameterMetaData ParseException ParsePosition Parser ParserConfigurationException
-      ParserDelegator PartialResultException PasswordAuthentication PasswordCallback PasswordView Patch
-      PathIterator Pattern PatternSyntaxException PBEKey PBEKeySpec PBEParameterSpec PDLOverrideSupported
-      Permission PermissionCollection Permissions PersistenceDelegate PersistentMBean PhantomReference Pipe
-      PipedInputStream PipedOutputStream PipedReader PipedWriter PixelGrabber PixelInterleavedSampleModel
-      PKCS8EncodedKeySpec PKIXBuilderParameters PKIXCertPathBuilderResult PKIXCertPathChecker
-      PKIXCertPathValidatorResult PKIXParameters PlainDocument PlainView Point Point2D PointerInfo Policy
-      PolicyNode PolicyQualifierInfo Polygon PooledConnection Popup PopupFactory PopupMenu PopupMenuEvent
-      PopupMenuListener PopupMenuUI Port PortableRemoteObject PortableRemoteObjectDelegate
-      PortUnreachableException Position Predicate PreferenceChangeEvent PreferenceChangeListener Preferences
-      PreferencesFactory PreparedStatement PresentationDirection Principal Printable PrinterAbortException
-      PrinterException PrinterGraphics PrinterInfo PrinterIOException PrinterIsAcceptingJobs PrinterJob
-      PrinterLocation PrinterMakeAndModel PrinterMessageFromOperator PrinterMoreInfo
-      PrinterMoreInfoManufacturer PrinterName PrinterResolution PrinterState PrinterStateReason
-      PrinterStateReasons PrinterURI PrintEvent PrintException PrintGraphics PrintJob PrintJobAdapter
-      PrintJobAttribute PrintJobAttributeEvent PrintJobAttributeListener PrintJobAttributeSet PrintJobEvent
-      PrintJobListener PrintQuality PrintRequestAttribute PrintRequestAttributeSet PrintService
-      PrintServiceAttribute PrintServiceAttributeEvent PrintServiceAttributeListener PrintServiceAttributeSet
-      PrintServiceLookup PrintStream PrintWriter PriorityBlockingQueue PriorityQueue PrivateClassLoader
-      PrivateCredentialPermission PrivateKey PrivateMLet PrivilegedAction PrivilegedActionException
-      PrivilegedExceptionAction Process ProcessBuilder ProfileDataException ProgressBarUI ProgressMonitor
-      ProgressMonitorInputStream Properties PropertyChangeEvent PropertyChangeListener
-      PropertyChangeListenerProxy PropertyChangeSupport PropertyDescriptor PropertyEditor
-      PropertyEditorManager PropertyEditorSupport PropertyPermission PropertyResourceBundle
-      PropertyVetoException ProtectionDomain ProtocolException Provider ProviderException Proxy ProxySelector
-      PSource PSSParameterSpec PublicKey PushbackInputStream PushbackReader QName QuadCurve2D Query QueryEval
-      QueryExp Queue QueuedJobCount Random RandomAccess RandomAccessFile Raster RasterFormatException RasterOp
-      RC2ParameterSpec RC5ParameterSpec Rdn Readable ReadableByteChannel Reader ReadOnlyBufferException
-      ReadWriteLock RealmCallback RealmChoiceCallback Receiver Rectangle Rectangle2D RectangularShape
-      ReentrantLock ReentrantReadWriteLock Ref RefAddr Reference Referenceable ReferenceQueue
-      ReferenceUriSchemesSupported ReferralException ReflectionException ReflectPermission Refreshable
-      RefreshFailedException Region RegisterableService Registry RegistryHandler RejectedExecutionException
-      RejectedExecutionHandler Relation RelationException RelationNotFoundException RelationNotification
-      RelationService RelationServiceMBean RelationServiceNotRegisteredException RelationSupport
-      RelationSupportMBean RelationType RelationTypeNotFoundException RelationTypeSupport Remote RemoteCall
-      RemoteException RemoteObject RemoteObjectInvocationHandler RemoteRef RemoteServer RemoteStub
-      RenderableImage RenderableImageOp RenderableImageProducer RenderContext RenderedImage
-      RenderedImageFactory Renderer RenderingHints RepaintManager ReplicateScaleFilter RequestingUserName
-      RequiredModelMBean RescaleOp ResolutionSyntax Resolver ResolveResult ResourceBundle ResponseCache Result
-      ResultSet ResultSetMetaData Retention RetentionPolicy ReverbType RGBImageFilter RMIClassLoader
-      RMIClassLoaderSpi RMIClientSocketFactory RMIConnection RMIConnectionImpl RMIConnectionImpl_Stub
-      RMIConnector RMIConnectorServer RMIFailureHandler RMIIIOPServerImpl RMIJRMPServerImpl
-      RMISecurityException RMISecurityManager RMIServer RMIServerImpl RMIServerImpl_Stub
-      RMIServerSocketFactory RMISocketFactory Robot Role RoleInfo RoleInfoNotFoundException RoleList
-      RoleNotFoundException RoleResult RoleStatus RoleUnresolved RoleUnresolvedList RootPaneContainer
-      RootPaneUI RoundingMode RoundRectangle2D RowMapper RowSet RowSetEvent RowSetInternal RowSetListener
-      RowSetMetaData RowSetMetaDataImpl RowSetReader RowSetWarning RowSetWriter RSAKey RSAKeyGenParameterSpec
-      RSAMultiPrimePrivateCrtKey RSAMultiPrimePrivateCrtKeySpec RSAOtherPrimeInfo RSAPrivateCrtKey
-      RSAPrivateCrtKeySpec RSAPrivateKey RSAPrivateKeySpec RSAPublicKey RSAPublicKeySpec RTFEditorKit
-      RuleBasedCollator Runnable Runtime RuntimeErrorException RuntimeException RuntimeMBeanException
-      RuntimeMXBean RuntimeOperationsException RuntimePermission SampleModel Sasl SaslClient SaslClientFactory
-      SaslException SaslServer SaslServerFactory Savepoint SAXParser SAXParserFactory SAXResult SAXSource
-      SAXTransformerFactory Scanner ScatteringByteChannel ScheduledExecutorService ScheduledFuture
-      ScheduledThreadPoolExecutor Schema SchemaFactory SchemaFactoryLoader SchemaViolationException Scrollable
-      Scrollbar ScrollBarUI ScrollPane ScrollPaneAdjustable ScrollPaneConstants ScrollPaneLayout ScrollPaneUI
-      SealedObject SearchControls SearchResult SecretKey SecretKeyFactory SecretKeyFactorySpi SecretKeySpec
-      SecureCacheResponse SecureClassLoader SecureRandom SecureRandomSpi Security SecurityException
-      SecurityManager SecurityPermission Segment SelectableChannel SelectionKey Selector SelectorProvider
-      Semaphore SeparatorUI Sequence SequenceInputStream Sequencer SerialArray SerialBlob SerialClob
-      SerialDatalink SerialException Serializable SerializablePermission SerialJavaObject SerialRef
-      SerialStruct ServerCloneException ServerError ServerException ServerNotActiveException ServerRef
-      ServerRuntimeException ServerSocket ServerSocketChannel ServerSocketFactory ServiceNotFoundException
-      ServicePermission ServiceRegistry ServiceUI ServiceUIFactory ServiceUnavailableException Set
-      SetOfIntegerSyntax Severity Shape ShapeGraphicAttribute SheetCollate Short ShortBuffer
-      ShortBufferException ShortLookupTable ShortMessage Sides Signature SignatureException SignatureSpi
-      SignedObject Signer SimpleAttributeSet SimpleBeanInfo SimpleDateFormat SimpleDoc SimpleFormatter
-      SimpleTimeZone SimpleType SinglePixelPackedSampleModel SingleSelectionModel Size2DSyntax
-      SizeLimitExceededException SizeRequirements SizeSequence Skeleton SkeletonMismatchException
-      SkeletonNotFoundException SliderUI Socket SocketAddress SocketChannel SocketException SocketFactory
-      SocketHandler SocketImpl SocketImplFactory SocketOptions SocketPermission SocketSecurityException
-      SocketTimeoutException SoftBevelBorder SoftReference SortControl SortedMap SortedSet
-      SortingFocusTraversalPolicy SortKey SortResponseControl Soundbank SoundbankReader SoundbankResource
-      Source SourceDataLine SourceLocator SpinnerDateModel SpinnerListModel SpinnerModel SpinnerNumberModel
-      SpinnerUI SplitPaneUI Spring SpringLayout SQLData SQLException SQLInput SQLInputImpl SQLOutput
-      SQLOutputImpl SQLPermission SQLWarning SSLContext SSLContextSpi SSLEngine SSLEngineResult SSLException
-      SSLHandshakeException SSLKeyException SSLPeerUnverifiedException SSLPermission SSLProtocolException
-      SslRMIClientSocketFactory SslRMIServerSocketFactory SSLServerSocket SSLServerSocketFactory SSLSession
-      SSLSessionBindingEvent SSLSessionBindingListener SSLSessionContext SSLSocket SSLSocketFactory Stack
-      StackOverflowError StackTraceElement StandardMBean StartTlsRequest StartTlsResponse StateEdit
-      StateEditable StateFactory Statement StreamCorruptedException StreamHandler StreamPrintService
-      StreamPrintServiceFactory StreamResult StreamSource StreamTokenizer StrictMath String StringBuffer
-      StringBufferInputStream StringBuilder StringCharacterIterator StringContent
-      StringIndexOutOfBoundsException StringMonitor StringMonitorMBean StringReader StringRefAddr
-      StringSelection StringTokenizer StringValueExp StringWriter Stroke Struct Stub StubDelegate
-      StubNotFoundException Style StyleConstants StyleContext StyledDocument StyledEditorKit StyleSheet
-      Subject SubjectDelegationPermission SubjectDomainCombiner SupportedValuesAttribute SuppressWarnings
-      SwingConstants SwingPropertyChangeSupport SwingUtilities SyncFactory SyncFactoryException
-      SyncFailedException SynchronousQueue SyncProvider SyncProviderException SyncResolver SynthConstants
-      SynthContext Synthesizer SynthGraphicsUtils SynthLookAndFeel SynthPainter SynthStyle SynthStyleFactory
-      SysexMessage System SystemColor SystemFlavorMap TabableView TabbedPaneUI TabExpander TableCellEditor
-      TableCellRenderer TableColumn TableColumnModel TableColumnModelEvent TableColumnModelListener
-      TableHeaderUI TableModel TableModelEvent TableModelListener TableUI TableView TabSet TabStop TabularData
-      TabularDataSupport TabularType TagElement Target TargetDataLine TargetedNotification Templates
-      TemplatesHandler TextAction TextArea TextAttribute TextComponent TextEvent TextField TextHitInfo
-      TextInputCallback TextLayout TextListener TextMeasurer TextOutputCallback TextSyntax TextUI TexturePaint
-      Thread ThreadDeath ThreadFactory ThreadGroup ThreadInfo ThreadLocal ThreadMXBean ThreadPoolExecutor
-      Throwable Tie TileObserver Time TimeLimitExceededException TimeoutException Timer
-      TimerAlarmClockNotification TimerMBean TimerNotification TimerTask Timestamp TimeUnit TimeZone
-      TitledBorder ToolBarUI Toolkit ToolTipManager ToolTipUI TooManyListenersException Track
-      TransactionalWriter TransactionRequiredException TransactionRolledbackException Transferable
-      TransferHandler TransformAttribute Transformer TransformerConfigurationException TransformerException
-      TransformerFactory TransformerFactoryConfigurationError TransformerHandler Transmitter Transparency
-      TreeCellEditor TreeCellRenderer TreeExpansionEvent TreeExpansionListener TreeMap TreeModel
-      TreeModelEvent TreeModelListener TreeNode TreePath TreeSelectionEvent TreeSelectionListener
-      TreeSelectionModel TreeSet TreeUI TreeWillExpandListener TrustAnchor TrustManager TrustManagerFactory
-      TrustManagerFactorySpi Type TypeInfoProvider TypeNotPresentException Types TypeVariable UID UIDefaults
-      UIManager UIResource UndeclaredThrowableException UndoableEdit UndoableEditEvent UndoableEditListener
-      UndoableEditSupport UndoManager UnexpectedException UnicastRemoteObject UnknownError
-      UnknownFormatConversionException UnknownFormatFlagsException UnknownGroupException UnknownHostException
-      UnknownObjectException UnknownServiceException UnmappableCharacterException UnmarshalException
-      UnmodifiableClassException UnmodifiableSetException UnrecoverableEntryException
-      UnrecoverableKeyException Unreferenced UnresolvedAddressException UnresolvedPermission
-      UnsatisfiedLinkError UnsolicitedNotification UnsolicitedNotificationEvent
-      UnsolicitedNotificationListener UnsupportedAddressTypeException UnsupportedAudioFileException
-      UnsupportedCallbackException UnsupportedCharsetException UnsupportedClassVersionError
-      UnsupportedEncodingException UnsupportedFlavorException UnsupportedLookAndFeelException
-      UnsupportedOperationException URI URIException URIResolver URISyntax URISyntaxException URL
-      URLClassLoader URLConnection URLDecoder URLEncoder URLStreamHandler URLStreamHandlerFactory
-      UTFDataFormatException Util UtilDelegate Utilities UUID Validator ValidatorHandler ValueExp ValueHandler
-      ValueHandlerMultiFormat VariableHeightLayoutCache Vector VerifyError VetoableChangeListener
-      VetoableChangeListenerProxy VetoableChangeSupport View ViewFactory ViewportLayout ViewportUI
-      VirtualMachineError Visibility VMID VoiceStatus Void VolatileImage WeakHashMap WeakReference WebRowSet
-      WildcardType Window WindowAdapter WindowConstants WindowEvent WindowFocusListener WindowListener
-      WindowStateListener WrappedPlainView WritableByteChannel WritableRaster WritableRenderedImage
-      WriteAbortedException Writer X500Principal X500PrivateCredential X509Certificate X509CertSelector
-      X509CRL X509CRLEntry X509CRLSelector X509EncodedKeySpec X509ExtendedKeyManager X509Extension
-      X509KeyManager X509TrustManager XAConnection XADataSource XAException XAResource Xid XMLConstants
-      XMLDecoder XMLEncoder XMLFormatter XMLGregorianCalendar XMLParseException XmlReader XmlWriter XPath
-      XPathConstants XPathException XPathExpression XPathExpressionException XPathFactory
-      XPathFactoryConfigurationException XPathFunction XPathFunctionException XPathFunctionResolver
-      XPathVariableResolver ZipEntry ZipException ZipFile ZipInputStream ZipOutputStream ZoneView
-    ]
-    
-  end
-  
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/java_script-0.9.6.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/java_script-0.9.6.rb
deleted file mode 100644
index cb49b7af9..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/java_script-0.9.6.rb
+++ /dev/null
@@ -1,224 +0,0 @@
-module CodeRay
-module Scanners
-
-  class JavaScript < Scanner
-
-    include Streamable
-
-    register_for :java_script
-    file_extension 'js'
-
-    # The actual JavaScript keywords.
-    KEYWORDS = %w[
-      break case catch continue default delete do else
-      finally for function if in instanceof new
-      return switch throw try typeof var void while with
-    ]
-    PREDEFINED_CONSTANTS = %w[
-      false null true undefined
-    ]
-    
-    MAGIC_VARIABLES = %w[ this arguments ]  # arguments was introduced in JavaScript 1.4
-    
-    KEYWORDS_EXPECTING_VALUE = WordList.new.add %w[
-      case delete in instanceof new return throw typeof with
-    ]
-    
-    # Reserved for future use.
-    RESERVED_WORDS = %w[
-      abstract boolean byte char class debugger double enum export extends
-      final float goto implements import int interface long native package
-      private protected public short static super synchronized throws transient
-      volatile
-    ]
-    
-    IDENT_KIND = WordList.new(:ident).
-      add(RESERVED_WORDS, :reserved).
-      add(PREDEFINED_CONSTANTS, :pre_constant).
-      add(MAGIC_VARIABLES, :local_variable).
-      add(KEYWORDS, :keyword)
-
-    ESCAPE = / [bfnrtv\n\\'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} /x
-    UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} | U[a-fA-F0-9]{8} /x
-    REGEXP_ESCAPE =  / [bBdDsSwW] /x
-    STRING_CONTENT_PATTERN = {
-      "'" => /[^\\']+/,
-      '"' => /[^\\"]+/,
-      '/' => /[^\\\/]+/,
-    }
-    KEY_CHECK_PATTERN = {
-      "'" => / [^\\']* (?: \\.? [^\\']* )* '? \s* : /x,
-      '"' => / [^\\"]* (?: \\.? [^\\"]* )* "? \s* : /x,
-    }
-
-    def scan_tokens tokens, options
-
-      state = :initial
-      string_delimiter = nil
-      value_expected = true
-      key_expected = false
-      function_expected = false
-
-      until eos?
-
-        kind = nil
-        match = nil
-        
-        case state
-
-        when :initial
-
-          if match = scan(/ \s+ | \\\n /x)
-            value_expected = true if !value_expected && match.index(?\n)
-            tokens << [match, :space]
-            next
-
-          elsif scan(%r! // [^\n\\]* (?: \\. [^\n\\]* )* | /\* (?: .*? \*/ | .* ) !mx)
-            value_expected = true
-            kind = :comment
-
-          elsif check(/\.?\d/)
-            key_expected = value_expected = false
-            if scan(/0[xX][0-9A-Fa-f]+/)
-              kind = :hex
-            elsif scan(/(?>0[0-7]+)(?![89.eEfF])/)
-              kind = :oct
-            elsif scan(/\d+[fF]|\d*\.\d+(?:[eE][+-]?\d+)?[fF]?|\d+[eE][+-]?\d+[fF]?/)
-              kind = :float
-            elsif scan(/\d+/)
-              kind = :integer
-            end
-          
-          elsif value_expected && match = scan(/<([[:alpha:]]\w*) (?: [^\/>]*\/> | .*?<\/\1>)/xim)
-            # FIXME: scan over nested tags
-            xml_scanner.tokenize match
-            value_expected = false
-            next
-            
-          elsif match = scan(/ [-+*=<>?:;,!&^|(\[{~%]+ | \.(?!\d) /x)
-            value_expected = true
-            last_operator = match[-1]
-            key_expected = (last_operator == ?{) || (last_operator == ?,)
-            function_expected = false
-            kind = :operator
-
-          elsif scan(/ [)\]}]+ /x)
-            function_expected = key_expected = value_expected = false
-            kind = :operator
-
-          elsif match = scan(/ [$a-zA-Z_][A-Za-z_0-9$]* /x)
-            kind = IDENT_KIND[match]
-            value_expected = (kind == :keyword) && KEYWORDS_EXPECTING_VALUE[match]
-            # TODO: labels
-            if kind == :ident
-              if match.index(?$)  # $ allowed inside an identifier
-                kind = :predefined
-              elsif function_expected
-                kind = :function
-              elsif check(/\s*[=:]\s*function\b/)
-                kind = :function
-              elsif key_expected && check(/\s*:/)
-                kind = :key
-              end
-            end
-            function_expected = (kind == :keyword) && (match == 'function')
-            key_expected = false
-          
-          elsif match = scan(/["']/)
-            if key_expected && check(KEY_CHECK_PATTERN[match])
-              state = :key
-            else
-              state = :string
-            end
-            tokens << [:open, state]
-            string_delimiter = match
-            kind = :delimiter
-
-          elsif value_expected && (match = scan(/\/(?=\S)/))
-            tokens << [:open, :regexp]
-            state = :regexp
-            string_delimiter = '/'
-            kind = :delimiter
-
-          elsif scan(/ \/ /x)
-            value_expected = true
-            key_expected = false
-            kind = :operator
-
-          else
-            getch
-            kind = :error
-
-          end
-
-        when :string, :regexp, :key
-          if scan(STRING_CONTENT_PATTERN[string_delimiter])
-            kind = :content
-          elsif match = scan(/["'\/]/)
-            tokens << [match, :delimiter]
-            if state == :regexp
-              modifiers = scan(/[gim]+/)
-              tokens << [modifiers, :modifier] if modifiers && !modifiers.empty?
-            end
-            tokens << [:close, state]
-            string_delimiter = nil
-            key_expected = value_expected = false
-            state = :initial
-            next
-          elsif state != :regexp && (match = scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox))
-            if string_delimiter == "'" && !(match == "\\\\" || match == "\\'")
-              kind = :content
-            else
-              kind = :char
-            end
-          elsif state == :regexp && scan(/ \\ (?: #{ESCAPE} | #{REGEXP_ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
-            kind = :char
-          elsif scan(/\\./m)
-            kind = :content
-          elsif scan(/ \\ | $ /x)
-            tokens << [:close, state]
-            kind = :error
-            key_expected = value_expected = false
-            state = :initial
-          else
-            raise_inspect "else case \" reached; %p not handled." % peek(1), tokens
-          end
-
-        else
-          raise_inspect 'Unknown state', tokens
-
-        end
-
-        match ||= matched
-        if $CODERAY_DEBUG and not kind
-          raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens
-        end
-        raise_inspect 'Empty token', tokens unless match
-        
-        tokens << [match, kind]
-
-      end
-
-      if [:string, :regexp].include? state
-        tokens << [:close, state]
-      end
-
-      tokens
-    end
-
-  protected
-
-    def reset_instance
-      super
-      @xml_scanner.reset if defined? @xml_scanner
-    end
-
-    def xml_scanner
-      @xml_scanner ||= CodeRay.scanner :xml, :tokens => @tokens, :keep_tokens => true, :keep_state => false
-    end
-
-  end
-  
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/java_script.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/java_script.rb
deleted file mode 100644
index 1f26348be..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/java_script.rb
+++ /dev/null
@@ -1,224 +0,0 @@
-module CodeRay
-module Scanners
-
-  class JavaScript < Scanner
-
-    include Streamable
-
-    register_for :java_script
-    file_extension 'js'
-
-    # The actual JavaScript keywords.
-    KEYWORDS = %w[
-      break case catch continue default delete do else
-      finally for function if in instanceof new
-      return switch throw try typeof var void while with
-    ]
-    PREDEFINED_CONSTANTS = %w[
-      false null true undefined
-    ]
-    
-    MAGIC_VARIABLES = %w[ this arguments ]  # arguments was introduced in JavaScript 1.4
-    
-    KEYWORDS_EXPECTING_VALUE = WordList.new.add %w[
-      case delete in instanceof new return throw typeof with
-    ]
-    
-    # Reserved for future use.
-    RESERVED_WORDS = %w[
-      abstract boolean byte char class debugger double enum export extends
-      final float goto implements import int interface long native package
-      private protected public short static super synchronized throws transient
-      volatile
-    ]
-    
-    IDENT_KIND = WordList.new(:ident).
-      add(RESERVED_WORDS, :reserved).
-      add(PREDEFINED_CONSTANTS, :pre_constant).
-      add(MAGIC_VARIABLES, :local_variable).
-      add(KEYWORDS, :keyword)
-
-    ESCAPE = / [bfnrtv\n\\'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} /x
-    UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} | U[a-fA-F0-9]{8} /x
-    REGEXP_ESCAPE =  / [bBdDsSwW] /x
-    STRING_CONTENT_PATTERN = {
-      "'" => /[^\\']+/,
-      '"' => /[^\\"]+/,
-      '/' => /[^\\\/]+/,
-    }
-    KEY_CHECK_PATTERN = {
-      "'" => / (?> [^\\']* (?: \\. [^\\']* )* ) ' \s* : /mx,
-      '"' => / (?> [^\\"]* (?: \\. [^\\"]* )* ) " \s* : /mx,
-    }
-
-    def scan_tokens tokens, options
-
-      state = :initial
-      string_delimiter = nil
-      value_expected = true
-      key_expected = false
-      function_expected = false
-
-      until eos?
-
-        kind = nil
-        match = nil
-        
-        case state
-
-        when :initial
-
-          if match = scan(/ \s+ | \\\n /x)
-            value_expected = true if !value_expected && match.index(?\n)
-            tokens << [match, :space]
-            next
-
-          elsif scan(%r! // [^\n\\]* (?: \\. [^\n\\]* )* | /\* (?: .*? \*/ | .* ) !mx)
-            value_expected = true
-            kind = :comment
-
-          elsif check(/\.?\d/)
-            key_expected = value_expected = false
-            if scan(/0[xX][0-9A-Fa-f]+/)
-              kind = :hex
-            elsif scan(/(?>0[0-7]+)(?![89.eEfF])/)
-              kind = :oct
-            elsif scan(/\d+[fF]|\d*\.\d+(?:[eE][+-]?\d+)?[fF]?|\d+[eE][+-]?\d+[fF]?/)
-              kind = :float
-            elsif scan(/\d+/)
-              kind = :integer
-            end
-          
-          elsif value_expected && match = scan(/<([[:alpha:]]\w*) (?: [^\/>]*\/> | .*?<\/\1>)/xim)
-            # FIXME: scan over nested tags
-            xml_scanner.tokenize match
-            value_expected = false
-            next
-            
-          elsif match = scan(/ [-+*=<>?:;,!&^|(\[{~%]+ | \.(?!\d) /x)
-            value_expected = true
-            last_operator = match[-1]
-            key_expected = (last_operator == ?{) || (last_operator == ?,)
-            function_expected = false
-            kind = :operator
-
-          elsif scan(/ [)\]}]+ /x)
-            function_expected = key_expected = value_expected = false
-            kind = :operator
-
-          elsif match = scan(/ [$a-zA-Z_][A-Za-z_0-9$]* /x)
-            kind = IDENT_KIND[match]
-            value_expected = (kind == :keyword) && KEYWORDS_EXPECTING_VALUE[match]
-            # TODO: labels
-            if kind == :ident
-              if match.index(?$)  # $ allowed inside an identifier
-                kind = :predefined
-              elsif function_expected
-                kind = :function
-              elsif check(/\s*[=:]\s*function\b/)
-                kind = :function
-              elsif key_expected && check(/\s*:/)
-                kind = :key
-              end
-            end
-            function_expected = (kind == :keyword) && (match == 'function')
-            key_expected = false
-          
-          elsif match = scan(/["']/)
-            if key_expected && check(KEY_CHECK_PATTERN[match])
-              state = :key
-            else
-              state = :string
-            end
-            tokens << [:open, state]
-            string_delimiter = match
-            kind = :delimiter
-
-          elsif value_expected && (match = scan(/\/(?=\S)/))
-            tokens << [:open, :regexp]
-            state = :regexp
-            string_delimiter = '/'
-            kind = :delimiter
-
-          elsif scan(/ \/ /x)
-            value_expected = true
-            key_expected = false
-            kind = :operator
-
-          else
-            getch
-            kind = :error
-
-          end
-
-        when :string, :regexp, :key
-          if scan(STRING_CONTENT_PATTERN[string_delimiter])
-            kind = :content
-          elsif match = scan(/["'\/]/)
-            tokens << [match, :delimiter]
-            if state == :regexp
-              modifiers = scan(/[gim]+/)
-              tokens << [modifiers, :modifier] if modifiers && !modifiers.empty?
-            end
-            tokens << [:close, state]
-            string_delimiter = nil
-            key_expected = value_expected = false
-            state = :initial
-            next
-          elsif state != :regexp && (match = scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox))
-            if string_delimiter == "'" && !(match == "\\\\" || match == "\\'")
-              kind = :content
-            else
-              kind = :char
-            end
-          elsif state == :regexp && scan(/ \\ (?: #{ESCAPE} | #{REGEXP_ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
-            kind = :char
-          elsif scan(/\\./m)
-            kind = :content
-          elsif scan(/ \\ | $ /x)
-            tokens << [:close, state]
-            kind = :error
-            key_expected = value_expected = false
-            state = :initial
-          else
-            raise_inspect "else case \" reached; %p not handled." % peek(1), tokens
-          end
-
-        else
-          raise_inspect 'Unknown state', tokens
-
-        end
-
-        match ||= matched
-        if $CODERAY_DEBUG and not kind
-          raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens
-        end
-        raise_inspect 'Empty token', tokens unless match
-        
-        tokens << [match, kind]
-
-      end
-
-      if [:string, :regexp].include? state
-        tokens << [:close, state]
-      end
-
-      tokens
-    end
-
-  protected
-
-    def reset_instance
-      super
-      @xml_scanner.reset if defined? @xml_scanner
-    end
-
-    def xml_scanner
-      @xml_scanner ||= CodeRay.scanner :xml, :tokens => @tokens, :keep_tokens => true, :keep_state => false
-    end
-
-  end
-  
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/json.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/json.rb
deleted file mode 100644
index abe24fb04..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/json.rb
+++ /dev/null
@@ -1,108 +0,0 @@
-module CodeRay
-module Scanners
-  
-  class JSON < Scanner
-    
-    include Streamable
-    
-    register_for :json
-    file_extension 'json'
-    
-    KINDS_NOT_LOC = [
-      :float, :char, :content, :delimiter,
-      :error, :integer, :operator, :value,
-    ]
-    
-    ESCAPE = / [bfnrt\\"\/] /x
-    UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} /x
-    
-    def scan_tokens tokens, options
-      
-      state = :initial
-      stack = []
-      key_expected = false
-      
-      until eos?
-        
-        kind = nil
-        match = nil
-        
-        case state
-        
-        when :initial
-          if match = scan(/ \s+ | \\\n /x)
-            tokens << [match, :space]
-            next
-          elsif match = scan(/ [:,\[{\]}] /x)
-            kind = :operator
-            case match
-            when '{' then stack << :object; key_expected = true
-            when '[' then stack << :array
-            when ':' then key_expected = false
-            when ',' then key_expected = true if stack.last == :object
-            when '}', ']' then stack.pop  # no error recovery, but works for valid JSON
-            end
-          elsif match = scan(/ true | false | null /x)
-            kind = :value
-          elsif match = scan(/-?(?:0|[1-9]\d*)/)
-            kind = :integer
-            if scan(/\.\d+(?:[eE][-+]?\d+)?|[eE][-+]?\d+/)
-              match << matched
-              kind = :float
-            end
-          elsif match = scan(/"/)
-            state = key_expected ? :key : :string
-            tokens << [:open, state]
-            kind = :delimiter
-          else
-            getch
-            kind = :error
-          end
-          
-        when :string, :key
-          if scan(/[^\\"]+/)
-            kind = :content
-          elsif scan(/"/)
-            tokens << ['"', :delimiter]
-            tokens << [:close, state]
-            state = :initial
-            next
-          elsif scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
-            kind = :char
-          elsif scan(/\\./m)
-            kind = :content
-          elsif scan(/ \\ | $ /x)
-            tokens << [:close, state]
-            kind = :error
-            state = :initial
-          else
-            raise_inspect "else case \" reached; %p not handled." % peek(1), tokens
-          end
-          
-        else
-          raise_inspect 'Unknown state', tokens
-          
-        end
-        
-        match ||= matched
-        if $CODERAY_DEBUG and not kind
-          raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens
-        end
-        raise_inspect 'Empty token', tokens unless match
-        
-        tokens << [match, kind]
-        
-      end
-      
-      if [:string, :key].include? state
-        tokens << [:close, state]
-      end
-      
-      tokens
-    end
-    
-  end
-  
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/nitro_xhtml.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/nitro_xhtml.rb
deleted file mode 100644
index 6eb1d3b8b..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/nitro_xhtml.rb
+++ /dev/null
@@ -1,136 +0,0 @@
-module CodeRay
-module Scanners
-
-  load :html
-  load :ruby
-
-  # Nitro XHTML Scanner
-  class NitroXHTML < Scanner
-
-    include Streamable
-    register_for :nitro_xhtml
-    file_extension :xhtml
-    title 'Nitro XHTML'
-
-    KINDS_NOT_LOC = HTML::KINDS_NOT_LOC
-    
-    NITRO_RUBY_BLOCK = /
-      <\?r
-      (?>
-        [^\?]*
-        (?> \?(?!>) [^\?]* )*
-      )
-      (?: \?> )?
-    |
-      <ruby>
-      (?>
-        [^<]*
-        (?> <(?!\/ruby>) [^<]* )*
-      )
-      (?: <\/ruby> )?
-    |
-      <%
-      (?>
-        [^%]*
-        (?> %(?!>) [^%]* )*
-      )
-      (?: %> )?
-    /mx
-
-    NITRO_VALUE_BLOCK = /
-      \#
-      (?:
-        \{
-        [^{}]*
-        (?>
-          \{ [^}]* \}
-          (?> [^{}]* )
-        )*
-        \}?
-      | \| [^|]* \|?
-      | \( [^)]* \)?
-      | \[ [^\]]* \]?
-      | \\ [^\\]* \\?
-      )
-    /x
-
-    NITRO_ENTITY = /
-      % (?: \#\d+ | \w+ ) ;
-    /
-
-    START_OF_RUBY = /
-      (?=[<\#%])
-      < (?: \?r | % | ruby> )
-    | \# [{(|]
-    | % (?: \#\d+ | \w+ ) ;
-    /x
-
-    CLOSING_PAREN = Hash.new do |h, p|
-      h[p] = p
-    end.update( {
-      '(' => ')',
-      '[' => ']',
-      '{' => '}',
-    } )
-
-  private
-
-    def setup
-      @ruby_scanner = CodeRay.scanner :ruby, :tokens => @tokens, :keep_tokens => true
-      @html_scanner = CodeRay.scanner :html, :tokens => @tokens, :keep_tokens => true, :keep_state => true
-    end
-
-    def reset_instance
-      super
-      @html_scanner.reset
-    end
-
-    def scan_tokens tokens, options
-
-      until eos?
-
-        if (match = scan_until(/(?=#{START_OF_RUBY})/o) || scan_until(/\z/)) and not match.empty?
-          @html_scanner.tokenize match
-
-        elsif match = scan(/#{NITRO_VALUE_BLOCK}/o)
-          start_tag = match[0,2]
-          delimiter = CLOSING_PAREN[start_tag[1,1]]
-          end_tag = match[-1,1] == delimiter ? delimiter : ''
-          tokens << [:open, :inline]
-          tokens << [start_tag, :inline_delimiter]
-          code = match[start_tag.size .. -1 - end_tag.size]
-          @ruby_scanner.tokenize code
-          tokens << [end_tag, :inline_delimiter] unless end_tag.empty?
-          tokens << [:close, :inline]
-
-        elsif match = scan(/#{NITRO_RUBY_BLOCK}/o)
-          start_tag = '<?r'
-          end_tag = match[-2,2] == '?>' ? '?>' : ''
-          tokens << [:open, :inline]
-          tokens << [start_tag, :inline_delimiter]
-          code = match[start_tag.size .. -(end_tag.size)-1]
-          @ruby_scanner.tokenize code
-          tokens << [end_tag, :inline_delimiter] unless end_tag.empty?
-          tokens << [:close, :inline]
-
-        elsif entity = scan(/#{NITRO_ENTITY}/o)
-          tokens << [entity, :entity]
-        
-        elsif scan(/%/)
-          tokens << [matched, :error]
-
-        else
-          raise_inspect 'else-case reached!', tokens
-          
-        end
-
-      end
-
-      tokens
-
-    end
-
-  end
-
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/php.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/php.rb
deleted file mode 100644
index cb93264f5..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/php.rb
+++ /dev/null
@@ -1,533 +0,0 @@
-module CodeRay
-module Scanners
-  
-  load :html
-  
-  # Original by Stefan Walk.
-  class PHP < Scanner
-    
-    register_for :php
-    file_extension 'php'
-    
-    KINDS_NOT_LOC = HTML::KINDS_NOT_LOC
-    
-    def setup
-      @html_scanner = CodeRay.scanner :html, :tokens => @tokens, :keep_tokens => true, :keep_state => true
-    end
-    
-    def reset_instance
-      super
-      @html_scanner.reset
-    end
-    
-    module Words
-      
-      # according to http://www.php.net/manual/en/reserved.keywords.php
-      KEYWORDS = %w[
-        abstract and array as break case catch class clone const continue declare default do else elseif
-        enddeclare endfor endforeach endif endswitch endwhile extends final for foreach function global
-        goto if implements interface instanceof namespace new or private protected public static switch
-        throw try use var while xor
-        cfunction old_function
-      ]
-      
-      TYPES = %w[ int integer float double bool boolean string array object resource ]
-      
-      LANGUAGE_CONSTRUCTS = %w[
-        die echo empty exit eval include include_once isset list
-        require require_once return print unset
-      ]
-      
-      CLASSES = %w[ Directory stdClass __PHP_Incomplete_Class exception php_user_filter Closure ]
-      
-      # according to http://php.net/quickref.php on 2009-04-21;
-      # all functions with _ excluded (module functions) and selected additional functions
-      BUILTIN_FUNCTIONS = %w[
-        abs acos acosh addcslashes addslashes aggregate array arsort ascii2ebcdic asin asinh asort assert atan atan2
-        atanh basename bcadd bccomp bcdiv bcmod bcmul bcpow bcpowmod bcscale bcsqrt bcsub bin2hex bindec
-        bindtextdomain bzclose bzcompress bzdecompress bzerrno bzerror bzerrstr bzflush bzopen bzread bzwrite
-        calculhmac ceil chdir checkdate checkdnsrr chgrp chmod chop chown chr chroot clearstatcache closedir closelog
-        compact constant copy cos cosh count crc32 crypt current date dcgettext dcngettext deaggregate decbin dechex
-        decoct define defined deg2rad delete dgettext die dirname diskfreespace dl dngettext doubleval each
-        ebcdic2ascii echo empty end ereg eregi escapeshellarg escapeshellcmd eval exec exit exp explode expm1 extract
-        fclose feof fflush fgetc fgetcsv fgets fgetss file fileatime filectime filegroup fileinode filemtime fileowner
-        fileperms filepro filesize filetype floatval flock floor flush fmod fnmatch fopen fpassthru fprintf fputcsv
-        fputs fread frenchtojd fscanf fseek fsockopen fstat ftell ftok ftruncate fwrite getallheaders getcwd getdate
-        getenv gethostbyaddr gethostbyname gethostbynamel getimagesize getlastmod getmxrr getmygid getmyinode getmypid
-        getmyuid getopt getprotobyname getprotobynumber getrandmax getrusage getservbyname getservbyport gettext
-        gettimeofday gettype glob gmdate gmmktime gmstrftime gregoriantojd gzclose gzcompress gzdecode gzdeflate
-        gzencode gzeof gzfile gzgetc gzgets gzgetss gzinflate gzopen gzpassthru gzputs gzread gzrewind gzseek gztell
-        gzuncompress gzwrite hash header hebrev hebrevc hexdec htmlentities htmlspecialchars hypot iconv idate
-        implode include intval ip2long iptcembed iptcparse isset
-        jddayofweek jdmonthname jdtofrench jdtogregorian jdtojewish jdtojulian jdtounix jewishtojd join jpeg2wbmp
-        juliantojd key krsort ksort lcfirst lchgrp lchown levenshtein link linkinfo list localeconv localtime log
-        log10 log1p long2ip lstat ltrim mail main max md5 metaphone mhash microtime min mkdir mktime msql natcasesort
-        natsort next ngettext nl2br nthmac octdec opendir openlog
-        ord overload pack passthru pathinfo pclose pfsockopen phpcredits phpinfo phpversion pi png2wbmp popen pos pow
-        prev print printf putenv quotemeta rad2deg rand range rawurldecode rawurlencode readdir readfile readgzfile
-        readline readlink realpath recode rename require reset rewind rewinddir rmdir round rsort rtrim scandir
-        serialize setcookie setlocale setrawcookie settype sha1 shuffle signeurlpaiement sin sinh sizeof sleep snmpget
-        snmpgetnext snmprealwalk snmpset snmpwalk snmpwalkoid sort soundex split spliti sprintf sqrt srand sscanf stat
-        strcasecmp strchr strcmp strcoll strcspn strftime stripcslashes stripos stripslashes stristr strlen
-        strnatcasecmp strnatcmp strncasecmp strncmp strpbrk strpos strptime strrchr strrev strripos strrpos strspn
-        strstr strtok strtolower strtotime strtoupper strtr strval substr symlink syslog system tan tanh tempnam
-        textdomain time tmpfile touch trim uasort ucfirst ucwords uksort umask uniqid unixtojd unlink unpack
-        unserialize unset urldecode urlencode usleep usort vfprintf virtual vprintf vsprintf wordwrap
-        array_change_key_case array_chunk array_combine array_count_values array_diff array_diff_assoc
-        array_diff_key array_diff_uassoc array_diff_ukey array_fill array_fill_keys array_filter array_flip
-        array_intersect array_intersect_assoc array_intersect_key array_intersect_uassoc array_intersect_ukey
-        array_key_exists array_keys array_map array_merge array_merge_recursive array_multisort array_pad
-        array_pop array_product array_push array_rand array_reduce array_reverse array_search array_shift
-        array_slice array_splice array_sum array_udiff array_udiff_assoc array_udiff_uassoc array_uintersect
-        array_uintersect_assoc array_uintersect_uassoc array_unique array_unshift array_values array_walk
-        array_walk_recursive
-        assert_options base_convert base64_decode base64_encode
-        chunk_split class_exists class_implements class_parents
-        count_chars debug_backtrace debug_print_backtrace debug_zval_dump
-        error_get_last error_log error_reporting extension_loaded
-        file_exists file_get_contents file_put_contents load_file
-        func_get_arg func_get_args func_num_args function_exists
-        get_browser get_called_class get_cfg_var get_class get_class_methods get_class_vars
-        get_current_user get_declared_classes get_declared_interfaces get_defined_constants
-        get_defined_functions get_defined_vars get_extension_funcs get_headers get_html_translation_table
-        get_include_path get_included_files get_loaded_extensions get_magic_quotes_gpc get_magic_quotes_runtime
-        get_meta_tags get_object_vars get_parent_class get_required_filesget_resource_type
-        gc_collect_cycles gc_disable gc_enable gc_enabled
-        halt_compiler headers_list headers_sent highlight_file highlight_string
-        html_entity_decode htmlspecialchars_decode
-        in_array include_once inclued_get_data
-        is_a is_array is_binary is_bool is_buffer is_callable is_dir is_double is_executable is_file is_finite
-        is_float is_infinite is_int is_integer is_link is_long is_nan is_null is_numeric is_object is_readable
-        is_real is_resource is_scalar is_soap_fault is_string is_subclass_of is_unicode is_uploaded_file
-        is_writable is_writeable
-        locale_get_default locale_set_default
-        number_format override_function parse_str parse_url
-        php_check_syntax php_ini_loaded_file php_ini_scanned_files php_logo_guid php_sapi_name
-        php_strip_whitespace php_uname
-        preg_filter preg_grep preg_last_error preg_match preg_match_all preg_quote preg_replace
-        preg_replace_callback preg_split print_r
-        require_once register_shutdown_function register_tick_function
-        set_error_handler set_exception_handler set_file_buffer set_include_path
-        set_magic_quotes_runtime set_time_limit shell_exec
-        str_getcsv str_ireplace str_pad str_repeat str_replace str_rot13 str_shuffle str_split str_word_count
-        strip_tags substr_compare substr_count substr_replace
-        time_nanosleep time_sleep_until
-        token_get_all token_name trigger_error
-        unregister_tick_function use_soap_error_handler user_error
-        utf8_decode utf8_encode var_dump var_export
-        version_compare
-        zend_logo_guid zend_thread_id zend_version
-        create_function call_user_func_array
-        posix_access posix_ctermid posix_get_last_error posix_getcwd posix_getegid
-        posix_geteuid posix_getgid posix_getgrgid posix_getgrnam posix_getgroups
-        posix_getlogin posix_getpgid posix_getpgrp posix_getpid posix_getppid
-        posix_getpwnam posix_getpwuid posix_getrlimit posix_getsid posix_getuid
-        posix_initgroups posix_isatty posix_kill posix_mkfifo posix_mknod
-        posix_setegid posix_seteuid posix_setgid posix_setpgid posix_setsid
-        posix_setuid posix_strerror posix_times posix_ttyname posix_uname
-        pcntl_alarm pcntl_exec pcntl_fork pcntl_getpriority pcntl_setpriority
-        pcntl_signal pcntl_signal_dispatch pcntl_sigprocmask pcntl_sigtimedwait
-        pcntl_sigwaitinfo pcntl_wait pcntl_waitpid pcntl_wexitstatus pcntl_wifexited
-        pcntl_wifsignaled pcntl_wifstopped pcntl_wstopsig pcntl_wtermsig
-      ]
-      # TODO: more built-in PHP functions?
-      
-      EXCEPTIONS = %w[
-        E_ERROR E_WARNING E_PARSE E_NOTICE E_CORE_ERROR E_CORE_WARNING E_COMPILE_ERROR E_COMPILE_WARNING
-        E_USER_ERROR E_USER_WARNING E_USER_NOTICE E_DEPRECATED E_USER_DEPRECATED E_ALL E_STRICT
-      ]
-      
-      CONSTANTS = %w[
-        null true false self parent
-        __LINE__ __DIR__ __FILE__ __LINE__
-        __CLASS__ __NAMESPACE__ __METHOD__ __FUNCTION__
-        PHP_VERSION PHP_MAJOR_VERSION PHP_MINOR_VERSION PHP_RELEASE_VERSION PHP_VERSION_ID PHP_EXTRA_VERSION PHP_ZTS
-        PHP_DEBUG PHP_MAXPATHLEN PHP_OS PHP_SAPI PHP_EOL PHP_INT_MAX PHP_INT_SIZE DEFAULT_INCLUDE_PATH
-        PEAR_INSTALL_DIR PEAR_EXTENSION_DIR PHP_EXTENSION_DIR PHP_PREFIX PHP_BINDIR PHP_LIBDIR PHP_DATADIR
-        PHP_SYSCONFDIR PHP_LOCALSTATEDIR PHP_CONFIG_FILE_PATH PHP_CONFIG_FILE_SCAN_DIR PHP_SHLIB_SUFFIX
-        PHP_OUTPUT_HANDLER_START PHP_OUTPUT_HANDLER_CONT PHP_OUTPUT_HANDLER_END
-        __COMPILER_HALT_OFFSET__
-        EXTR_OVERWRITE EXTR_SKIP EXTR_PREFIX_SAME EXTR_PREFIX_ALL EXTR_PREFIX_INVALID EXTR_PREFIX_IF_EXISTS
-        EXTR_IF_EXISTS SORT_ASC SORT_DESC SORT_REGULAR SORT_NUMERIC SORT_STRING CASE_LOWER CASE_UPPER COUNT_NORMAL
-        COUNT_RECURSIVE ASSERT_ACTIVE ASSERT_CALLBACK ASSERT_BAIL ASSERT_WARNING ASSERT_QUIET_EVAL CONNECTION_ABORTED
-        CONNECTION_NORMAL CONNECTION_TIMEOUT INI_USER INI_PERDIR INI_SYSTEM INI_ALL M_E M_LOG2E M_LOG10E M_LN2 M_LN10
-        M_PI M_PI_2 M_PI_4 M_1_PI M_2_PI M_2_SQRTPI M_SQRT2 M_SQRT1_2 CRYPT_SALT_LENGTH CRYPT_STD_DES CRYPT_EXT_DES
-        CRYPT_MD5 CRYPT_BLOWFISH DIRECTORY_SEPARATOR SEEK_SET SEEK_CUR SEEK_END LOCK_SH LOCK_EX LOCK_UN LOCK_NB
-        HTML_SPECIALCHARS HTML_ENTITIES ENT_COMPAT ENT_QUOTES ENT_NOQUOTES INFO_GENERAL INFO_CREDITS
-        INFO_CONFIGURATION INFO_MODULES INFO_ENVIRONMENT INFO_VARIABLES INFO_LICENSE INFO_ALL CREDITS_GROUP
-        CREDITS_GENERAL CREDITS_SAPI CREDITS_MODULES CREDITS_DOCS CREDITS_FULLPAGE CREDITS_QA CREDITS_ALL STR_PAD_LEFT
-        STR_PAD_RIGHT STR_PAD_BOTH PATHINFO_DIRNAME PATHINFO_BASENAME PATHINFO_EXTENSION PATH_SEPARATOR CHAR_MAX
-        LC_CTYPE LC_NUMERIC LC_TIME LC_COLLATE LC_MONETARY LC_ALL LC_MESSAGES ABDAY_1 ABDAY_2 ABDAY_3 ABDAY_4 ABDAY_5
-        ABDAY_6 ABDAY_7 DAY_1 DAY_2 DAY_3 DAY_4 DAY_5 DAY_6 DAY_7 ABMON_1 ABMON_2 ABMON_3 ABMON_4 ABMON_5 ABMON_6
-        ABMON_7 ABMON_8 ABMON_9 ABMON_10 ABMON_11 ABMON_12 MON_1 MON_2 MON_3 MON_4 MON_5 MON_6 MON_7 MON_8 MON_9
-        MON_10 MON_11 MON_12 AM_STR PM_STR D_T_FMT D_FMT T_FMT T_FMT_AMPM ERA ERA_YEAR ERA_D_T_FMT ERA_D_FMT ERA_T_FMT
-        ALT_DIGITS INT_CURR_SYMBOL CURRENCY_SYMBOL CRNCYSTR MON_DECIMAL_POINT MON_THOUSANDS_SEP MON_GROUPING
-        POSITIVE_SIGN NEGATIVE_SIGN INT_FRAC_DIGITS FRAC_DIGITS P_CS_PRECEDES P_SEP_BY_SPACE N_CS_PRECEDES
-        N_SEP_BY_SPACE P_SIGN_POSN N_SIGN_POSN DECIMAL_POINT RADIXCHAR THOUSANDS_SEP THOUSEP GROUPING YESEXPR NOEXPR
-        YESSTR NOSTR CODESET LOG_EMERG LOG_ALERT LOG_CRIT LOG_ERR LOG_WARNING LOG_NOTICE LOG_INFO LOG_DEBUG LOG_KERN
-        LOG_USER LOG_MAIL LOG_DAEMON LOG_AUTH LOG_SYSLOG LOG_LPR LOG_NEWS LOG_UUCP LOG_CRON LOG_AUTHPRIV LOG_LOCAL0
-        LOG_LOCAL1 LOG_LOCAL2 LOG_LOCAL3 LOG_LOCAL4 LOG_LOCAL5 LOG_LOCAL6 LOG_LOCAL7 LOG_PID LOG_CONS LOG_ODELAY
-        LOG_NDELAY LOG_NOWAIT LOG_PERROR
-      ]
-      
-      PREDEFINED = %w[
-        $GLOBALS $_SERVER $_GET $_POST $_FILES $_REQUEST $_SESSION $_ENV
-        $_COOKIE $php_errormsg $HTTP_RAW_POST_DATA $http_response_header
-        $argc $argv
-      ]
-      
-      IDENT_KIND = CaseIgnoringWordList.new(:ident).
-        add(KEYWORDS, :reserved).
-        add(TYPES, :pre_type).
-        add(LANGUAGE_CONSTRUCTS, :reserved).
-        add(BUILTIN_FUNCTIONS, :predefined).
-        add(CLASSES, :pre_constant).
-        add(EXCEPTIONS, :exception).
-        add(CONSTANTS, :pre_constant)
-      
-      VARIABLE_KIND = WordList.new(:local_variable).
-        add(PREDEFINED, :predefined)
-    end
-    
-    module RE
-      
-      PHP_START = /
-        <script\s+[^>]*?language\s*=\s*"php"[^>]*?> |
-        <script\s+[^>]*?language\s*=\s*'php'[^>]*?> |
-        <\?php\d? |
-        <\?(?!xml)
-      /xi
-      
-      PHP_END = %r!
-        </script> |
-        \?>
-      !xi
-      
-      HTML_INDICATOR = /<!DOCTYPE html|<(?:html|body|div|p)[> ]/i
-      
-      IDENTIFIER = /[a-z_\x7f-\xFF][a-z0-9_\x7f-\xFF]*/i
-      VARIABLE = /\$#{IDENTIFIER}/
-      
-      OPERATOR = /
-        \.(?!\d)=? |      # dot that is not decimal point, string concatenation
-        && | \|\| |       # logic
-        :: | -> | => |    # scope, member, dictionary
-        \\(?!\n) |        # namespace
-        \+\+ | -- |       # increment, decrement
-        [,;?:()\[\]{}] |  # simple delimiters
-        [-+*\/%&|^]=? |   # ordinary math, binary logic, assignment shortcuts
-        [~$] |            # whatever
-        =& |              # reference assignment
-        [=!]=?=? | <> |   # comparison and assignment
-        <<=? | >>=? | [<>]=?  # comparison and shift
-      /x
-      
-    end
-    
-    def scan_tokens tokens, options
-      if string.respond_to?(:encoding)
-        unless string.encoding == Encoding::ASCII_8BIT
-          self.string = string.encode Encoding::ASCII_8BIT,
-            :invalid => :replace, :undef => :replace, :replace => '?'
-        end
-      end
-      
-      if check(RE::PHP_START) ||  # starts with <?
-       (match?(/\s*<\S/) && exist?(RE::PHP_START)) || # starts with tag and contains <?
-       exist?(RE::HTML_INDICATOR) ||
-       check(/.{1,100}#{RE::PHP_START}/om)  # PHP start after max 100 chars
-        # is HTML with embedded PHP, so start with HTML
-        states = [:initial]
-      else
-        # is just PHP, so start with PHP surrounded by HTML
-        states = [:initial, :php]
-      end
-      
-      label_expected = true
-      case_expected = false
-      
-      heredoc_delimiter = nil
-      delimiter = nil
-      modifier = nil
-      
-      until eos?
-        
-        match = nil
-        kind = nil
-        
-        case states.last
-        
-        when :initial  # HTML
-          if scan RE::PHP_START
-            kind = :inline_delimiter
-            label_expected = true
-            states << :php
-          else
-            match = scan_until(/(?=#{RE::PHP_START})/o) || scan_until(/\z/)
-            @html_scanner.tokenize match unless match.empty?
-            next
-          end
-        
-        when :php
-          if match = scan(/\s+/)
-            tokens << [match, :space]
-            next
-          
-          elsif scan(%r! (?m: \/\* (?: .*? \*\/ | .* ) ) | (?://|\#) .*? (?=#{RE::PHP_END}|$) !xo)
-            kind = :comment
-          
-          elsif match = scan(RE::IDENTIFIER)
-            kind = Words::IDENT_KIND[match]
-            if kind == :ident && label_expected && check(/:(?!:)/)
-              kind = :label
-              label_expected = true
-            else
-              label_expected = false
-              if kind == :ident && match =~ /^[A-Z]/
-                kind = :constant
-              elsif kind == :reserved
-                case match
-                when 'class'
-                  states << :class_expected
-                when 'function'
-                  states << :function_expected
-                when 'case', 'default'
-                  case_expected = true
-                end
-              elsif match == 'b' && check(/['"]/)  # binary string literal
-                modifier = match
-                next
-              end
-            end
-          
-          elsif scan(/(?:\d+\.\d*|\d*\.\d+)(?:e[-+]?\d+)?|\d+e[-+]?\d+/i)
-            label_expected = false
-            kind = :float
-          
-          elsif scan(/0x[0-9a-fA-F]+/)
-            label_expected = false
-            kind = :hex
-          
-          elsif scan(/\d+/)
-            label_expected = false
-            kind = :integer
-          
-          elsif scan(/'/)
-            tokens << [:open, :string]
-            if modifier
-              tokens << [modifier, :modifier]
-              modifier = nil
-            end
-            kind = :delimiter
-            states.push :sqstring
-          
-          elsif match = scan(/["`]/)
-            tokens << [:open, :string]
-            if modifier
-              tokens << [modifier, :modifier]
-              modifier = nil
-            end
-            delimiter = match
-            kind = :delimiter
-            states.push :dqstring
-          
-          elsif match = scan(RE::VARIABLE)
-            label_expected = false
-            kind = Words::VARIABLE_KIND[match]
-          
-          elsif scan(/\{/)
-            kind = :operator
-            label_expected = true
-            states.push :php
-          
-          elsif scan(/\}/)
-            if states.size == 1
-              kind = :error
-            else
-              states.pop
-              if states.last.is_a?(::Array)
-                delimiter = states.last[1]
-                states[-1] = states.last[0]
-                tokens << [matched, :delimiter]
-                tokens << [:close, :inline]
-                next
-              else
-                kind = :operator
-                label_expected = true
-              end
-            end
-          
-          elsif scan(/@/)
-            label_expected = false
-            kind = :exception
-          
-          elsif scan RE::PHP_END
-            kind = :inline_delimiter
-            states = [:initial]
-          
-          elsif match = scan(/<<<(?:(#{RE::IDENTIFIER})|"(#{RE::IDENTIFIER})"|'(#{RE::IDENTIFIER})')/o)
-            tokens << [:open, :string]
-            warn 'heredoc in heredoc?' if heredoc_delimiter
-            heredoc_delimiter = Regexp.escape(self[1] || self[2] || self[3])
-            kind = :delimiter
-            states.push self[3] ? :sqstring : :dqstring
-            heredoc_delimiter = /#{heredoc_delimiter}(?=;?$)/
-          
-          elsif match = scan(/#{RE::OPERATOR}/o)
-            label_expected = match == ';'
-            if case_expected
-              label_expected = true if match == ':'
-              case_expected = false
-            end
-            kind = :operator
-          
-          else
-            getch
-            kind = :error
-          
-          end
-        
-        when :sqstring
-          if scan(heredoc_delimiter ? /[^\\\n]+/ : /[^'\\]+/)
-            kind = :content
-          elsif !heredoc_delimiter && scan(/'/)
-            tokens << [matched, :delimiter]
-            tokens << [:close, :string]
-            delimiter = nil
-            label_expected = false
-            states.pop
-            next
-          elsif heredoc_delimiter && match = scan(/\n/)
-            kind = :content
-            if scan heredoc_delimiter
-              tokens << ["\n", :content]
-              tokens << [matched, :delimiter]
-              tokens << [:close, :string]
-              heredoc_delimiter = nil
-              label_expected = false
-              states.pop
-              next
-            end
-          elsif scan(heredoc_delimiter ? /\\\\/ : /\\[\\'\n]/)
-            kind = :char
-          elsif scan(/\\./m)
-            kind = :content
-          elsif scan(/\\/)
-            kind = :error
-          end
-        
-        when :dqstring
-          if scan(heredoc_delimiter ? /[^${\\\n]+/ : (delimiter == '"' ? /[^"${\\]+/ : /[^`${\\]+/))
-            kind = :content
-          elsif !heredoc_delimiter && scan(delimiter == '"' ? /"/ : /`/)
-            tokens << [matched, :delimiter]
-            tokens << [:close, :string]
-            delimiter = nil
-            label_expected = false
-            states.pop
-            next
-          elsif heredoc_delimiter && match = scan(/\n/)
-            kind = :content
-            if scan heredoc_delimiter
-              tokens << ["\n", :content]
-              tokens << [matched, :delimiter]
-              tokens << [:close, :string]
-              heredoc_delimiter = nil
-              label_expected = false
-              states.pop
-              next
-            end
-          elsif scan(/\\(?:x[0-9A-Fa-f]{1,2}|[0-7]{1,3})/)
-            kind = :char
-          elsif scan(heredoc_delimiter ? /\\[nrtvf\\$]/ : (delimiter == '"' ? /\\[nrtvf\\$"]/ : /\\[nrtvf\\$`]/))
-            kind = :char
-          elsif scan(/\\./m)
-            kind = :content
-          elsif scan(/\\/)
-            kind = :error
-          elsif match = scan(/#{RE::VARIABLE}/o)
-            kind = :local_variable
-            if check(/\[#{RE::IDENTIFIER}\]/o)
-              tokens << [:open, :inline]
-              tokens << [match, :local_variable]
-              tokens << [scan(/\[/), :operator]
-              tokens << [scan(/#{RE::IDENTIFIER}/o), :ident]
-              tokens << [scan(/\]/), :operator]
-              tokens << [:close, :inline]
-              next
-            elsif check(/\[/)
-              match << scan(/\[['"]?#{RE::IDENTIFIER}?['"]?\]?/o)
-              kind = :error
-            elsif check(/->#{RE::IDENTIFIER}/o)
-              tokens << [:open, :inline]
-              tokens << [match, :local_variable]
-              tokens << [scan(/->/), :operator]
-              tokens << [scan(/#{RE::IDENTIFIER}/o), :ident]
-              tokens << [:close, :inline]
-              next
-            elsif check(/->/)
-              match << scan(/->/)
-              kind = :error
-            end
-          elsif match = scan(/\{/)
-            if check(/\$/)
-              kind = :delimiter
-              states[-1] = [states.last, delimiter]
-              delimiter = nil
-              states.push :php
-              tokens << [:open, :inline]
-            else
-              kind = :string
-            end
-          elsif scan(/\$\{#{RE::IDENTIFIER}\}/o)
-            kind = :local_variable
-          elsif scan(/\$/)
-            kind = :content
-          end
-        
-        when :class_expected
-          if scan(/\s+/)
-            kind = :space
-          elsif match = scan(/#{RE::IDENTIFIER}/o)
-            kind = :class
-            states.pop
-          else
-            states.pop
-            next
-          end
-        
-        when :function_expected
-          if scan(/\s+/)
-            kind = :space
-          elsif scan(/&/)
-            kind = :operator
-          elsif match = scan(/#{RE::IDENTIFIER}/o)
-            kind = :function
-            states.pop
-          else
-            states.pop
-            next
-          end
-        
-        else
-          raise_inspect 'Unknown state!', tokens, states
-        end
-        
-        match ||= matched
-        if $CODERAY_DEBUG and not kind
-          raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens, states
-        end
-        raise_inspect 'Empty token', tokens, states unless match
-        
-        tokens << [match, kind]
-        
-      end
-      
-      tokens
-    end
-    
-  end
-  
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/plaintext.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/plaintext.rb
deleted file mode 100644
index 6cbb1196c..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/plaintext.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-module CodeRay
-module Scanners
-
-  class Plaintext < Scanner
-
-    register_for :plaintext, :plain
-    title 'Plain text'
-    
-    include Streamable
-    
-    KINDS_NOT_LOC = [:plain]
-    
-    def scan_tokens tokens, options
-      text = (scan_until(/\z/) || '')
-      tokens << [text, :plain]
-    end
-
-  end
-
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/python.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/python.rb
deleted file mode 100644
index 1daa79fcf..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/python.rb
+++ /dev/null
@@ -1,285 +0,0 @@
-module CodeRay
-module Scanners
-  
-  # Bases on pygments' PythonLexer, see
-  # http://dev.pocoo.org/projects/pygments/browser/pygments/lexers/agile.py.
-  class Python < Scanner
-    
-    include Streamable
-    
-    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
-    ]
-    
-    OLD_KEYWORDS = [
-      'exec', 'print',  # gone in Python 3
-    ]
-    
-    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
-    ]
-    
-    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
-    ]
-    
-    PREDEFINED_VARIABLES_AND_CONSTANTS = [
-      'False', 'True', 'None', # "keywords" since Python 3
-      'self', 'Ellipsis', 'NotImplemented',
-    ]
-    
-    IDENT_KIND = WordList.new(:ident).
-      add(KEYWORDS, :keyword).
-      add(OLD_KEYWORDS, :old_keyword).
-      add(PREDEFINED_METHODS_AND_TYPES, :predefined).
-      add(PREDEFINED_VARIABLES_AND_CONSTANTS, :pre_constant).
-      add(PREDEFINED_EXCEPTIONS, :exception)
-    
-    NAME = / [^\W\d] \w* /x
-    ESCAPE = / [abfnrtv\n\\'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} /x
-    UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} | U[a-fA-F0-9]{8} | N\{[-\w ]+\} /x
-    
-    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
-    
-    STRING_DELIMITER_REGEXP = Hash.new do |h, delimiter|
-      h[delimiter] = Regexp.union delimiter
-    end
-    
-    STRING_CONTENT_REGEXP = Hash.new do |h, delimiter|
-      h[delimiter] = / [^\\\n]+? (?= \\ | $ | #{Regexp.escape(delimiter)} ) /x
-    end
-    
-    DEF_NEW_STATE = WordList.new(:initial).
-      add(%w(def), :def_expected).
-      add(%w(import from), :include_expected).
-      add(%w(class), :class_expected)
-    
-    DESCRIPTOR = /
-      #{NAME}
-      (?: \. #{NAME} )*
-      | \*
-    /x
-    
-    def scan_tokens tokens, options
-      
-      state = :initial
-      string_delimiter = nil
-      string_raw = false
-      import_clause = class_name_follows = last_token_dot = false
-      unicode = string.respond_to?(:encoding) && string.encoding.name == 'UTF-8'
-      from_import_state = []
-      
-      until eos?
-        
-        kind = nil
-        match = nil
-        
-        if state == :string
-          if scan(STRING_DELIMITER_REGEXP[string_delimiter])
-            tokens << [matched, :delimiter]
-            tokens << [:close, :string]
-            state = :initial
-            next
-          elsif string_delimiter.size == 3 && scan(/\n/)
-            kind = :content
-          elsif scan(STRING_CONTENT_REGEXP[string_delimiter])
-            kind = :content
-          elsif !string_raw && scan(/ \\ #{ESCAPE} /ox)
-            kind = :char
-          elsif scan(/ \\ #{UNICODE_ESCAPE} /ox)
-            kind = :char
-          elsif scan(/ \\ . /x)
-            kind = :content
-          elsif scan(/ \\ | $ /x)
-            tokens << [:close, :string]
-            kind = :error
-            state = :initial
-          else
-            raise_inspect "else case \" reached; %p not handled." % peek(1), tokens, state
-          end
-        
-        elsif match = scan(/ [ \t]+ | \\\n /x)
-          tokens << [match, :space]
-          next
-        
-        elsif match = scan(/\n/)
-          tokens << [match, :space]
-          state = :initial if state == :include_expected
-          next
-        
-        elsif match = scan(/ \# [^\n]* /mx)
-          tokens << [match, :comment]
-          next
-        
-        elsif state == :initial
-          
-          if scan(/#{OPERATOR}/o)
-            kind = :operator
-          
-          elsif match = scan(/(u?r?|b)?("""|"|'''|')/i)
-            tokens << [:open, :string]
-            string_delimiter = self[2]
-            string_raw = false
-            modifiers = self[1]
-            unless modifiers.empty?
-              string_raw = !!modifiers.index(?r)
-              tokens << [modifiers, :modifier]
-              match = string_delimiter
-            end
-            state = :string
-            kind = :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
-          
-          elsif scan(/@[a-zA-Z0-9_.]+[lL]?/)
-            kind = :decorator
-          
-          elsif scan(/0[xX][0-9A-Fa-f]+[lL]?/)
-            kind = :hex
-          
-          elsif scan(/0[bB][01]+[lL]?/)
-            kind = :bin
-          
-          elsif match = scan(/(?:\d*\.\d+|\d+\.\d*)(?:[eE][+-]?\d+)?|\d+[eE][+-]?\d+/)
-            kind = :float
-            if scan(/[jJ]/)
-              match << matched
-              kind = :imaginary
-            end
-          
-          elsif scan(/0[oO][0-7]+|0[0-7]+(?![89.eE])[lL]?/)
-            kind = :oct
-          
-          elsif match = scan(/\d+([lL])?/)
-            kind = :integer
-            if self[1] == nil && scan(/[jJ]/)
-              match << matched
-              kind = :imaginary
-            end
-          
-          else
-            getch
-            kind = :error
-          
-          end
-            
-        elsif state == :def_expected
-          state = :initial
-          if match = scan(unicode ? /#{NAME}/uo : /#{NAME}/o)
-            kind = :method
-          else
-            next
-          end
-        
-        elsif state == :class_expected
-          state = :initial
-          if match = scan(unicode ? /#{NAME}/uo : /#{NAME}/o)
-            kind = :class
-          else
-            next
-          end
-          
-        elsif state == :include_expected
-          if match = scan(unicode ? /#{DESCRIPTOR}/uo : /#{DESCRIPTOR}/o)
-            kind = :include
-            if match == 'as'
-              kind = :keyword
-              from_import_state << :as
-            elsif from_import_state.first == :from && match == 'import'
-              kind = :keyword
-              from_import_state << :import
-            elsif from_import_state.last == :as
-              # kind = match[0,1][unicode ? /[[:upper:]]/u : /[[:upper:]]/] ? :class : :method
-              kind = :ident
-              from_import_state.pop
-            elsif IDENT_KIND[match] == :keyword
-              unscan
-              match = nil
-              state = :initial
-              next
-            end
-          elsif match = scan(/,/)
-            from_import_state.pop if from_import_state.last == :as
-            kind = :operator
-          else
-            from_import_state = []
-            state = :initial
-            next
-          end
-          
-        else
-          raise_inspect 'Unknown state', tokens, state
-          
-        end
-        
-        match ||= matched
-        if $CODERAY_DEBUG and not kind
-          raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens, state
-        end
-        raise_inspect 'Empty token', tokens, state unless match
-        
-        last_token_dot = match == '.'
-        
-        tokens << [match, kind]
-        
-      end
-      
-      if state == :string
-        tokens << [:close, :string]
-      end
-      
-      tokens
-    end
-    
-  end
-  
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/rhtml.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/rhtml.rb
deleted file mode 100644
index 378d0786d..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/rhtml.rb
+++ /dev/null
@@ -1,78 +0,0 @@
-module CodeRay
-module Scanners
-
-  load :html
-  load :ruby
-
-  # RHTML Scanner
-  class RHTML < Scanner
-
-    include Streamable
-    register_for :rhtml
-    title 'HTML ERB Template'
-    
-    KINDS_NOT_LOC = HTML::KINDS_NOT_LOC
-
-    ERB_RUBY_BLOCK = /
-      <%(?!%)[=-]?
-      (?>
-        [^\-%]*    # normal*
-        (?>        # special
-          (?: %(?!>) | -(?!%>) )
-          [^\-%]*  # normal*
-        )*
-      )
-      (?: -?%> )?
-    /x
-
-    START_OF_ERB = /
-      <%(?!%)
-    /x
-
-  private
-
-    def setup
-      @ruby_scanner = CodeRay.scanner :ruby, :tokens => @tokens, :keep_tokens => true
-      @html_scanner = CodeRay.scanner :html, :tokens => @tokens, :keep_tokens => true, :keep_state => true
-    end
-
-    def reset_instance
-      super
-      @html_scanner.reset
-    end
-
-    def scan_tokens tokens, options
-
-      until eos?
-
-        if (match = scan_until(/(?=#{START_OF_ERB})/o) || scan_until(/\z/)) and not match.empty?
-          @html_scanner.tokenize match
-
-        elsif match = scan(/#{ERB_RUBY_BLOCK}/o)
-          start_tag = match[/\A<%[-=#]?/]
-          end_tag = match[/-?%?>?\z/]
-          tokens << [:open, :inline]
-          tokens << [start_tag, :inline_delimiter]
-          code = match[start_tag.size .. -1 - end_tag.size]
-          if start_tag == '<%#'
-            tokens << [code, :comment]
-          else
-            @ruby_scanner.tokenize code
-          end
-          tokens << [end_tag, :inline_delimiter] unless end_tag.empty?
-          tokens << [:close, :inline]
-
-        else
-          raise_inspect 'else-case reached!', tokens
-        end
-
-      end
-
-      tokens
-
-    end
-
-  end
-
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/ruby.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/ruby.rb
deleted file mode 100644
index 3cadc64d1..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/ruby.rb
+++ /dev/null
@@ -1,444 +0,0 @@
-# encoding: utf-8
-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.
-  #
-  # For now, I think it's better than the scanners in VIM or Syntax, or
-  # any highlighter I was able to find, except Caleb's RubyLexer.
-  #
-  # I hope it's also better than the rdoc/irb lexer.
-  class Ruby < Scanner
-
-    include Streamable
-
-    register_for :ruby
-    file_extension 'rb'
-
-    helper :patterns
-    
-    if not defined? EncodingError
-      EncodingError = Class.new Exception
-    end
-
-  private
-    def scan_tokens tokens, options
-      if string.respond_to?(:encoding)
-        unless string.encoding == Encoding::UTF_8
-          self.string = string.encode Encoding::UTF_8,
-            :invalid => :replace, :undef => :replace, :replace => '?'
-        end
-        unicode = false
-      else
-        unicode = exist?(/[^\x00-\x7f]/)
-      end
-      
-      last_token_dot = false
-      value_expected = true
-      heredocs = nil
-      last_state = nil
-      state = :initial
-      depth = nil
-      inline_block_stack = []
-      
-      
-      patterns = Patterns  # avoid constant lookup
-      
-      until eos?
-        match = nil
-        kind = nil
-
-        if state.instance_of? patterns::StringState
-# {{{
-          match = scan_until(state.pattern) || scan_until(/\z/)
-          tokens << [match, :content] unless match.empty?
-          break if eos?
-
-          if state.heredoc and self[1]  # end of heredoc
-            match = getch.to_s
-            match << scan_until(/$/) unless eos?
-            tokens << [match, :delimiter]
-            tokens << [:close, state.type]
-            state = state.next_state
-            next
-          end
-
-          case match = getch
-
-          when state.delim
-            if state.paren
-              state.paren_depth -= 1
-              if state.paren_depth > 0
-                tokens << [match, :nesting_delimiter]
-                next
-              end
-            end
-            tokens << [match, :delimiter]
-            if state.type == :regexp and not eos?
-              modifiers = scan(/#{patterns::REGEXP_MODIFIERS}/ox)
-              tokens << [modifiers, :modifier] unless modifiers.empty?
-            end
-            tokens << [:close, state.type]
-            value_expected = false
-            state = state.next_state
-
-          when '\\'
-            if state.interpreted
-              if esc = scan(/ #{patterns::ESCAPE} /ox)
-                tokens << [match + esc, :char]
-              else
-                tokens << [match, :error]
-              end
-            else
-              case m = getch
-              when state.delim, '\\'
-                tokens << [match + m, :char]
-              when nil
-                tokens << [match, :error]
-              else
-                tokens << [match + m, :content]
-              end
-            end
-
-          when '#'
-            case peek(1)
-            when '{'
-              inline_block_stack << [state, depth, heredocs]
-              value_expected = true
-              state = :initial
-              depth = 1
-              tokens << [:open, :inline]
-              tokens << [match + getch, :inline_delimiter]
-            when '$', '@'
-              tokens << [match, :escape]
-              last_state = state  # scan one token as normal code, then return here
-              state = :initial
-            else
-              raise_inspect 'else-case # reached; #%p not handled' % peek(1), tokens
-            end
-
-          when state.paren
-            state.paren_depth += 1
-            tokens << [match, :nesting_delimiter]
-
-          when /#{patterns::REGEXP_SYMBOLS}/ox
-            tokens << [match, :function]
-
-          else
-            raise_inspect 'else-case " reached; %p not handled, state = %p' % [match, state], tokens
-
-          end
-          next
-# }}}
-        else
-# {{{
-          if match = scan(/[ \t\f]+/)
-            kind = :space
-            match << scan(/\s*/) unless eos? || heredocs
-            value_expected = true if match.index(?\n)
-            tokens << [match, kind]
-            next
-            
-          elsif match = scan(/\\?\n/)
-            kind = :space
-            if match == "\n"
-              value_expected = true
-              state = :initial if state == :undef_comma_expected
-            end
-            if heredocs
-              unscan  # heredoc scanning needs \n at start
-              state = heredocs.shift
-              tokens << [:open, state.type]
-              heredocs = nil if heredocs.empty?
-              next
-            else
-              match << scan(/\s*/) unless eos?
-            end
-            tokens << [match, kind]
-            next
-          
-          elsif bol? && match = scan(/\#!.*/)
-            tokens << [match, :doctype]
-            next
-            
-          elsif match = scan(/\#.*/) or
-            ( bol? and match = scan(/#{patterns::RUBYDOC_OR_DATA}/o) )
-              kind = :comment
-              tokens << [match, kind]
-              next
-
-          elsif state == :initial
-
-            # IDENTS #
-            if match = scan(unicode ? /#{patterns::METHOD_NAME}/uo :
-                                      /#{patterns::METHOD_NAME}/o)
-              if last_token_dot
-                kind = if match[/^[A-Z]/] and not match?(/\(/) then :constant else :ident end
-              else
-                if value_expected != :expect_colon && scan(/:(?= )/)
-                  tokens << [match, :key]
-                  match = ':'
-                  kind = :operator
-                else
-                  kind = patterns::IDENT_KIND[match]
-                  if kind == :ident
-                    if match[/\A[A-Z]/] and not match[/[!?]$/] and not match?(/\(/)
-                      kind = :constant
-                    end
-                  elsif kind == :reserved
-                    state = patterns::DEF_NEW_STATE[match]
-                    value_expected = :set if patterns::KEYWORDS_EXPECTING_VALUE[match]
-                  end
-                end
-              end
-              value_expected = :set if check(/#{patterns::VALUE_FOLLOWS}/o)
-            
-            elsif last_token_dot and match = scan(/#{patterns::METHOD_NAME_OPERATOR}|\(/o)
-              kind = :ident
-              value_expected = :set if check(unicode ? /#{patterns::VALUE_FOLLOWS}/uo :
-                                                       /#{patterns::VALUE_FOLLOWS}/o)
-
-            # OPERATORS #
-            elsif not last_token_dot and match = scan(/ \.\.\.? | (?:\.|::)() | [,\(\)\[\]\{\}] | ==?=? /x)
-              if match !~ / [.\)\]\}] /x or match =~ /\.\.\.?/
-                value_expected = :set
-              end
-              last_token_dot = :set if self[1]
-              kind = :operator
-              unless inline_block_stack.empty?
-                case match
-                when '{'
-                  depth += 1
-                when '}'
-                  depth -= 1
-                  if depth == 0  # closing brace of inline block reached
-                    state, depth, heredocs = inline_block_stack.pop
-                    heredocs = nil if heredocs && heredocs.empty?
-                    tokens << [match, :inline_delimiter]
-                    kind = :inline
-                    match = :close
-                  end
-                end
-              end
-
-            elsif match = scan(/ ['"] /mx)
-              tokens << [:open, :string]
-              kind = :delimiter
-              state = patterns::StringState.new :string, match == '"', match  # important for streaming
-
-            elsif match = scan(unicode ? /#{patterns::INSTANCE_VARIABLE}/uo :
-                                         /#{patterns::INSTANCE_VARIABLE}/o)
-              kind = :instance_variable
-
-            elsif value_expected and match = scan(/\//)
-              tokens << [:open, :regexp]
-              kind = :delimiter
-              interpreted = true
-              state = patterns::StringState.new :regexp, interpreted, match
-
-            # elsif match = scan(/[-+]?#{patterns::NUMERIC}/o)
-            elsif match = value_expected ? scan(/[-+]?#{patterns::NUMERIC}/o) : scan(/#{patterns::NUMERIC}/o)
-              kind = self[1] ? :float : :integer
-
-            elsif match = scan(unicode ? /#{patterns::SYMBOL}/uo :
-                                         /#{patterns::SYMBOL}/o)
-              case delim = match[1]
-              when ?', ?"
-                tokens << [:open, :symbol]
-                tokens << [':', :symbol]
-                match = delim.chr
-                kind = :delimiter
-                state = patterns::StringState.new :symbol, delim == ?", match
-              else
-                kind = :symbol
-              end
-
-            elsif match = scan(/ -[>=]? | [+!~^]=? | [*|&]{1,2}=? | >>? /x)
-              value_expected = :set
-              kind = :operator
-
-            elsif value_expected and match = scan(unicode ? /#{patterns::HEREDOC_OPEN}/uo :
-                                                            /#{patterns::HEREDOC_OPEN}/o)
-              indented = self[1] == '-'
-              quote = self[3]
-              delim = self[quote ? 4 : 2]
-              kind = patterns::QUOTE_TO_TYPE[quote]
-              tokens << [:open, kind]
-              tokens << [match, :delimiter]
-              match = :close
-              heredoc = patterns::StringState.new kind, quote != '\'', delim, (indented ? :indented : :linestart )
-              heredocs ||= []  # create heredocs if empty
-              heredocs << heredoc
-
-            elsif value_expected and match = scan(/#{patterns::FANCY_START_CORRECT}/o)
-              kind, interpreted = *patterns::FancyStringType.fetch(self[1]) do
-                raise_inspect 'Unknown fancy string: %%%p' % k, tokens
-              end
-              tokens << [:open, kind]
-              state = patterns::StringState.new kind, interpreted, self[2]
-              kind = :delimiter
-
-            elsif value_expected and match = scan(unicode ? /#{patterns::CHARACTER}/uo :
-                                                            /#{patterns::CHARACTER}/o)
-              kind = :integer
-
-            elsif match = scan(/ [\/%]=? | <(?:<|=>?)? | [?:;] /x)
-              value_expected = :set
-              kind = :operator
-
-            elsif match = scan(/`/)
-              if last_token_dot
-                kind = :operator
-              else
-                tokens << [:open, :shell]
-                kind = :delimiter
-                state = patterns::StringState.new :shell, true, match
-              end
-
-            elsif match = scan(unicode ? /#{patterns::GLOBAL_VARIABLE}/uo :
-                                         /#{patterns::GLOBAL_VARIABLE}/o)
-              kind = :global_variable
-
-            elsif match = scan(unicode ? /#{patterns::CLASS_VARIABLE}/uo :
-                                         /#{patterns::CLASS_VARIABLE}/o)
-              kind = :class_variable
-
-            else
-              if !unicode && !string.respond_to?(:encoding)
-                # check for unicode
-                debug, $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
-                end
-                next if unicode
-              end
-              kind = :error
-              match = scan(unicode ? /./mu : /./m)
-
-            end
-
-          elsif state == :def_expected
-            state = :initial
-            if scan(/self\./)
-              tokens << ['self', :pre_constant]
-              tokens << ['.', :operator]
-            end
-            if match = scan(unicode ? /(?>#{patterns::METHOD_NAME_EX})(?!\.|::)/uo :
-                                      /(?>#{patterns::METHOD_NAME_EX})(?!\.|::)/o)
-              kind = :method
-            else
-              next
-            end
-
-          elsif state == :module_expected
-            if match = scan(/<</)
-              kind = :operator
-            else
-              state = :initial
-              if match = scan(unicode ? /(?:#{patterns::IDENT}::)*#{patterns::IDENT}/uo :
-                                        /(?:#{patterns::IDENT}::)*#{patterns::IDENT}/o)
-                kind = :class
-              else
-                next
-              end
-            end
-
-          elsif state == :undef_expected
-            state = :undef_comma_expected
-            if match = scan(unicode ? /#{patterns::METHOD_NAME_EX}/uo :
-                                      /#{patterns::METHOD_NAME_EX}/o)
-              kind = :method
-            elsif match = scan(unicode ? /#{patterns::SYMBOL}/uo :
-                                         /#{patterns::SYMBOL}/o)
-              case delim = match[1]
-              when ?', ?"
-                tokens << [:open, :symbol]
-                tokens << [':', :symbol]
-                match = delim.chr
-                kind = :delimiter
-                state = patterns::StringState.new :symbol, delim == ?", match
-                state.next_state = :undef_comma_expected
-              else
-                kind = :symbol
-              end
-            else
-              state = :initial
-              next
-            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
-              tokens << [self[1], (self[1][0] == ?: ? :symbol : :method)]
-              tokens << [self[2], :space]
-              tokens << [self[3], (self[3][0] == ?: ? :symbol : :method)]
-            end
-            state = :initial
-            next
-
-          elsif state == :undef_comma_expected
-            if match = scan(/,/)
-              kind = :operator
-              state = :undef_expected
-            else
-              state = :initial
-              next
-            end
-
-          end
-# }}}
-          
-          unless kind == :error
-            if value_expected = value_expected == :set
-              value_expected = :expect_colon if match == '?' || match == 'when'
-            end
-            last_token_dot = last_token_dot == :set
-          end
-          
-          if $CODERAY_DEBUG and not kind
-            raise_inspect 'Error token %p in line %d' %
-              [[match, kind], line], tokens, state
-          end
-          raise_inspect 'Empty token', tokens unless match
-
-          tokens << [match, kind]
-
-          if last_state
-            state = last_state
-            last_state = nil
-          end
-        end
-      end
-
-      inline_block_stack << [state] if state.is_a? patterns::StringState
-      until inline_block_stack.empty?
-        this_block = inline_block_stack.pop
-        tokens << [:close, :inline] if this_block.size > 1
-        state = this_block.first
-        tokens << [:close, state.type]
-      end
-
-      tokens
-    end
-
-  end
-
-end
-end
-
-# vim:fdm=marker
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/ruby/patterns.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/ruby/patterns.rb
deleted file mode 100644
index ba3ac8a46..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/ruby/patterns.rb
+++ /dev/null
@@ -1,252 +0,0 @@
-# encoding: utf-8
-module CodeRay
-module Scanners
-
-  module Ruby::Patterns  # :nodoc:
-
-    RESERVED_WORDS = %w[
-      and def end in or unless begin
-      defined? ensure module redo super until
-      BEGIN break do next rescue then
-      when END case else for retry
-      while alias class elsif if not return
-      undef yield
-    ]
-
-    DEF_KEYWORDS = %w[ def ]
-    UNDEF_KEYWORDS = %w[ undef ]
-    ALIAS_KEYWORDS = %w[ alias ]
-    MODULE_KEYWORDS = %w[ class module ]
-    DEF_NEW_STATE = WordList.new(:initial).
-      add(DEF_KEYWORDS, :def_expected).
-      add(UNDEF_KEYWORDS, :undef_expected).
-      add(ALIAS_KEYWORDS, :alias_expected).
-      add(MODULE_KEYWORDS, :module_expected)
-
-    PREDEFINED_CONSTANTS = %w[
-      nil true false self
-      DATA ARGV ARGF
-      __FILE__ __LINE__ __ENCODING__
-    ]
-
-    IDENT_KIND = WordList.new(:ident).
-      add(RESERVED_WORDS, :reserved).
-      add(PREDEFINED_CONSTANTS, :pre_constant)
-
-    if /\w/u === '∑'
-      # MRI 1.8.6, 1.8.7
-      IDENT = /[^\W\d]\w*/
-    else
-      if //.respond_to? :encoding
-        # MRI 1.9.1, 1.9.2
-        IDENT = Regexp.new '[\p{L}\p{M}\p{Pc}\p{Sm}&&[^\x00-\x40\x5b-\x5e\x60\x7b-\x7f]][\p{L}\p{M}\p{N}\p{Pc}\p{Sm}&&[^\x00-\x2f\x3a-\x40\x5b-\x5e\x60\x7b-\x7f]]*'
-      else
-        # JRuby, Rubinius
-        IDENT = /[^\x00-\x40\x5b-\x5e\x60\x7b-\x7f][^\x00-\x2f\x3a-\x40\x5b-\x5e\x60\x7b-\x7f]*/
-      end
-    end
-
-    METHOD_NAME = / #{IDENT} [?!]? /ox
-    METHOD_NAME_OPERATOR = /
-      \*\*?           # multiplication and power
-      | [-+~]@?       # plus, minus, tilde with and without at sign
-      | [\/%&|^`]     # division, modulo or format strings, and, or, xor, system
-      | \[\]=?        # array getter and setter
-      | << | >>       # append or shift left, shift right
-      | <=?>? | >=?   # comparison, rocket operator
-      | ===? | =~     # simple equality, case equality, match
-      | ![~=@]?       # negation with and without at sign, not-equal and not-match
-    /ox
-    METHOD_NAME_EX = / #{IDENT} (?:[?!]|=(?!>))? | #{METHOD_NAME_OPERATOR} /ox
-    INSTANCE_VARIABLE = / @ #{IDENT} /ox
-    CLASS_VARIABLE = / @@ #{IDENT} /ox
-    OBJECT_VARIABLE = / @@? #{IDENT} /ox
-    GLOBAL_VARIABLE = / \$ (?: #{IDENT} | [1-9]\d* | 0\w* | [~&+`'=\/,;_.<>!@$?*":\\] | -[a-zA-Z_0-9] ) /ox
-    PREFIX_VARIABLE = / #{GLOBAL_VARIABLE} | #{OBJECT_VARIABLE} /ox
-    VARIABLE = / @?@? #{IDENT} | #{GLOBAL_VARIABLE} /ox
-
-    QUOTE_TO_TYPE = {
-      '`' => :shell,
-      '/'=> :regexp,
-    }
-    QUOTE_TO_TYPE.default = :string
-
-    REGEXP_MODIFIERS = /[mixounse]*/
-    REGEXP_SYMBOLS = /[|?*+(){}\[\].^$]/
-
-    DECIMAL = /\d+(?:_\d+)*/
-    OCTAL = /0_?[0-7]+(?:_[0-7]+)*/
-    HEXADECIMAL = /0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*/
-    BINARY = /0b[01]+(?:_[01]+)*/
-
-    EXPONENT = / [eE] [+-]? #{DECIMAL} /ox
-    FLOAT_SUFFIX = / #{EXPONENT} | \. #{DECIMAL} #{EXPONENT}? /ox
-    FLOAT_OR_INT = / #{DECIMAL} (?: #{FLOAT_SUFFIX} () )? /ox
-    NUMERIC = / (?: (?=0) (?: #{OCTAL} | #{HEXADECIMAL} | #{BINARY} ) | #{FLOAT_OR_INT} ) /ox
-
-    SYMBOL = /
-      :
-      (?:
-        #{METHOD_NAME_EX}
-      | #{PREFIX_VARIABLE}
-      | ['"]
-      )
-    /ox
-    METHOD_NAME_OR_SYMBOL = / #{METHOD_NAME_EX} | #{SYMBOL} /ox
-
-    SIMPLE_ESCAPE = /
-        [abefnrstv]
-      |  [0-7]{1,3}
-      | x[0-9A-Fa-f]{1,2}
-      | .?
-    /mx
-    
-    CONTROL_META_ESCAPE = /
-      (?: M-|C-|c )
-      (?: \\ (?: M-|C-|c ) )*
-      (?: [^\\] | \\ #{SIMPLE_ESCAPE} )?
-    /mox
-    
-    ESCAPE = /
-      #{CONTROL_META_ESCAPE} | #{SIMPLE_ESCAPE}
-    /mox
-    
-    CHARACTER = /
-      \?
-      (?:
-        [^\s\\]
-      | \\ #{ESCAPE}
-      )
-    /mox
-
-    # NOTE: This is not completely correct, but
-    # nobody needs heredoc delimiters ending with \n.
-    # Also, delimiters starting with numbers are allowed.
-    # but they are more often than not a false positive.
-    HEREDOC_OPEN = /
-      << (-)?              # $1 = float
-      (?:
-        ( #{IDENT} )       # $2 = delim
-      |
-        ( ["'`\/] )        # $3 = quote, type
-        ( [^\n]*? ) \3     # $4 = delim
-      )
-    /mx
-
-    RUBYDOC = /
-      =begin (?!\S)
-      .*?
-      (?: \Z | ^=end (?!\S) [^\n]* )
-    /mx
-
-    DATA = /
-      __END__$
-      .*?
-      (?: \Z | (?=^\#CODE) )
-    /mx
-    
-    # Checks for a valid value to follow. This enables
-    # value_expected in method calls without parentheses.
-    VALUE_FOLLOWS = /
-      (?>[ \t\f\v]+)
-      (?:
-        [%\/][^\s=]
-      | <<-?\S
-      | [-+] \d
-      | #{CHARACTER}
-      )
-    /x
-    KEYWORDS_EXPECTING_VALUE = WordList.new.add(%w[
-      and end in or unless begin
-      defined? ensure redo super until
-      break do next rescue then
-      when case else for retry
-      while elsif if not return
-      yield
-    ])
-
-    RUBYDOC_OR_DATA = / #{RUBYDOC} | #{DATA} /xo
-
-    RDOC_DATA_START = / ^=begin (?!\S) | ^__END__$ /x
-
-    FANCY_START_CORRECT = / % ( [qQwWxsr] | (?![a-zA-Z0-9]) ) ([^a-zA-Z0-9]) /mx
-
-    FancyStringType = {
-      'q' => [:string, false],
-      'Q' => [:string, true],
-      'r' => [:regexp, true],
-      's' => [:symbol, false],
-      'x' => [:shell, true]
-    }
-    FancyStringType['w'] = FancyStringType['q']
-    FancyStringType['W'] = FancyStringType[''] = FancyStringType['Q']
-
-    class StringState < Struct.new :type, :interpreted, :delim, :heredoc,
-      :paren, :paren_depth, :pattern, :next_state
-
-      CLOSING_PAREN = Hash[ *%w[
-        ( )
-        [ ]
-        < >
-        { }
-      ] ]
-
-      CLOSING_PAREN.each { |k,v| k.freeze; v.freeze }  # debug, if I try to change it with <<
-      OPENING_PAREN = CLOSING_PAREN.invert
-
-      STRING_PATTERN = Hash.new do |h, k|
-        delim, interpreted = *k
-        delim_pattern = Regexp.escape(delim.dup)  # dup: workaround for old Ruby
-        if closing_paren = CLOSING_PAREN[delim]
-          delim_pattern = delim_pattern[0..-1] if defined? JRUBY_VERSION  # JRuby fix
-          delim_pattern << Regexp.escape(closing_paren)
-        end
-        delim_pattern << '\\\\' unless delim == '\\'
-        
-        special_escapes =
-          case interpreted
-          when :regexp_symbols
-            '| ' + REGEXP_SYMBOLS.source
-          when :words
-            '| \s'
-          end
-        
-        h[k] =
-          if interpreted and not delim == '#'
-            / (?= [#{delim_pattern}] | \# [{$@] #{special_escapes} ) /mx
-          else
-            / (?= [#{delim_pattern}] #{special_escapes} ) /mx
-          end
-      end
-
-      HEREDOC_PATTERN = Hash.new do |h, k|
-        delim, interpreted, indented = *k
-        delim_pattern = Regexp.escape(delim.dup)  # dup: workaround for old Ruby
-        delim_pattern = / \n #{ '(?>[\ \t]*)' if indented } #{ Regexp.new delim_pattern } $ /x
-        h[k] =
-          if interpreted
-            / (?= #{delim_pattern}() | \\ | \# [{$@] ) /mx  # $1 set == end of heredoc
-          else
-            / (?= #{delim_pattern}() | \\ ) /mx
-          end
-      end
-
-      def initialize kind, interpreted, delim, heredoc = false
-        if heredoc
-          pattern = HEREDOC_PATTERN[ [delim, interpreted, heredoc == :indented] ]
-          delim = nil
-        else
-          pattern = STRING_PATTERN[ [delim, interpreted] ]
-          if paren = CLOSING_PAREN[delim]
-            delim, paren = paren, delim
-            paren_depth = 1
-          end
-        end
-        super kind, interpreted, delim, heredoc, paren, paren_depth, pattern, :initial
-      end
-    end unless defined? StringState
-
-  end
-
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/scheme.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/scheme.rb
deleted file mode 100644
index ba22b80be..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/scheme.rb
+++ /dev/null
@@ -1,145 +0,0 @@
-module CodeRay
-  module Scanners
-
-    # Scheme scanner for CodeRay (by closure).
-    # Thanks to murphy for putting CodeRay into public.
-    class Scheme < Scanner
-      
-      # TODO: function defs
-      # TODO: built-in functions
-      
-      register_for :scheme
-      file_extension 'scm'
-
-      CORE_FORMS = %w[
-        lambda let let* letrec syntax-case define-syntax let-syntax
-        letrec-syntax begin define quote if or and cond case do delay
-        quasiquote set! cons force call-with-current-continuation call/cc
-      ]
-
-      IDENT_KIND = CaseIgnoringWordList.new(:ident).
-        add(CORE_FORMS, :reserved)
-      
-      #IDENTIFIER_INITIAL = /[a-z!@\$%&\*\/\:<=>\?~_\^]/i
-      #IDENTIFIER_SUBSEQUENT = /#{IDENTIFIER_INITIAL}|\d|\.|\+|-/
-      #IDENTIFIER = /#{IDENTIFIER_INITIAL}#{IDENTIFIER_SUBSEQUENT}*|\+|-|\.{3}/
-      IDENTIFIER = /[a-zA-Z!@$%&*\/:<=>?~_^][\w!@$%&*\/:<=>?~^.+\-]*|[+-]|\.\.\./
-      DIGIT = /\d/
-      DIGIT10 = DIGIT
-      DIGIT16 = /[0-9a-f]/i
-      DIGIT8 = /[0-7]/
-      DIGIT2 = /[01]/
-      RADIX16 = /\#x/i
-      RADIX8 = /\#o/i
-      RADIX2 = /\#b/i
-      RADIX10 = /\#d/i
-      EXACTNESS = /#i|#e/i
-      SIGN = /[\+-]?/
-      EXP_MARK = /[esfdl]/i
-      EXP = /#{EXP_MARK}#{SIGN}#{DIGIT}+/
-      SUFFIX = /#{EXP}?/
-      PREFIX10 = /#{RADIX10}?#{EXACTNESS}?|#{EXACTNESS}?#{RADIX10}?/
-      PREFIX16 = /#{RADIX16}#{EXACTNESS}?|#{EXACTNESS}?#{RADIX16}/
-      PREFIX8 = /#{RADIX8}#{EXACTNESS}?|#{EXACTNESS}?#{RADIX8}/
-      PREFIX2 = /#{RADIX2}#{EXACTNESS}?|#{EXACTNESS}?#{RADIX2}/
-      UINT10 = /#{DIGIT10}+#*/
-      UINT16 = /#{DIGIT16}+#*/
-      UINT8 = /#{DIGIT8}+#*/
-      UINT2 = /#{DIGIT2}+#*/
-      DECIMAL = /#{DIGIT10}+#+\.#*#{SUFFIX}|#{DIGIT10}+\.#{DIGIT10}*#*#{SUFFIX}|\.#{DIGIT10}+#*#{SUFFIX}|#{UINT10}#{EXP}/
-      UREAL10 = /#{UINT10}\/#{UINT10}|#{DECIMAL}|#{UINT10}/
-      UREAL16 = /#{UINT16}\/#{UINT16}|#{UINT16}/
-      UREAL8 = /#{UINT8}\/#{UINT8}|#{UINT8}/
-      UREAL2 = /#{UINT2}\/#{UINT2}|#{UINT2}/
-      REAL10 = /#{SIGN}#{UREAL10}/
-      REAL16 = /#{SIGN}#{UREAL16}/
-      REAL8 = /#{SIGN}#{UREAL8}/
-      REAL2 = /#{SIGN}#{UREAL2}/
-      IMAG10 = /i|#{UREAL10}i/
-      IMAG16 = /i|#{UREAL16}i/
-      IMAG8 = /i|#{UREAL8}i/
-      IMAG2 = /i|#{UREAL2}i/
-      COMPLEX10 = /#{REAL10}@#{REAL10}|#{REAL10}\+#{IMAG10}|#{REAL10}-#{IMAG10}|\+#{IMAG10}|-#{IMAG10}|#{REAL10}/
-      COMPLEX16 = /#{REAL16}@#{REAL16}|#{REAL16}\+#{IMAG16}|#{REAL16}-#{IMAG16}|\+#{IMAG16}|-#{IMAG16}|#{REAL16}/
-      COMPLEX8 = /#{REAL8}@#{REAL8}|#{REAL8}\+#{IMAG8}|#{REAL8}-#{IMAG8}|\+#{IMAG8}|-#{IMAG8}|#{REAL8}/
-      COMPLEX2 = /#{REAL2}@#{REAL2}|#{REAL2}\+#{IMAG2}|#{REAL2}-#{IMAG2}|\+#{IMAG2}|-#{IMAG2}|#{REAL2}/
-      NUM10 = /#{PREFIX10}?#{COMPLEX10}/
-      NUM16 = /#{PREFIX16}#{COMPLEX16}/
-      NUM8 = /#{PREFIX8}#{COMPLEX8}/
-      NUM2 = /#{PREFIX2}#{COMPLEX2}/
-      NUM = /#{NUM10}|#{NUM16}|#{NUM8}|#{NUM2}/
-    
-    private
-      def scan_tokens tokens,options
-        
-        state = :initial
-        ident_kind = IDENT_KIND
-        
-        until eos?
-          kind = match = nil
-          
-          case state
-          when :initial
-            if scan(/ \s+ | \\\n /x)
-              kind = :space
-            elsif scan(/['\(\[\)\]]|#\(/)
-              kind = :operator_fat
-            elsif scan(/;.*/)
-              kind = :comment
-            elsif scan(/#\\(?:newline|space|.?)/)
-              kind = :char
-            elsif scan(/#[ft]/)
-              kind = :pre_constant
-            elsif scan(/#{IDENTIFIER}/o)
-              kind = ident_kind[matched]
-            elsif scan(/\./)
-              kind = :operator
-            elsif scan(/"/)
-              tokens << [:open, :string]
-              state = :string
-              tokens << ['"', :delimiter]
-              next
-            elsif scan(/#{NUM}/o) and not matched.empty?
-              kind = :integer
-            elsif getch
-              kind = :error
-            end
-            
-          when :string
-            if scan(/[^"\\]+/) or scan(/\\.?/)
-              kind = :content
-            elsif scan(/"/)
-              tokens << ['"', :delimiter]
-              tokens << [:close, :string]
-              state = :initial
-              next
-            else
-              raise_inspect "else case \" reached; %p not handled." % peek(1),
-                tokens, state
-            end
-            
-          else
-            raise "else case reached"
-          end
-          
-          match ||= matched
-          if $CODERAY_DEBUG and not kind
-            raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens
-          end
-          raise_inspect 'Empty token', tokens, state unless match
-          
-          tokens << [match, kind]
-          
-        end  # until eos
-        
-        if state == :string
-          tokens << [:close, :string]
-        end
-        
-        tokens
-        
-      end #scan_tokens
-    end #class
-  end #module scanners
-end #module coderay
\ No newline at end of file
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/sql.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/sql.rb
deleted file mode 100644
index 890758162..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/sql.rb
+++ /dev/null
@@ -1,162 +0,0 @@
-module CodeRay module Scanners
-  
-  # by Josh Goebel
-  class SQL < Scanner
-
-    register_for :sql
-    
-    RESERVED_WORDS = %w(
-      create database table index trigger drop primary key set select
-      insert update delete replace into
-      on from values before and or if exists case when
-      then else as group order by avg where
-      join inner outer union engine not
-      like end using collate show columns begin
-    )
-    
-    PREDEFINED_TYPES = %w(
-      char varchar enum binary text tinytext mediumtext
-      longtext blob tinyblob mediumblob longblob timestamp
-      date time datetime year double decimal float int
-      integer tinyint mediumint bigint smallint unsigned bit
-      bool boolean hex bin oct
-    )
-    
-    PREDEFINED_FUNCTIONS = %w( sum cast abs pi count min max avg )
-    
-    DIRECTIVES = %w( auto_increment unique default charset )
-
-    PREDEFINED_CONSTANTS = %w( null true false )
-    
-    IDENT_KIND = CaseIgnoringWordList.new(:ident).
-      add(RESERVED_WORDS, :reserved).
-      add(PREDEFINED_TYPES, :pre_type).
-      add(PREDEFINED_CONSTANTS, :pre_constant).
-      add(PREDEFINED_FUNCTIONS, :predefined).
-      add(DIRECTIVES, :directive)
-    
-    ESCAPE = / [rbfntv\n\\\/'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} | . /mx
-    UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} | U[a-fA-F0-9]{8} /x
-    
-    STRING_PREFIXES = /[xnb]|_\w+/i
-    
-    def scan_tokens tokens, options
-      
-      state = :initial
-      string_type = nil
-      string_content = ''
-      
-      until eos?
-        
-        kind = nil
-        match = nil
-        
-        if state == :initial
-          
-          if scan(/ \s+ | \\\n /x)
-            kind = :space
-          
-          elsif scan(/(?:--\s?|#).*/)
-            kind = :comment
-            
-          elsif scan(%r! /\* (?: .*? \*/ | .* ) !mx)
-            kind = :comment
-            
-          elsif scan(/ [-+*\/=<>;,!&^|()\[\]{}~%] | \.(?!\d) /x)
-            kind = :operator
-            
-          elsif scan(/(#{STRING_PREFIXES})?([`"'])/o)
-            prefix = self[1]
-            string_type = self[2]
-            tokens << [:open, :string]
-            tokens << [prefix, :modifier] if prefix
-            match = string_type
-            state = :string
-            kind = :delimiter
-            
-          elsif match = scan(/ @? [A-Za-z_][A-Za-z_0-9]* /x)
-            kind = match[0] == ?@ ? :variable : IDENT_KIND[match.downcase]
-            
-          elsif scan(/0[xX][0-9A-Fa-f]+/)
-            kind = :hex
-            
-          elsif scan(/0[0-7]+(?![89.eEfF])/)
-            kind = :oct
-            
-          elsif scan(/(?>\d+)(?![.eEfF])/)
-            kind = :integer
-            
-          elsif scan(/\d[fF]|\d*\.\d+(?:[eE][+-]?\d+)?|\d+[eE][+-]?\d+/)
-            kind = :float
-            
-          else
-            getch
-            kind = :error
-            
-          end
-          
-        elsif state == :string
-          if match = scan(/[^\\"'`]+/)
-            string_content << match
-            next
-          elsif match = scan(/["'`]/)
-            if string_type == match
-              if peek(1) == string_type  # doubling means escape
-                string_content << string_type << getch
-                next
-              end
-              unless string_content.empty?
-                tokens << [string_content, :content]
-                string_content = ''
-              end
-              tokens << [matched, :delimiter]
-              tokens << [:close, :string]
-              state = :initial
-              string_type = nil
-              next
-            else
-              string_content << match
-            end
-            next
-          elsif scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
-            unless string_content.empty?
-              tokens << [string_content, :content]
-              string_content = ''
-            end
-            kind = :char
-          elsif match = scan(/ \\ . /mox)
-            string_content << match
-            next
-          elsif scan(/ \\ | $ /x)
-            unless string_content.empty?
-              tokens << [string_content, :content]
-              string_content = ''
-            end
-            kind = :error
-            state = :initial
-          else
-            raise "else case \" reached; %p not handled." % peek(1), tokens
-          end
-          
-        else
-          raise 'else-case reached', tokens
-          
-        end
-        
-        match ||= matched
-        unless kind
-          raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens, state
-        end
-        raise_inspect 'Empty token', tokens unless match
-        
-        tokens << [match, kind]
-        
-      end
-      tokens
-      
-    end
-    
-  end
-  
-end end
\ No newline at end of file
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/xml.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/xml.rb
deleted file mode 100644
index aeabeca86..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/xml.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-module CodeRay
-module Scanners
-
-  load :html
-
-  # XML Scanner
-  #
-  # Currently this is the same scanner as Scanners::HTML.
-  class XML < HTML
-
-    register_for :xml
-    file_extension 'xml'
-    
-  end
-
-end
-end
diff --git a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/yaml.rb b/vendor/gems/coderay-0.9.7/lib/coderay/scanners/yaml.rb
deleted file mode 100644
index 7903ab970..000000000
--- a/vendor/gems/coderay-0.9.7/lib/coderay/scanners/yaml.rb
+++ /dev/null
@@ -1,140 +0,0 @@
-module CodeRay
-module Scanners
-  
-  # YAML Scanner
-  #
-  # Based on the YAML scanner from Syntax by Jamis Buck.
-  class YAML < Scanner
-    
-    register_for :yaml
-    file_extension 'yml'
-    
-    KINDS_NOT_LOC = :all
-    
-    def scan_tokens tokens, options
-      
-      value_expected = nil
-      state = :initial
-      key_indent = indent = 0
-      
-      until eos?
-        
-        kind = nil
-        match = nil
-        key_indent = nil if bol?
-        
-        if match = scan(/ +[\t ]*/)
-          kind = :space
-          
-        elsif match = scan(/\n+/)
-          kind = :space
-          state = :initial if match.index(?\n)
-          
-        elsif match = scan(/#.*/)
-          kind = :comment
-          
-        elsif bol? and case
-          when match = scan(/---|\.\.\./)
-            tokens << [:open, :head]
-            tokens << [match, :head]
-            tokens << [:close, :head]
-            next
-          when match = scan(/%.*/)
-            tokens << [match, :doctype]
-            next
-          end
-        
-        elsif state == :value and case
-          when !check(/(?:"[^"]*")(?=: |:$)/) && scan(/"/)
-            tokens << [:open, :string]
-            tokens << [matched, :delimiter]
-            tokens << [matched, :content] if scan(/ [^"\\]* (?: \\. [^"\\]* )* /mx)
-            tokens << [matched, :delimiter] if scan(/"/)
-            tokens << [:close, :string]
-            next
-          when match = scan(/[|>][-+]?/)
-            tokens << [:open, :string]
-            tokens << [match, :delimiter]
-            string_indent = key_indent || column(pos - match.size - 1)
-            tokens << [matched, :content] if scan(/(?:\n+ {#{string_indent + 1}}.*)+/)
-            tokens << [:close, :string]
-            next
-          when match = scan(/(?![!"*&]).+?(?=$|\s+#)/)
-            tokens << [match, :string]
-            string_indent = key_indent || column(pos - match.size - 1)
-            tokens << [matched, :string] if scan(/(?:\n+ {#{string_indent + 1}}.*)+/)
-            next
-          end
-          
-        elsif case
-          when match = scan(/[-:](?= |$)/)
-            state = :value if state == :colon && (match == ':' || match == '-')
-            state = :value if state == :initial && match == '-'
-            kind = :operator
-          when match = scan(/[,{}\[\]]/)
-            kind = :operator
-          when state == :initial && match = scan(/[\w.() ]*\S(?=: |:$)/)
-            kind = :key
-            key_indent = column(pos - match.size - 1)
-            # tokens << [key_indent.inspect, :debug]
-            state = :colon
-          when match = scan(/(?:"[^"\n]*"|'[^'\n]*')(?=: |:$)/)
-            tokens << [:open, :key]
-            tokens << [match[0,1], :delimiter]
-            tokens << [match[1..-2], :content]
-            tokens << [match[-1,1], :delimiter]
-            tokens << [:close, :key]
-            key_indent = column(pos - match.size - 1)
-            # tokens << [key_indent.inspect, :debug]
-            state = :colon
-            next
-          when scan(/(![\w\/]+)(:([\w:]+))?/)
-            tokens << [self[1], :type]
-            if self[2]
-              tokens << [':', :operator]
-              tokens << [self[3], :class]
-            end
-            next
-          when scan(/&\S+/)
-            kind = :variable
-          when scan(/\*\w+/)
-            kind = :global_variable
-          when scan(/<</)
-            kind = :class_variable
-          when scan(/\d\d:\d\d:\d\d/)
-            kind = :oct
-          when scan(/\d\d\d\d-\d\d-\d\d\s\d\d:\d\d:\d\d(\.\d+)? [-+]\d\d:\d\d/)
-            kind = :oct
-          when scan(/:\w+/)
-            kind = :symbol
-          when scan(/[^:\s]+(:(?! |$)[^:\s]*)* .*/)
-            kind = :error
-          when scan(/[^:\s]+(:(?! |$)[^:\s]*)*/)
-            kind = :error
-          end
-          
-        else
-          getch
-          kind = :error
-          
-        end
-        
-        match ||= matched
-        
-        if $CODERAY_DEBUG and not kind
-          raise_inspect 'Error token %p in line %d' %
-            [[match, kind], line], tokens, state
-        end
-        raise_inspect 'Empty token', tokens, state unless match
-        
-        tokens << [match, kind]
-        
-      end
-      
-      tokens
-    end
-    
-  end
-  
-end
-end