coderay 0.9.8 → 1.0.0

data/lib/coderay/scanners/text.rb

@@ -0,0 +1,26 @@
+module CodeRay
+  module Scanners
+    
+    # Scanner for plain text.
+    # 
+    # Yields just one token of the kind :plain.
+    # 
+    # Alias: +plaintext+, +plain+
+    class Text < Scanner
+      
+      register_for :text
+      title 'Plain text'
+      
+      KINDS_NOT_LOC = [:plain]  # :nodoc:
+      
+    protected
+      
+      def scan_tokens encoder, options
+        encoder.text_token string, :plain
+        encoder
+      end
+      
+    end
+    
+  end
+end

data/lib/coderay/scanners/xml.rb

@@ -3,7 +3,7 @@ module Scanners
 
   load :html
 
-  # XML Scanner
+  # Scanner for XML.
   #
   # Currently this is the same scanner as Scanners::HTML.
   class XML < HTML

data/lib/coderay/scanners/yaml.rb

@@ -1,7 +1,7 @@
 module CodeRay
 module Scanners
   
-  # YAML Scanner
+  # Scanner for YAML.
   #
   # Based on the YAML scanner from Syntax by Jamis Buck.
   class YAML < Scanner
@@ -11,57 +11,59 @@ module Scanners
     
     KINDS_NOT_LOC = :all
     
-    def scan_tokens tokens, options
+  protected
+    
+    def scan_tokens encoder, options
       
       state = :initial
-      key_indent = 0
+      key_indent = string_indent = 0
       
       until eos?
         
-        kind = nil
-        match = nil
         key_indent = nil if bol?
         
         if match = scan(/ +[\t ]*/)
-          kind = :space
+          encoder.text_token match, :space
           
         elsif match = scan(/\n+/)
