coderay 0.9.8 → 1.0.0

data/lib/coderay/encoders/lines_of_code.rb

@@ -1,10 +1,9 @@
-($:.unshift '../..'; require 'coderay') unless defined? CodeRay
 module CodeRay
 module Encoders
   
   # Counts the LoC (Lines of Code). Returns an Integer >= 0.
   # 
-  # Alias: :loc
+  # Alias: +loc+
   # 
   # Everything that is not comment, markup, doctype/shebang, or an empty line,
   # is considered to be code.
@@ -15,76 +14,32 @@ module Encoders
   # 
   # A Scanner class should define the token kinds that are not code in the
   # KINDS_NOT_LOC constant, which defaults to [:comment, :doctype].
-  class LinesOfCode < Encoder
+  class LinesOfCode < TokenKindFilter
     
     register_for :lines_of_code
     
     NON_EMPTY_LINE = /^\s*\S.*$/
     
-    def compile tokens, options
-      if scanner = tokens.scanner
+  protected
+    
+    def setup options
+      if scanner
         kinds_not_loc = scanner.class::KINDS_NOT_LOC
       else
-        warn ArgumentError, 'Tokens have no scanner.' if $VERBOSE
+        warn "Tokens have no associated scanner, counting all nonempty lines." if $VERBOSE
         kinds_not_loc = CodeRay::Scanners::Scanner::KINDS_NOT_LOC
       end
-      code = tokens.token_class_filter :exclude => kinds_not_loc
-      @loc = code.text.scan(NON_EMPTY_LINE).size
+      
+      options[:exclude] = kinds_not_loc
+      
+      super options
     end
     
     def finish options
-      @loc
+      output @tokens.text.scan(NON_EMPTY_LINE).size
     end
     
   end
   
 end
 end
-
-if $0 == __FILE__
-  $VERBOSE = true
-  $: << File.join(File.dirname(__FILE__), '..')
-  eval DATA.read, nil, $0, __LINE__ + 4
-end
-
-__END__
-require 'test/unit'
-
-class LinesOfCodeTest < Test::Unit::TestCase
-  
-  def test_creation
-    assert CodeRay::Encoders::LinesOfCode < CodeRay::Encoders::Encoder
-    filter = nil
-    assert_nothing_raised do
-      filter = CodeRay.encoder :loc
-    end
-    assert_kind_of CodeRay::Encoders::LinesOfCode, filter
-    assert_nothing_raised do
-      filter = CodeRay.encoder :lines_of_code
-    end
-    assert_kind_of CodeRay::Encoders::LinesOfCode, filter
-  end
-  
-  def test_lines_of_code
-    tokens = CodeRay.scan <<-RUBY, :ruby
-#!/usr/bin/env ruby
-
-# a minimal Ruby program
-puts "Hello world!"
-    RUBY
-    assert_equal 1, CodeRay::Encoders::LinesOfCode.new.encode_tokens(tokens)
-    assert_equal 1, tokens.lines_of_code
-    assert_equal 1, tokens.loc
-  end
-  
-  def test_filtering_block_tokens
-    tokens = CodeRay::Tokens.new
-    tokens << ["Hello\n", :world]
-    tokens << ["Hello\n", :space]
-    tokens << ["Hello\n", :comment]
-    assert_equal 2, CodeRay::Encoders::LinesOfCode.new.encode_tokens(tokens)
-    assert_equal 2, tokens.lines_of_code
-    assert_equal 2, tokens.loc
-  end
-  
-end

data/lib/coderay/encoders/null.rb

@@ -1,26 +1,18 @@
 module CodeRay
 module Encoders
-
+  
   # = Null Encoder
   #
   # Does nothing and returns an empty string.
   class Null < Encoder
-
-    include Streamable
+    
     register_for :null
-
-    # Defined for faster processing
-    def to_proc
-      proc {}
-    end
-
-  protected
-
-    def token(*)
+    
+    def text_token text, kind
       # do nothing
     end
-
+    
   end
-
+  
 end
 end

data/lib/coderay/encoders/page.rb

@@ -1,20 +1,24 @@
 module CodeRay
 module Encoders
-
+  
   load :html
-
+  
+  # Wraps the output into a HTML page, using CSS classes and
+  # line numbers in the table format by default.
+  # 
+  # See Encoders::HTML for available options.
   class Page < HTML
-
+    
     FILE_EXTENSION = 'html'
-
+    
     register_for :page
-
+    
     DEFAULT_OPTIONS = HTML::DEFAULT_OPTIONS.merge \
