coderay-beta 0.9.1

data/lib/coderay/encoders/html/numerization.rb

@@ -0,0 +1,133 @@
+module CodeRay
+module Encoders
+
+  class HTML
+
+    module Output
+
+      def numerize *args
+        clone.numerize!(*args)
+      end
+
+=begin      NUMERIZABLE_WRAPPINGS = {
+        :table => [:div, :page, nil],
+        :inline => :all,
+        :list => [:div, :page, nil]
+      }
+      NUMERIZABLE_WRAPPINGS.default = :all
+=end
+      def numerize! mode = :table, options = {}
+        return self unless mode
+
+        options = DEFAULT_OPTIONS.merge options
+
+        start = options[:line_number_start]
+        unless start.is_a? Integer
+          raise ArgumentError, "Invalid value %p for :line_number_start; Integer expected." % start
+        end
+
+        #allowed_wrappings = NUMERIZABLE_WRAPPINGS[mode]
+        #unless allowed_wrappings == :all or allowed_wrappings.include? options[:wrap]
+        #  raise ArgumentError, "Can't numerize, :wrap must be in %p, but is %p" % [NUMERIZABLE_WRAPPINGS, options[:wrap]]
+        #end
+
+        bold_every = options[:bold_every]
+        highlight_lines = options[:highlight_lines]
+        bolding =
+          if bold_every == false && highlight_lines == nil
+            proc { |line| line.to_s }
+          elsif highlight_lines.is_a? Enumerable
+            highlight_lines = highlight_lines.to_set
+            proc do |line|
+              if highlight_lines.include? line
+                "<strong class=\"highlighted\">#{line}</strong>"  # highlighted line numbers in bold
+              else
+                line.to_s
+              end
+            end
+          elsif bold_every.is_a? Integer
+            raise ArgumentError, ":bolding can't be 0." if bold_every == 0
+            proc do |line|
+              if line % bold_every == 0
+                "<strong>#{line}</strong>"  # every bold_every-th number in bold
+              else
+                line.to_s
+              end
+            end
+          else
+            raise ArgumentError, 'Invalid value %p for :bolding; false or Integer expected.' % bold_every
+          end
+
+        case mode
+        when :inline
+          max_width = (start + line_count).to_s.size
+          line_number = start
+          gsub!(/^/) do
+            line_number_text = bolding.call line_number
+            indent = ' ' * (max_width - line_number.to_s.size)  # TODO: Optimize (10^x)
+            res = "<span class=\"no\">#{indent}#{line_number_text}</span> "
+            line_number += 1
+            res
+          end
+
+        when :table
+          # This is really ugly.
+          # Because even monospace fonts seem to have different heights when bold,
+          # I make the newline bold, both in the code and the line numbers.
+          # FIXME Still not working perfect for Mr. Internet Exploder
+          line_numbers = (start ... start + line_count).to_a.map(&bolding).join("\n")
+          line_numbers << "\n"  # also for Mr. MS Internet Exploder :-/
+          line_numbers.gsub!(/\n/) { "<tt>\n</tt>" }
+
+          line_numbers_table_tpl = TABLE.apply('LINE_NUMBERS', line_numbers)
+          gsub!(/<\/div>\n/) { '</div>' }
+          gsub!(/\n/) { "<tt>\n</tt>" }
+          wrap_in! line_numbers_table_tpl
+          @wrapped_in = :div
+
+        when :list
+          opened_tags = []
+          gsub!(/^.*$\n?/) do |line|
+            line.chomp!
+
+            open = opened_tags.join
+            line.scan(%r!<(/)?span[^>]*>?!) do |close,|
+              if close
+                opened_tags.pop
+              else
+                opened_tags << $&
+              end
+            end
+            close = '</span>' * opened_tags.size
+
+            "<li>#{open}#{line}#{close}</li>\n"
+          end
+          chomp!("\n")
+          wrap_in! LIST
+          @wrapped_in = :div
+
+        else
+          raise ArgumentError, 'Unknown value %p for mode: expected one of %p' %
+            [mode, [:table, :list, :inline]]
+        end
+
+        self
+      end
+
+      def line_count
+        line_count = count("\n")
+        position_of_last_newline = rindex(?\n)
+        if position_of_last_newline
+          after_last_newline = self[position_of_last_newline + 1 .. -1]
+          ends_with_newline = after_last_newline[/\A(?:<\/span>)*\z/]
+          line_count += 1 if not ends_with_newline
+        end
+        line_count
+      end
+
+    end
+
+  end
+
+end
+end

