typo 5.3 → 5.4

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

@@ -1,77 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,211 +0,0 @@
-#!/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