-      :css => :class,
-      :wrap => :page,
+      :css          => :class,
+      :wrap         => :page,
       :line_numbers => :table
-
+    
   end
-
+  
 end
 end

data/lib/coderay/encoders/span.rb

@@ -1,19 +1,23 @@
 module CodeRay
 module Encoders
-
+  
   load :html
-
+  
+  # Wraps HTML output into a SPAN element, using inline styles by default.
+  # 
+  # See Encoders::HTML for available options.
   class Span < HTML
-
+    
     FILE_EXTENSION = 'span.html'
-
+    
     register_for :span
-
+    
     DEFAULT_OPTIONS = HTML::DEFAULT_OPTIONS.merge \
-      :css => :style,
-      :wrap => :span
-
+      :css          => :style,
+      :wrap         => :span,
+      :line_numbers => false
+    
   end
-
+  
 end
 end

data/lib/coderay/encoders/statistic.rb

@@ -1,43 +1,27 @@
 module CodeRay
 module Encoders
-
+  
   # Makes a statistic for the given tokens.
+  # 
+  # Alias: +stats+
   class Statistic < Encoder
-
-    include Streamable
-    register_for :stats, :statistic
-
-    attr_reader :type_stats, :real_token_count
-
+    
+    register_for :statistic
+    
+    attr_reader :type_stats, :real_token_count  # :nodoc:
+    
+    TypeStats = Struct.new :count, :size  # :nodoc:
+    
   protected
-
-    TypeStats = Struct.new :count, :size
-
+    
     def setup options
+      super
+      
       @type_stats = Hash.new { |h, k| h[k] = TypeStats.new 0, 0 }
       @real_token_count = 0
     end
-
-    def generate tokens, options
-      @tokens = tokens
-      super
-    end
-
-    def text_token text, kind
-      @real_token_count += 1 unless kind == :space
-      @type_stats[kind].count += 1
-      @type_stats[kind].size += text.size
-      @type_stats['TOTAL'].size += text.size
-      @type_stats['TOTAL'].count += 1
-    end
-
-    # TODO Hierarchy handling
-    def block_token action, kind
-      @type_stats['TOTAL'].count += 1
-      @type_stats['open/close'].count += 1
-    end
-
-    STATS = <<-STATS
+    
+    STATS = <<-STATS  # :nodoc:
 
 Code Statistics
 
@@ -49,12 +33,12 @@ Token Types (%d):
   type                     count     ratio    size (average)
 -------------------------------------------------------------
 %s
-      STATS
-# space                    12007   33.81 %     1.7
-    TOKEN_TYPES_ROW = <<-TKR
+    STATS
+    
+    TOKEN_TYPES_ROW = <<-TKR  # :nodoc:
   %-20s  %8d  %6.2f %%   %5.1f
-      TKR
-
+    TKR
+    
     def finish options
       all = @type_stats['TOTAL']
       all_count, all_size = all.count, all.size
@@ -64,14 +48,49 @@ Token Types (%d):
       types_stats = @type_stats.sort_by { |k, v| [-v.count, k.to_s] }.map do |k, v|
         TOKEN_TYPES_ROW % [k, v.count, 100.0 * v.count / all_count, v.size]
       end.join
