typo 5.1.3 → 5.1.98

data/vendor/gems/coderay-0.8.260/lib/coderay/encoders/statistic.rb

@@ -0,0 +1,77 @@
+module CodeRay
+module Encoders
+
+  # Makes a statistic for the given tokens.
+  class Statistic < Encoder
+
+    include Streamable
+    register_for :stats, :statistic
+
+    attr_reader :type_stats, :real_token_count
+
+  protected
+
+    TypeStats = Struct.new :count, :size
+
+    def setup options
+      @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
+
+Code Statistics
+
+Tokens            %8d
+  Non-Whitespace  %8d
+Bytes Total       %8d
+
+Token Types (%d):
+  type                     count     ratio    size (average)
+-------------------------------------------------------------
+%s
+      STATS
+# space                    12007   33.81 %     1.7
+    TOKEN_TYPES_ROW = <<-TKR
+  %-20s  %8d  %6.2f %%   %5.1f
+      TKR
+
+    def finish options
+      all = @type_stats['TOTAL']
+      all_count, all_size = all.count, all.size
+      @type_stats.each do |type, stat|
+        stat.size /= stat.count.to_f
+      end
+      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 % [
+        all_count, @real_token_count, all_size,
+        @type_stats.delete_if { |k, v| k.is_a? String }.size,
+        types_stats
+      ]
+    end
+
+  end
+
+end
+end

data/vendor/gems/coderay-0.8.260/lib/coderay/encoders/text.rb

@@ -0,0 +1,32 @@
+module CodeRay
+module Encoders
+
+  class Text < Encoder
+
+    include Streamable
+    register_for :text
+
+    FILE_EXTENSION = 'txt'
+
+    DEFAULT_OPTIONS = {
+      :separator => ''
+    }
+
+  protected
+    def setup options
+      @out = ''
+      @sep = options[:separator]
+    end
+
+    def token text, kind
+      @out << text + @sep if text.is_a? ::String
+    end
+
+    def finish options
+      @out.chomp @sep
+    end
+
+  end
+
+end
+end

data/vendor/gems/coderay-0.8.260/lib/coderay/encoders/tokens.rb

@@ -0,0 +1,44 @@
+module CodeRay
+module Encoders
+
+  # The Tokens encoder converts the tokens to a simple
+  # readable format. It doesn't use colors and is mainly
+  # intended for console output.
+  #
+  # The tokens are converted with Tokens.write_token.
+  #
+  # The format is:
+  #
+  #   <token-kind> \t <escaped token-text> \n
+  #
+  # Example:
+  #
+  #   require 'coderay'
+  #   puts CodeRay.scan("puts 3 + 4", :ruby).tokens
+  #
+  # prints:
+  #
+  #   ident   puts
+  #   space
+  #   integer 3
+  #   space
+  #   operator        +
+  #   space
+  #   integer 4
+  #
+  class Tokens < Encoder
+
+    include Streamable
+    register_for :tokens
+
+    FILE_EXTENSION = 'tok'
+
+  protected
+    def token text, kind
+      @out << CodeRay::Tokens.write_token(text, kind)
+    end
+
+  end
+
+end
+end

data/vendor/gems/coderay-0.8.260/lib/coderay/encoders/xml.rb

@@ -0,0 +1,70 @@
+module CodeRay
+module Encoders
+
+  # = XML Encoder
+  #
+  # Uses REXML. Very slow.
+  class XML < Encoder
+
+    include Streamable
+    register_for :xml
+
+    FILE_EXTENSION = 'xml'
+
+    require 'rexml/document'
+
+    DEFAULT_OPTIONS = {
+      :tab_width => 8,
+      :pretty => -1,
+      :transitive => false,
+    }
+
+  protected
+
+    def setup options
+      @doc = REXML::Document.new
+      @doc << REXML::XMLDecl.new
+      @tab_width = options[:tab_width]
+      @root = @node = @doc.add_element('coderay-tokens')
+    end
+
+    def finish options
+      @doc.write @out, options[:pretty], options[:transitive], true
+      @out
+    end
+    
+    def text_token text, kind
+      if kind == :space
+        token = @node
+      else
+        token = @node.add_element kind.to_s
+      end
+      text.scan(/(\x20+)|(\t+)|(\n)|[^\x20\t\n]+/) do |space, tab, nl|
+        case
+        when space
+          token << REXML::Text.new(space, true)
+        when tab
+          token << REXML::Text.new(tab, true)
+        when nl
+          token << REXML::Text.new(nl, true)
+        else
+          token << REXML::Text.new($&)
+        end
+      end
+    end
+
+    def open_token kind
+      @node = @node.add_element kind.to_s
+    end
+
+    def close_token kind
+      if @node == @root
+        raise 'no token to close!'
+      end
+      @node = @node.parent
+    end
+
+  end
+
+end
+end

