raldred-coderay 0.9.0 → 0.9.339

data/lib/coderay/scanners/css.rb

@@ -0,0 +1,202 @@
+module CodeRay
+module Scanners
+
+  class CSS < Scanner
+
+    register_for :css
+
+    module RE
+      NonASCII = /[\x80-\xFF]/
+      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]|#{NonASCII}|#{Escape}/
+      NMStart = /[_a-zA-Z]|#{NonASCII}|#{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 = :keyword
+            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 $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

data/lib/coderay/scanners/debug.rb

@@ -0,0 +1,61 @@
+module CodeRay
+module Scanners
+
+  # = Debug Scanner
+  class Debug < Scanner
+
+    include Streamable
+    register_for :debug
+    file_extension 'raydebug'
+
+  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 scan(/ > /x)
+            kind = opened_tokens.pop
+            match = :close
+            
+          else
+            kind = :error
+            getch
+
+          end
+                  
+        match ||= matched
+        if $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

data/lib/coderay/scanners/delphi.rb

@@ -0,0 +1,150 @@
+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, caching=true).
+      add(RESERVED_WORDS, :reserved).
+      add(DIRECTIVES, :directive)
+    
+    NAME_FOLLOWS = CaseIgnoringWordList.new(false, caching=true).
+      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 $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

data/lib/coderay/scanners/diff.rb

@@ -0,0 +1,104 @@
+module CodeRay
+module Scanners
+  
+  class Diff < Scanner
+    
+    register_for :diff
+    
+    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 scan(/(@@)((?>[^@\n]*))(@@)/)
+            tokens << [:begin_line, line_kind = :change]
+            tokens << [self[1], :change]
+            tokens << [self[2], :plain]
+            tokens << [self[3], :change]
+            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 = :head]
+            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 $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