data/lib/coderay/encoders/html/output.rb

@@ -0,0 +1,206 @@
+module CodeRay
+module Encoders
+
+  class HTML
+
+    # This module is included in the output String from thew HTML Encoder.
+    #
+    # It provides methods like wrap, div, page etc.
+    #
+    # Remember to use #clone instead of #dup to keep the modules the object was
+    # extended with.
+    #
+    # TODO: more doc.
+    module Output
+
+      require 'coderay/encoders/html/numerization.rb'
+
+      attr_accessor :css
+
+      class << self
+
+        # This makes Output look like a class.
+        #
+        # Example:
+        #
+        #  a = Output.new '<span class="co">Code</span>'
+        #  a.wrap! :page
+        def new string, css = CSS.new, element = nil
+          output = string.clone.extend self
+          output.wrapped_in = element
+          output.css = css
+          output
+        end
+
+        # Raises an exception if an object that doesn't respond to to_str is extended by Output,
+        # to prevent users from misuse. Use Module#remove_method to disable.
+        def extended o
+          warn "The Output module is intended to extend instances of String, not #{o.class}." unless o.respond_to? :to_str
+        end
+
+        def make_stylesheet css, in_tag = false
+          sheet = css.stylesheet
+          sheet = <<-CSS if in_tag
+<style type="text/css">
+#{sheet}
+</style>
+          CSS
+          sheet
+        end
+
+        def page_template_for_css css
+          sheet = make_stylesheet css
+          PAGE.apply 'CSS', sheet
+        end
+
+        # Define a new wrapper. This is meta programming.
+        def wrapper *wrappers
+          wrappers.each do |wrapper|
+            define_method wrapper do |*args|
+              wrap wrapper, *args
+            end
+            define_method "#{wrapper}!".to_sym do |*args|
+              wrap! wrapper, *args
+            end
+          end
+        end
+
+      end
+
+      wrapper :div, :span, :page
+
+      def wrapped_in? element
+        wrapped_in == element
+      end
+
+      def wrapped_in
+        @wrapped_in ||= nil
+      end
+      attr_writer :wrapped_in
+
+      def wrap_in template
+        clone.wrap_in! template
+      end
+
+      def wrap_in! template
+        Template.wrap! self, template, 'CONTENT'
+        self
+      end
+      
+      def apply_title! title
+        self.sub!(/(<title>)(<\/title>)/) { $1 + title + $2 }
+        self
+      end
+
+      def wrap! element, *args
+        return self if not element or element == wrapped_in
+        case element
+        when :div
+          raise "Can't wrap %p in %p" % [wrapped_in, element] unless wrapped_in? nil
+          wrap_in! DIV
+        when :span
+          raise "Can't wrap %p in %p" % [wrapped_in, element] unless wrapped_in? nil
+          wrap_in! SPAN
+        when :page
+          wrap! :div if wrapped_in? nil
+          raise "Can't wrap %p in %p" % [wrapped_in, element] unless wrapped_in? :div
+          wrap_in! Output.page_template_for_css(@css)
+          if args.first.is_a?(Hash) && title = args.first[:title]
+            apply_title! title
+          end
+          self
+        when nil
+          return self
+        else
+          raise "Unknown value %p for :wrap" % element
+        end
+        @wrapped_in = element
+        self
+      end
+
+      def wrap *args
+        clone.wrap!(*args)
+      end
+
+      def stylesheet in_tag = false
+        Output.make_stylesheet @css, in_tag
+      end
+
+      class Template < String
+
+        def self.wrap! str, template, target
+          target = Regexp.new(Regexp.escape("<%#{target}%>"))
+          if template =~ target
+            str[0,0] = $`
+            str << $'
+          else
+            raise "Template target <%%%p%%> not found" % target
+          end
+        end
+
+        def apply target, replacement
+          target = Regexp.new(Regexp.escape("<%#{target}%>"))
+          if self =~ target
+            Template.new($` + replacement + $')
+          else
+            raise "Template target <%%%p%%> not found" % target
+          end
+        end
+
+        module Simple
+          def ` str  #` <-- for stupid editors
+            Template.new str
+          end
+        end
+      end
+
+      extend Template::Simple
+
+#-- don't include the templates in docu
+
+      SPAN = `<span class="CodeRay"><%CONTENT%></span>`
+
+      DIV = <<-`DIV`
+<div class="CodeRay">
+  <div class="code"><pre><%CONTENT%></pre></div>
+</div>
+      DIV
+
+      TABLE = <<-`TABLE`
+<table class="CodeRay"><tr>
+  <td class="line_numbers" title="click to toggle" onclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre><%LINE_NUMBERS%></pre></td>
+  <td class="code"><pre ondblclick="with (this.style) { overflow = (overflow == 'auto' || overflow == '') ? 'visible' : 'auto' }"><%CONTENT%></pre></td>
+</tr></table>
+      TABLE
+      # title="double click to expand"
+
+      LIST = <<-`LIST`
+<ol class="CodeRay">
+<%CONTENT%>
+</ol>
+      LIST
+
+      PAGE = <<-`PAGE`
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="de">
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <title></title>
+  <style type="text/css">
+<%CSS%>
+  </style>
+</head>
+<body style="background-color: white;">
+
+<%CONTENT%>
+</body>
+</html>
+      PAGE
+
+    end
+
+  end
+
+end
+end