data/vendor/gems/coderay-0.8.260/lib/coderay/encoders/yaml.rb

@@ -0,0 +1,22 @@
+module CodeRay
+module Encoders
+
+  # = YAML Encoder
+  #
+  # Slow.
+  class YAML < Encoder
+
+    register_for :yaml
+
+    FILE_EXTENSION = 'yaml'
+
+  protected
+    def compile tokens, options
+      require 'yaml'
+      @out = tokens.to_a.to_yaml
+    end
+
+  end
+
+end
+end

data/vendor/gems/coderay-0.8.260/lib/coderay/for_redcloth.rb

@@ -0,0 +1,72 @@
+module CodeRay  # :nodoc:
+  
+  # A little hack to enable CodeRay highlighting in RedCloth.
+  # 
+  # Usage:
+  #  require 'coderay'
+  #  require 'coderay/for_redcloth'
+  #  RedCloth.new('@[ruby]puts "Hello, World!"@').to_html
+  # 
+  # Make sure you have RedCloth 4.0.3 activated, for example by calling
+  #  require 'rubygems'
+  # before RedCloth is loaded and before calling CodeRay.for_redcloth.
+  module ForRedCloth
+    
+    def self.install
+      gem 'RedCloth', '>= 4.0.3' rescue nil
+      require 'redcloth'
+      raise 'CodeRay.for_redcloth needs RedCloth 4.0.3 or later.' unless RedCloth::VERSION.to_s >= '4.0.3'
+      RedCloth::TextileDoc.send :include, ForRedCloth::TextileDoc
+      RedCloth::Formatters::HTML.module_eval do
+        def unescape(html)
+          replacements = {
+            '&' => '&',
+            '"' => '"',
+            '>' => '>',
+            '&lt;' => '<',
+          }
+          html.gsub(/&(?:amp|quot|[gl]t);/) { |entity| replacements[entity] }
+        end
+        undef_method :code, :bc_open, :bc_close, :escape_pre
+        def code(opts)  # :nodoc:
+          opts[:block] = true
+          if opts[:lang] && !filter_coderay
+            require 'coderay'
+            @in_bc ||= nil
+            format = @in_bc ? :div : :span
+            highlighted_code = CodeRay.encode opts[:text], opts[:lang], format, :stream => true
+            highlighted_code.sub!(/\A<(span|div)/) { |m| m + pba(@in_bc || opts) }
+            highlighted_code = unescape(highlighted_code) unless @in_bc
+            highlighted_code
+          else
+            "<code#{pba(opts)}>#{opts[:text]}</code>"
+          end
+        end
+        def bc_open(opts)  # :nodoc:
+          opts[:block] = true
+          @in_bc = opts
+          opts[:lang] ? '' : "<pre#{pba(opts)}>"
+        end
+        def bc_close(opts)  # :nodoc:
+          @in_bc = nil
+          opts[:lang] ? '' : "</pre>\n"
+        end
+        def escape_pre(text)
+          if @in_bc ||= nil
+            text
+          else
+            html_esc(text, :html_escape_preformatted)
+          end
+        end
+      end
+    end
+
+    module TextileDoc  # :nodoc:
+      attr_accessor :filter_coderay
+    end
+    
+  end
+  
+end
+
+CodeRay::ForRedCloth.install

data/vendor/gems/coderay-0.8.260/lib/coderay/helpers/file_type.rb