-          kind = :space
+          encoder.text_token match, :space
           state = :initial if match.index(?\n)
           
         elsif match = scan(/#.*/)
-          kind = :comment
+          encoder.text_token match, :comment
           
         elsif bol? and case
           when match = scan(/---|\.\.\./)
-            tokens << [:open, :head]
-            tokens << [match, :head]
-            tokens << [:close, :head]
+            encoder.begin_group :head
+            encoder.text_token match, :head
+            encoder.end_group :head
             next
           when match = scan(/%.*/)
-            tokens << [match, :doctype]
+            encoder.text_token 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]
+          when !check(/(?:"[^"]*")(?=: |:$)/) && match = scan(/"/)
+            encoder.begin_group :string
+            encoder.text_token match, :delimiter
+            encoder.text_token match, :content if match = scan(/ [^"\\]* (?: \\. [^"\\]* )* /mx)
+            encoder.text_token match, :delimiter if match = scan(/"/)
+            encoder.end_group :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]
+            encoder.begin_group :string
+            encoder.text_token match, :delimiter
+            string_indent = key_indent || column(pos - match.size) - 1
+            encoder.text_token matched, :content if scan(/(?:\n+ {#{string_indent + 1}}.*)+/)
+            encoder.end_group :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}}.*)+/)
+            encoder.begin_group :string
+            encoder.text_token match, :content
+            string_indent = key_indent || column(pos - match.size) - 1
+            encoder.text_token matched, :content if scan(/(?:\n+ {#{string_indent + 1}}.*)+/)
+            encoder.end_group :string
             next
           end
           
@@ -69,68 +71,67 @@ module Scanners
           when match = scan(/[-:](?= |$)/)
             state = :value if state == :colon && (match == ':' || match == '-')
             state = :value if state == :initial && match == '-'
-            kind = :operator
+            encoder.text_token match, :operator
+            next
           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]
+            encoder.text_token match, :operator
+            next
+          when state == :initial && match = scan(/[\w.() ]*\S(?= *:(?: |$))/)
+            encoder.text_token match, :key
+            key_indent = column(pos - match.size) - 1
             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]
+            next
+          when match = scan(/(?:"[^"\n]*"|'[^'\n]*')(?= *:(?: |$))/)
+            encoder.begin_group :key
+            encoder.text_token match[0,1], :delimiter
+            encoder.text_token match[1..-2], :content
+            encoder.text_token match[-1,1], :delimiter
+            encoder.end_group :key
+            key_indent = column(pos - match.size) - 1
             state = :colon
             next
-          when scan(/(![\w\/]+)(:([\w:]+))?/)
-            tokens << [self[1], :type]
+          when match = scan(/(![\w\/]+)(:([\w:]+))?/)
+            encoder.text_token self[1], :type
             if self[2]
-              tokens << [':', :operator]
-              tokens << [self[3], :class]
+              encoder.text_token ':', :operator
+              encoder.text_token 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
+          when match = scan(/&\S+/)
+            encoder.text_token match, :variable
+            next
+          when match = scan(/\*\w+/)
+            encoder.text_token match, :global_variable
+            next
+          when match = scan(/<</)
+            encoder.text_token match, :class_variable
+            next
+          when match = scan(/\d\d:\d\d:\d\d/)
+            encoder.text_token match, :octal
+            next
+          when match = scan(/\d\d\d\d-\d\d-\d\d\s\d\d:\d\d:\d\d(\.\d+)? [-+]\d\d:\d\d/)
+            encoder.text_token match, :octal
+            next
+          when match = scan(/:\w+/)
+            encoder.text_token match, :symbol
+            next
+          when match = scan(/[^:\s]+(:(?! |$)[^:\s]*)* .*/)
+            encoder.text_token match, :error
+            next
+          when match = scan(/[^:\s]+(:(?! |$)[^:\s]*)*/)
+            encoder.text_token match, :error
+            next
           end
           
         else
-          getch
-          kind = :error
+          raise if eos?
+          encoder.text_token getch, :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
+      encoder
     end
     
   end

data/lib/coderay/style.rb

@@ -1,20 +1,23 @@
 module CodeRay
 
   # This module holds the Style class and its subclasses.
-  #
+  # 
   # See Plugin.
   module Styles
     extend PluginHost
     plugin_path File.dirname(__FILE__), 'styles'
-
+    
+    # Base class for styles.
+    # 
+    # Styles are used by Encoders::HTML to colorize tokens.
     class Style
       extend Plugin
       plugin_host Styles
-
-      DEFAULT_OPTIONS = { }
-
+      
+      DEFAULT_OPTIONS = { }  # :nodoc:
+      
     end
-
+    
   end
-
+  
 end

data/lib/coderay/styles/_map.rb

@@ -1,7 +1,7 @@
 module CodeRay
 module Styles
-
-  default :cycnus
-
+  
+  default :alpha
+  
 end
 end

data/lib/coderay/styles/alpha.rb

@@ -0,0 +1,143 @@
+module CodeRay
+module Styles
+  
+  # A colorful theme using CSS 3 colors (with alpha channel).
+  class Alpha < Style
+
+    register_for :alpha
+
+    code_background = 'hsl(0,0%,95%)'
+    numbers_background = 'hsl(180,65%,90%)'
+    border_color = 'silver'
+    normal_color = 'black'
+
+    CSS_MAIN_STYLES = <<-MAIN  # :nodoc:
+.CodeRay {
+  background-color: #{code_background};
+  border: 1px solid #{border_color};
+  color: #{normal_color};
+}
+.CodeRay pre {
+  margin: 0px;
+}
+
+span.CodeRay { white-space: pre; border: 0px; padding: 2px; }
+
+table.CodeRay { border-collapse: collapse; width: 100%; padding: 2px; }
+table.CodeRay td { padding: 2px 4px; vertical-align: top; }
+
+.CodeRay .line-numbers {
+  background-color: #{numbers_background};
+  color: gray;
+  text-align: right;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  user-select: none;
+}
+.CodeRay .line-numbers a {
+  background-color: #{numbers_background} !important;
+  color: gray !important;
+  text-decoration: none !important;
+}
+.CodeRay .line-numbers a:target { color: blue !important; }
+.CodeRay .line-numbers .highlighted { color: red !important; }
+.CodeRay .line-numbers .highlighted a { color: red !important; }
+.CodeRay span.line-numbers { padding: 0px 4px; }
+.CodeRay .line { display: block; float: left; width: 100%; }
+.CodeRay .code { width: 100%; }
+.CodeRay .code pre { overflow: auto; }
+    MAIN
+
+    TOKEN_COLORS = <<-'TOKENS'
+.debug { color: white !important; background: blue !important; }
+
+.annotation { color:#007 }
+.attribute-name { color:#b48 }
+.attribute-value { color:#700 }
+.binary { color:#509 }
+.char .content { color:#D20 }
+.char .delimiter { color:#710 }
+.char { color:#D20 }
+.class { color:#B06; font-weight:bold }
+.class-variable { color:#369 }
+.color { color:#0A0 }
+.comment { color:#777 }
+.comment .char { color:#444 }
+.comment .delimiter { color:#444 }
+.complex { color:#A08 }
+.constant { color:#036; font-weight:bold }
+.decorator { color:#B0B }
+.definition { color:#099; font-weight:bold }
+.delimiter { color:black }
+.directive { color:#088; font-weight:bold }
+.doc { color:#970 }
+.doc-string { color:#D42; font-weight:bold }
+.doctype { color:#34b }
+.entity { color:#800; font-weight:bold }
+.error { color:#F00; background-color:#FAA }
+.escape  { color:#666 }
+.exception { color:#C00; font-weight:bold }
+.float { color:#60E }
+.function { color:#06B; font-weight:bold }
+.global-variable { color:#d70 }
+.hex { color:#02b }
+.imaginary { color:#f00 }
+.include { color:#B44; font-weight:bold }
+.inline { background-color: hsla(0,0%,0%,0.07); color: black }
+.inline-delimiter { font-weight: bold; color: #666 }
+.instance-variable { color:#33B }
+.integer  { color:#00D }
+.key .char { color: #60f }
+.key .delimiter { color: #404 }
+.key { color: #606 }
+.keyword { color:#080; font-weight:bold }
+.label { color:#970; font-weight:bold }
+.local-variable { color:#963 }
+.namespace { color:#707; font-weight:bold }
+.octal { color:#40E }
+.operator { }
+.predefined { color:#369; font-weight:bold }
+.predefined-constant { color:#069 }
+.predefined-type { color:#0a5; font-weight:bold }
+.preprocessor { color:#579 }
+.pseudo-class { color:#00C; font-weight:bold }
+.regexp .content { color:#808 }
+.regexp .delimiter { color:#404 }
+.regexp .modifier { color:#C2C }
+.regexp { background-color:hsla(300,100%,50%,0.06); }
+.reserved { color:#080; font-weight:bold }
+.shell .content { color:#2B2 }
+.shell .delimiter { color:#161 }
+.shell { background-color:hsla(120,100%,50%,0.06); }
+.string .char { color: #b0b }
+.string .content { color: #D20 }
+.string .delimiter { color: #710 }
+.string .modifier { color: #E40 }
+.string { background-color:hsla(0,100%,50%,0.05); }
+.symbol .content { color:#A60 }
+.symbol .delimiter { color:#630 }
+.symbol { color:#A60 }
+.tag { color:#070 }
+.type { color:#339; font-weight:bold }
+.value { color: #088; }
+.variable  { color:#037 }
+
+.insert { background: hsla(120,100%,50%,0.12) }
+.delete { background: hsla(0,100%,50%,0.12) }
+.change { color: #bbf; background: #007; }
+.head { color: #f8f; background: #505 }
+.head .filename { color: white; }
+
+.delete .eyecatcher { background-color: hsla(0,100%,50%,0.2); border: 1px solid hsla(0,100%,45%,0.5); margin: -1px; border-bottom: none; border-top-left-radius: 5px; border-top-right-radius: 5px; }
+.insert .eyecatcher { background-color: hsla(120,100%,50%,0.2); border: 1px solid hsla(120,100%,25%,0.5); margin: -1px; border-top: none; border-bottom-left-radius: 5px; border-bottom-right-radius: 5px; }
+
+.insert .insert { color: #0c0; background:transparent; font-weight:bold }
+.delete .delete { color: #c00; background:transparent; font-weight:bold }
+.change .change { color: #88f }
+.head .head { color: #f4f }
+    TOKENS
+
+  end
+
+end
+end

data/lib/coderay/token_kinds.rb

@@ -0,0 +1,90 @@
+module CodeRay
+  
+  # A Hash of all known token kinds and their associated CSS classes.
+  TokenKinds = Hash.new do |h, k|
+    warn 'Undefined Token kind: %p' % [k] if $CODERAY_DEBUG
+    false
+  end
+  
+  # speedup
+  TokenKinds.compare_by_identity if TokenKinds.respond_to? :compare_by_identity
+  
+  TokenKinds.update(  # :nodoc:
+    :annotation          => 'annotation',
+    :attribute_name      => 'attribute-name',
+    :attribute_value     => 'attribute-value',
+    :binary              => 'bin',
+    :char                => 'char',
+    :class               => 'class',
+    :class_variable      => 'class-variable',
+    :color               => 'color',
+    :comment             => 'comment',
+    :complex             => 'complex',
+    :constant            => 'constant',
+    :content             => 'content',
+    :debug               => 'debug',
+    :decorator           => 'decorator',
+    :definition          => 'definition',
+    :delimiter           => 'delimiter',
+    :directive           => 'directive',
+    :doc                 => 'doc',
+    :doctype             => 'doctype',
+    :doc_string          => 'doc-string',
+    :entity              => 'entity',
+    :error               => 'error',
+    :escape              => 'escape',
+    :exception           => 'exception',
+    :filename            => 'filename',
+    :float               => 'float',
+    :function            => 'function',
+    :global_variable     => 'global-variable',
+    :hex                 => 'hex',
+    :imaginary           => 'imaginary',
+    :important           => 'important',
+    :include             => 'include',
+    :inline              => 'inline',
+    :inline_delimiter    => 'inline-delimiter',
+    :instance_variable   => 'instance-variable',
+    :integer             => 'integer',
+    :key                 => 'key',
+    :keyword             => 'keyword',
+    :label               => 'label',
+    :local_variable      => 'local-variable',
+    :modifier            => 'modifier',
+    :namespace           => 'namespace',
+    :octal               => 'octal',
+    :predefined          => 'predefined',
+    :predefined_constant => 'predefined-constant',
+    :predefined_type     => 'predefined-type',
+    :preprocessor        => 'preprocessor',
+    :pseudo_class        => 'pseudo-class',
+    :regexp              => 'regexp',
+    :reserved            => 'reserved',
+    :shell               => 'shell',
+    :string              => 'string',
+    :symbol              => 'symbol',
+    :tag                 => 'tag',
+    :type                => 'type',
+    :value               => 'value',
+    :variable            => 'variable',
+    
+    :change              => 'change',
+    :delete              => 'delete',
+    :head                => 'head',
+    :insert              => 'insert',
+    
+    :eyecatcher          => 'eyecatcher',
+    
+    :ident               => false,
+    :operator            => false,
+    
+    :space               => false,
+    :plain               => false
+  )
+  
+  TokenKinds[:method]    = TokenKinds[:function]
+  TokenKinds[:escape]    = TokenKinds[:delimiter]
+  TokenKinds[:docstring] = TokenKinds[:comment]
+  
+  TokenKinds.freeze
+end