data/lib/coderay/encoders/json.rb

@@ -0,0 +1,69 @@
+($:.unshift '../..'; require 'coderay') unless defined? CodeRay
+module CodeRay
+module Encoders
+  
+  # = JSON Encoder
+  class JSON < Encoder
+    
+    register_for :json
+    FILE_EXTENSION = 'json'
+    
+  protected
+    def setup options
+      begin
+        require 'json'
+      rescue LoadError
+        require 'rubygems'
+        require 'json'
+      end
+      @out = []
+    end
+    
+    def text_token text, kind
+      { :type => 'text', :text => text, :kind => kind }
+    end
+    
+    def block_token action, kind
+      { :type => 'block', :action => action, :kind => kind }
+    end
+    
+    def finish options
+      @out.to_json
+    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'
+$:.delete '.'
+require 'rubygems' if RUBY_VERSION < '1.9'
+
+class JSONEncoderTest < Test::Unit::TestCase
+  
+  def test_json_output
+    tokens = CodeRay.scan <<-RUBY, :ruby
+puts "Hello world!"
+    RUBY
+    require 'json'
+    assert_equal [
+      {"type"=>"text", "text"=>"puts", "kind"=>"ident"},
+      {"type"=>"text", "text"=>" ", "kind"=>"space"},
+      {"type"=>"block", "action"=>"open", "kind"=>"string"},
+      {"type"=>"text", "text"=>"\"", "kind"=>"delimiter"},
+      {"type"=>"text", "text"=>"Hello world!", "kind"=>"content"},
+      {"type"=>"text", "text"=>"\"", "kind"=>"delimiter"},
+      {"type"=>"block", "action"=>"close", "kind"=>"string"},
+      {"type"=>"text", "text"=>"\n", "kind"=>"space"}
+    ], JSON.load(tokens.json)
+  end
+  
+end

data/lib/coderay/encoders/lines_of_code.rb

@@ -0,0 +1,90 @@
+($:.unshift '../..'; require 'coderay') unless defined? CodeRay
+module CodeRay
+module Encoders
+  
+  # Counts the LoC (Lines of Code). Returns an Integer >= 0.
+  # 
+  # Alias: :loc
+  # 
+  # Everything that is not comment, markup, doctype/shebang, or an empty line,
+  # is considered to be code.
+  # 
+  # For example,
+  # * HTML files not containing JavaScript have 0 LoC
+  # * in a Java class without comments, LoC is the number of non-empty lines
+  # 
+  # 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
+    
+    register_for :lines_of_code
+    
+    NON_EMPTY_LINE = /^\s*\S.*$/
+    
+    def compile tokens, options
+      if scanner = tokens.scanner
+        kinds_not_loc = scanner.class::KINDS_NOT_LOC
+      else
+        warn ArgumentError, 'Tokens have no scanner.' if $DEBUG
+        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
+    end
+    
+    def finish options
+      @loc
+    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