@@ -0,0 +1,211 @@
+#!/usr/bin/env ruby
+module CodeRay
+
+# = FileType
+#
+# A simple filetype recognizer.
+#
+# Copyright (c) 2006 by murphy (Kornelius Kalnbach) <murphy rubychan de>
+#
+# License:: LGPL / ask the author
+# Version:: 0.1 (2005-09-01)
+#
+# == Documentation
+#
+#  # determine the type of the given
+#   lang = FileType[ARGV.first]
+#  
+#   # return :plaintext if the file type is unknown
+#   lang = FileType.fetch ARGV.first, :plaintext
+#  
+#   # try the shebang line, too
+#   lang = FileType.fetch ARGV.first, :plaintext, true
+module FileType
+
+  UnknownFileType = Class.new Exception
+
+  class << self
+
+    # Try to determine the file type of the file.
+    #
+    # +filename+ is a relative or absolute path to a file.
+    #
+    # The file itself is only accessed when +read_shebang+ is set to true.
+    # That means you can get filetypes from files that don't exist.
+    def [] filename, read_shebang = false
+      name = File.basename filename
+      ext = File.extname(name).sub(/^\./, '')  # from last dot, delete the leading dot
+      ext2 = filename[/\.(.*)/, 1]  # from first dot
+
+      type =
+        TypeFromExt[ext.downcase] ||
+        (TypeFromExt[ext2.downcase] if ext2) ||
+        TypeFromName[name] ||
+        TypeFromName[name.downcase]
+      type ||= shebang(filename) if read_shebang
+
+      type
+    end
+
+    def shebang filename
+      begin
+        File.open filename, 'r' do |f|
+          if first_line = f.gets
+            if type = first_line[TypeFromShebang]
+              type.to_sym
+            end
+          end
+        end
+      rescue IOError
+        nil
+      end
+    end
+
+    # This works like Hash#fetch.
+    #
+    # If the filetype cannot be found, the +default+ value
+    # is returned.
+    def fetch filename, default = nil, read_shebang = false
+      if default and block_given?
+        warn 'block supersedes default value argument'
+      end
+
+      unless type = self[filename, read_shebang]
+        return yield if block_given?
+        return default if default
+        raise UnknownFileType, 'Could not determine type of %p.' % filename
+      end
+      type
+    end
+
+  end
+
+  TypeFromExt = {
+    'rb' => :ruby,
+    'rbw' => :ruby,
+    'rake' => :ruby,
+    'mab' => :ruby,
+    'cpp' => :c,
+    'c' => :c,
+    'h' => :c,
+    'js' => :java_script,
+    'xml' => :xml,
+    'htm' => :html,
+    'html' => :html,
+    'xhtml' => :xhtml,
+    'raydebug' => :debug,
+    'rhtml' => :rhtml,
+    'html.erb' => :rhtml,
+    'ss' => :scheme,
+    'sch' => :scheme,
+    'yaml' => :yaml,
+    'yml' => :yaml,
+  }
+
+  TypeFromShebang = /\b(?:ruby|perl|python|sh)\b/
+
+  TypeFromName = {
+    'Rakefile' => :ruby,
+    'Rantfile' => :ruby,
+  }
+
+end
+
+end
+
+if $0 == __FILE__
+  $VERBOSE = true
+  eval DATA.read, nil, $0, __LINE__ + 4
+end
+
+__END__
+require 'test/unit'
+
+class TC_FileType < Test::Unit::TestCase
+  
+  include CodeRay
+  
+  def test_fetch
+    assert_raise FileType::UnknownFileType do
+      FileType.fetch ''
+    end
+
+    assert_throws :not_found do
+      FileType.fetch '.' do
+        throw :not_found
+      end
+    end
+
+    assert_equal :default, FileType.fetch('c', :default)
+
+    stderr, fake_stderr = $stderr, Object.new
+    $err = ''
+    def fake_stderr.write x
+      $err << x
+    end
+    $stderr = fake_stderr
+    FileType.fetch('c', :default) { }
+    assert_equal "block supersedes default value argument\n", $err
+    $stderr = stderr
+  end
+
+  def test_ruby
+    assert_equal :ruby, FileType['test.rb']
+    assert_equal :ruby, FileType['C:\\Program Files\\x\\y\\c\\test.rbw']
+    assert_equal :ruby, FileType['/usr/bin/something/Rakefile']
+    assert_equal :ruby, FileType['~/myapp/gem/Rantfile']
+    assert_equal :ruby, FileType['./lib/tasks\repository.rake']
+    assert_not_equal :ruby, FileType['test_rb']
+    assert_not_equal :ruby, FileType['Makefile']
+    assert_not_equal :ruby, FileType['set.rb/set']
+    assert_not_equal :ruby, FileType['~/projects/blabla/rb']
+  end
+
+  def test_c
+    assert_equal :c, FileType['test.c']
+    assert_equal :c, FileType['C:\\Program Files\\x\\y\\c\\test.h']
+    assert_not_equal :c, FileType['test_c']
+    assert_not_equal :c, FileType['Makefile']
+    assert_not_equal :c, FileType['set.h/set']
+    assert_not_equal :c, FileType['~/projects/blabla/c']
+  end
+
+  def test_html
+    assert_equal :html, FileType['test.htm']
+    assert_equal :xhtml, FileType['test.xhtml']
+    assert_equal :xhtml, FileType['test.html.xhtml']
+    assert_equal :rhtml, FileType['_form.rhtml']
+    assert_equal :rhtml, FileType['_form.html.erb']
+  end
+
+  def test_yaml
+    assert_equal :yaml, FileType['test.yml']
+    assert_equal :yaml, FileType['test.yaml']
+    assert_equal :yaml, FileType['my.html.yaml']
+    assert_not_equal :yaml, FileType['YAML']
+  end
+
+  def test_no_shebang
+    dir = './test'
+    if File.directory? dir
+      Dir.chdir dir do
+        assert_equal :c, FileType['test.c']
+      end
+    end
+  end
+  
+  def test_shebang_empty_file
+    require 'tmpdir'
+    tmpfile = File.join(Dir.tmpdir, 'bla')
+    File.open(tmpfile, 'w') { }  # touch
+    assert_equal nil, FileType[tmpfile]
+  end
+  
+  def test_shebang
+    require 'tmpdir'
+    tmpfile = File.join(Dir.tmpdir, 'bla')
+    File.open(tmpfile, 'w') { |f| f.puts '#!/usr/bin/env ruby' }
+    assert_equal :ruby, FileType[tmpfile, true]
+  end
+
+end