-      STATS % [
+      @out << STATS % [
         all_count, @real_token_count, all_size,
         @type_stats.delete_if { |k, v| k.is_a? String }.size,
         types_stats
       ]
+      
+      super
     end
-
+    
+  public
+    
+    def text_token text, kind
+      @real_token_count += 1 unless kind == :space
+      @type_stats[kind].count += 1
+      @type_stats[kind].size += text.size
+      @type_stats['TOTAL'].size += text.size
+      @type_stats['TOTAL'].count += 1
+    end
+    
+    # TODO Hierarchy handling
+    def begin_group kind
+      block_token ':begin_group', kind
+    end
+    
+    def end_group kind
+      block_token ':end_group', kind
+    end
+    
+    def begin_line kind
+      block_token ':begin_line', kind
+    end
+    
+    def end_line kind
+      block_token ':end_line', kind
+    end
+    
+    def block_token action, kind
+      @type_stats['TOTAL'].count += 1
+      @type_stats[action].count += 1
+      @type_stats[kind].count += 1
+    end
+    
   end
-
+  
 end
 end

data/lib/coderay/encoders/terminal.rb

@@ -0,0 +1,179 @@
+module CodeRay
+  module Encoders
+    
+    # Outputs code highlighted for a color terminal.
+    # 
+    # Note: This encoder is in beta. It currently doesn't use the Styles.
+    # 
+    # Alias: +term+
+    # 
+    # == Authors & License
+    # 
+    # By Rob Aldred (http://robaldred.co.uk)
+    # 
+    # Based on idea by Nathan Weizenbaum (http://nex-3.com)
+    # 
+    # MIT License (http://www.opensource.org/licenses/mit-license.php)
+    class Terminal < Encoder
+      
+      register_for :terminal
+      
+      TOKEN_COLORS = {
+        :annotation => '35',
+        :attribute_name => '33',
+        :attribute_value => '31',
+        :binary => '1;35',
+        :char => {
+          :self => '36', :delimiter => '34'
+        },
+        :class => '1;35',
+        :class_variable => '36',
+        :color => '32',
+        :comment => '37',
+        :complex => '34',
+        :constant => ['34', '4'],
+        :decoration => '35',
+        :definition => '1;32',
+        :directive => ['32', '4'],
+        :doc => '46',
+        :doctype => '1;30',
+        :doc_string => ['31', '4'],
+        :entity => '33',
+        :error => ['1;33', '41'],
+        :exception => '1;31',
+        :float => '1;35',
+        :function => '1;34',
+        :global_variable => '42',
+        :hex => '1;36',
+        :include => '33',
+        :integer => '1;34',
+        :key => '35',
+        :label => '1;15',
+        :local_variable => '33',
+        :octal => '1;35',
+        :operator_name => '1;29',
+        :predefined_constant => '1;36',
+        :predefined_type => '1;30',
+        :predefined => ['4', '1;34'],
+        :preprocessor => '36',
+        :pseudo_class => '34',
+        :regexp => {
+          :self => '31',
+          :content => '31',
+          :delimiter => '1;29',
+          :modifier => '35',
+          :function => '1;29'
+        },
+        :reserved => '1;31',
+        :shell => {
+          :self => '42',
+          :content => '1;29',
+          :delimiter => '37',
+        },
+        :string => {
+          :self => '32',
+          :modifier => '1;32',
+          :escape => '1;36',
+          :delimiter => '1;32',
+        },
+        :symbol => '1;32',
+        :tag => '34',
+        :type => '1;34',
+        :value => '36',
+        :variable => '34',
+        
+        :insert => '42',
+        :delete => '41',
+        :change => '44',
+        :head => '45'
+      }
+      TOKEN_COLORS[:keyword] = TOKEN_COLORS[:reserved]
+      TOKEN_COLORS[:method] = TOKEN_COLORS[:function]
+      TOKEN_COLORS[:imaginary] = TOKEN_COLORS[:complex]
+      TOKEN_COLORS[:begin_group] = TOKEN_COLORS[:end_group] =
+        TOKEN_COLORS[:escape] = TOKEN_COLORS[:delimiter]
+      
+    protected
+      
+      def setup(options)
+        super
+        @opened = []
+        @subcolors = nil
+      end
+      
+    public
+      
+      def text_token text, kind
+        if color = (@subcolors || TOKEN_COLORS)[kind]
+          if Hash === color
+            if color[:self]
+              color = color[:self]
+            else
+              @out << text
+              return
+            end
+          end
+          
+          @out << ansi_colorize(color)
+          @out << text.gsub("\n", ansi_clear + "\n" + ansi_colorize(color))
+          @out << ansi_clear
+          @out << ansi_colorize(@subcolors[:self]) if @subcolors && @subcolors[:self]
+        else
+          @out << text
+        end
+      end
+      
+      def begin_group kind
+        @opened << kind
+        @out << open_token(kind)
+      end
+      alias begin_line begin_group
+      
+      def end_group kind
+        if @opened.empty?
+          # nothing to close
+        else
+          @opened.pop
+          @out << ansi_clear
+          @out << open_token(@opened.last)
+        end
+      end
+      
+      def end_line kind
+        if @opened.empty?
+          # nothing to close
+        else
+          @opened.pop
+          # whole lines to be highlighted,
+          # eg. added/modified/deleted lines in a diff
+          @out << "\t" * 100 + ansi_clear
+          @out << open_token(@opened.last)
+        end
+      end
+      
+    private
+      
+      def open_token kind
+        if color = TOKEN_COLORS[kind]
+          if Hash === color
+            @subcolors = color
+            ansi_colorize(color[:self]) if color[:self]
+          else
+            @subcolors = {}
+            ansi_colorize(color)
+          end
+        else
+          @subcolors = nil
+          ''
+        end
+      end
+      
+      def ansi_colorize(color)
+        Array(color).map { |c| "\e[#{c}m" }.join
+      end
+      def ansi_clear
+        ansi_colorize(0)
+      end
+    end
+  end
+end