data/vendor/gems/coderay-0.8.260/lib/coderay/helpers/gzip_simple.rb

@@ -0,0 +1,123 @@
+# =GZip Simple
+#
+# A simplified interface to the gzip library +zlib+ (from the Ruby Standard Library.)
+#
+# Author: murphy (mail to murphy cYcnus de)
+#
+# Version: 0.2 (2005.may.28)
+#
+# ==Documentation
+#
+# See +GZip+ module and the +String+ extensions.
+#
+module GZip
+
+  require 'zlib'
+
+  # The default zipping level. 7 zips good and fast.
+  DEFAULT_GZIP_LEVEL = 7
+
+  # Unzips the given string +s+.
+  #
+  # Example:
+  #   require 'gzip_simple'
+  #   print GZip.gunzip(File.read('adresses.gz'))
+  def GZip.gunzip s
+    Zlib::Inflate.inflate s
+  end
+
+  # Zips the given string +s+.
+  #
+  # Example:
+  #   require 'gzip_simple'
+  #   File.open('adresses.gz', 'w') do |file
+  #     file.write GZip.gzip('Mum: 0123 456 789', 9)
+  #   end
+  #
+  # If you provide a +level+, you can control how strong
+  # the string is compressed:
+  # - 0: no compression, only convert to gzip format
+  # - 1: compress fast
+  # - 7: compress more, but still fast (default)
+  # - 8: compress more, slower
+  # - 9: compress best, very slow
+  def GZip.gzip s, level = DEFAULT_GZIP_LEVEL
+    Zlib::Deflate.new(level).deflate s, Zlib::FINISH
+  end
+end
+
+
+# String extensions to use the GZip module.
+#
+# The methods gzip and gunzip provide an even more simple
+# interface to the ZLib:
+#
+#   # create a big string
+#   x = 'a' * 1000
+#   
+#   # zip it
+#   x_gz = x.gzip
+#   
+#   # test the result
+#   puts 'Zipped %d bytes to %d bytes.' % [x.size, x_gz.size]
+#   #-> Zipped 1000 bytes to 19 bytes.
+#   
+#   # unzipping works
+#   p x_gz.gunzip == x  #-> true
+class String
+  # Returns the string, unzipped.
+  # See GZip.gunzip
+  def gunzip
+    GZip.gunzip self
+  end
+  # Replaces the string with its unzipped value.
+  # See GZip.gunzip
+  def gunzip!
+    replace gunzip
+  end
+
+  # Returns the string, zipped.
+  # +level+ is the gzip compression level, see GZip.gzip.
+  def gzip level = GZip::DEFAULT_GZIP_LEVEL
+    GZip.gzip self, level
+  end
+  # Replaces the string with its zipped value.
+  # See GZip.gzip.
+  def gzip!(*args)
+    replace gzip(*args)
+  end
+end
+
+if $0 == __FILE__
+  eval DATA.read, nil, $0, __LINE__+4
+end
+
+__END__
+#CODE
+
+# Testing / Benchmark
+x = 'a' * 1000
+x_gz = x.gzip
+puts 'Zipped %d bytes to %d bytes.' % [x.size, x_gz.size]  #-> Zipped 1000 bytes to 19 bytes.
+p x_gz.gunzip == x  #-> true
+
+require 'benchmark'
+
+INFO = 'packed to %0.3f%%'  # :nodoc:
+
+x = Array.new(100000) { rand(255).chr + 'aaaaaaaaa' + rand(255).chr }.join
+Benchmark.bm(10) do |bm|
+  for level in 0..9
+    bm.report "zip #{level}" do
+      $x = x.gzip level
+    end
+    puts INFO % [100.0 * $x.size / x.size]
+  end
+  bm.report 'zip' do
+    $x = x.gzip
+  end
+  puts INFO % [100.0 * $x.size / x.size]
+  bm.report 'unzip' do
+    $x.gunzip
+  end
+end