coderay 1.0.0.598.pre → 1.0.0.738.pre

data/lib/coderay/encoders/terminal.rb

@@ -93,11 +93,10 @@ module CodeRay
       TOKEN_COLORS[:method] = TOKEN_COLORS[:function]
       TOKEN_COLORS[:imaginary] = TOKEN_COLORS[:complex]
       TOKEN_COLORS[:begin_group] = TOKEN_COLORS[:end_group] =
-        TOKEN_COLORS[:nesting_delimiter] = TOKEN_COLORS[:escape] =
-        TOKEN_COLORS[:delimiter]
-
+        TOKEN_COLORS[:escape] = TOKEN_COLORS[:delimiter]
+      
     protected
-
+      
       def setup(options)
         super
         @opened = []

data/lib/coderay/encoders/text.rb

@@ -1,4 +1,3 @@
-($:.unshift '../..'; require 'coderay') unless defined? CodeRay
 module CodeRay
 module Encoders
   
@@ -24,7 +23,7 @@ module Encoders
     }
 
     def text_token text, kind
-      @out << text
+      super
       @out << @sep if @sep
     end
 
@@ -42,24 +41,3 @@ module Encoders
 
 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 CountTest < Test::Unit::TestCase
-  
-  def test_count
-    ruby = <<-RUBY
-puts "Hello world!"
-    RUBY
-    tokens = CodeRay.scan ruby, :ruby
-    assert_equal ruby, tokens.encode_with(:text)
-  end
-  
-end

data/lib/coderay/encoders/token_kind_filter.rb

@@ -1,4 +1,3 @@
-($:.unshift '../..'; require 'coderay') unless defined? CodeRay
 module CodeRay
 module Encoders
   
@@ -109,60 +108,3 @@ module Encoders
   
 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 TokenKindFilterTest < Test::Unit::TestCase
-  
-  def test_creation
-    assert CodeRay::Encoders::TokenKindFilter < CodeRay::Encoders::Encoder
-    assert CodeRay::Encoders::TokenKindFilter < CodeRay::Encoders::Filter
-    filter = nil
-    assert_nothing_raised do
-      filter = CodeRay.encoder :token_kind_filter
-    end
-    assert_instance_of CodeRay::Encoders::TokenKindFilter, filter
-  end
-  
-  def test_filtering_text_tokens
-    tokens = CodeRay::Tokens.new
-    for i in 1..10
-      tokens.text_token i.to_s, :index
-      tokens.text_token ' ', :space if i < 10
-    end
-    assert_equal 10, CodeRay::Encoders::TokenKindFilter.new.encode_tokens(tokens, :exclude => :space).count
-    assert_equal 10, tokens.token_kind_filter(:exclude => :space).count
-    assert_equal 9, CodeRay::Encoders::TokenKindFilter.new.encode_tokens(tokens, :include => :space).count
-    assert_equal 9, tokens.token_kind_filter(:include => :space).count
-    assert_equal 0, CodeRay::Encoders::TokenKindFilter.new.encode_tokens(tokens, :exclude => :all).count
-    assert_equal 0, tokens.token_kind_filter(:exclude => :all).count
-  end
-  
-  def test_filtering_block_tokens
-    tokens = CodeRay::Tokens.new
-    10.times do |i|
-      tokens.begin_group :index
-      tokens.text_token i.to_s, :content
-      tokens.end_group :index
-      tokens.begin_group :naught if i == 5
-      tokens.end_group :naught if i == 7
-      tokens.begin_line :blubb
-      tokens.text_token i.to_s, :content
-      tokens.end_line :blubb
-    end
-    assert_equal 16, CodeRay::Encoders::TokenKindFilter.new.encode_tokens(tokens, :include => :blubb).count
-    assert_equal 16, tokens.token_kind_filter(:include => :blubb).count
-    assert_equal 24, CodeRay::Encoders::TokenKindFilter.new.encode_tokens(tokens, :include => [:blubb, :content]).count
-    assert_equal 24, tokens.token_kind_filter(:include => [:blubb, :content]).count
-    assert_equal 32, CodeRay::Encoders::TokenKindFilter.new.encode_tokens(tokens, :exclude => :index).count
-    assert_equal 32, tokens.token_kind_filter(:exclude => :index).count
-  end
-  
-end

data/lib/coderay/helpers/file_type.rb

@@ -1,70 +1,70 @@
-#!/usr/bin/env ruby
 module CodeRay
-
-# = FileType
-#
-# A simple filetype recognizer.
-#
-# == Usage
-#
-#  # 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.to_s[/\.(.*)/, 1]  # from first dot
-
-      type =
-        TypeFromExt[ext] ||
-        TypeFromExt[ext.downcase] ||
-        (TypeFromExt[ext2] if ext2) ||
-        (TypeFromExt[ext2.downcase] if ext2) ||
-        TypeFromName[name] ||
-        TypeFromName[name.downcase]
-      type ||= shebang(filename) if read_shebang
-
-      type
-    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
+  
+  # = FileType
+  #
+  # A simple filetype recognizer.
+  #
+  # == Usage
+  #
+  #  # 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
     
-  protected
+    UnknownFileType = Class.new Exception
     
-    def shebang filename
-      begin
+    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.to_s[/\.(.*)/, 1]  # from first dot
+        
+        type =
+          TypeFromExt[ext] ||
+          TypeFromExt[ext.downcase] ||
+          (TypeFromExt[ext2] if ext2) ||
+          (TypeFromExt[ext2.downcase] if ext2) ||
+          TypeFromName[name] ||
+          TypeFromName[name.downcase]
+        type ||= shebang(filename) if read_shebang
+        
+        type
+      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 && block_given?
+          warn 'Block supersedes default value argument; use either.'
+        end
+        
+        if type = self[filename, read_shebang]
+          type
+        else
+          return yield if block_given?
+          return default if default
+          raise UnknownFileType, 'Could not determine type of %p.' % filename
+        end
+      end
+      
+    protected
+      
+      def shebang filename
+        return unless File.exist? filename
         File.open filename, 'r' do |f|
           if first_line = f.gets
             if type = first_line[TypeFromShebang]
@@ -72,185 +72,64 @@ module FileType
             end
           end
         end
-      rescue IOError
-        nil
       end
+      
     end
-
-  end
-
-  TypeFromExt = {
-    'c' => :c,
-    'css' => :css,
-    'diff' => :diff,
-    'dpr' => :delphi,
-    'gemspec' => :ruby,
-    'groovy' => :groovy,
-    'gvy' => :groovy,
-    'h' => :c,
-    'htm' => :html,
-    'html' => :html,
-    'html.erb' => :rhtml,
-    'java' => :java,
-    'js' => :java_script,
-    'json' => :json,
-    'mab' => :ruby,
-    'pas' => :delphi,
-    'patch' => :diff,
-    'php' => :php,
-    'php3' => :php,
-    'php4' => :php,
-    'php5' => :php,
-    'py' => :python,
-    'py3' => :python,
-    'pyw' => :python,
-    'rake' => :ruby,
-    'raydebug' => :raydebug,
-    'rb' => :ruby,
-    'rbw' => :ruby,
-    'rhtml' => :rhtml,
-    'rjs' => :ruby,
-    'rpdf' => :ruby,
-    'rxml' => :ruby,
-    'sch' => :scheme,
-    'sql' => :sql,
-    'ss' => :scheme,
-    'xhtml' => :xhtml,
-    'xml' => :xml,
-    'yaml' => :yaml,
-    'yml' => :yaml,
-  }
-  for cpp_alias in %w[cc cpp cp cxx c++ C hh hpp h++ cu]
-    TypeFromExt[cpp_alias] = :cpp
-  end
-
-  TypeFromShebang = /\b(?:ruby|perl|python|sh)\b/
-
-  TypeFromName = {
-    'Capfile' => :ruby,
-    'Rakefile' => :ruby,
-    'Rantfile' => :ruby,
-  }
-
-end
-
-end
-
-if $0 == __FILE__
-  $VERBOSE = true
-  eval DATA.read, nil, $0, __LINE__ + 4
-end
-
-__END__
-require 'test/unit'
-
-class FileTypeTests < 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['test.java.rb']
-    assert_equal :java, FileType['test.rb.java']
-    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_cpp
-    assert_equal :cpp, FileType['test.c++']
-    assert_equal :cpp, FileType['test.cxx']
-    assert_equal :cpp, FileType['test.hh']
-    assert_equal :cpp, FileType['test.hpp']
-    assert_equal :cpp, FileType['test.cu']
-    assert_equal :cpp, FileType['test.C']
-    assert_not_equal :cpp, FileType['test.c']
-    assert_not_equal :cpp, FileType['test.h']
-  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_pathname
-    require 'pathname'
-    pn = Pathname.new 'test.rb'
-    assert_equal :ruby, FileType[pn]
-    dir = Pathname.new '/etc/var/blubb'
-    assert_equal :ruby, FileType[dir + pn]
-    assert_equal :cpp, FileType[dir + 'test.cpp']
-  end
-
-  def test_no_shebang
-    dir = './test'
-    if File.directory? dir
-      Dir.chdir dir do
-        assert_equal :c, FileType['test.c']
-      end
+    
+    TypeFromExt = {
+      'c' => :c,
+      'clj' => :clojure,
+      'css' => :css,
+      'diff' => :diff,
+      'dpr' => :delphi,
+      'gemspec' => :ruby,
+      'groovy' => :groovy,
+      'gvy' => :groovy,
+      'h' => :c,
+      'htm' => :html,
+      'html' => :html,
+      'html.erb' => :rhtml,
+      'java' => :java,
+      'js' => :java_script,
+      'json' => :json,
+      'mab' => :ruby,
+      'pas' => :delphi,
+      'patch' => :diff,
+      'php' => :php,
+      'php3' => :php,
+      'php4' => :php,
+      'php5' => :php,
+      'py' => :python,
+      'py3' => :python,
+      'pyw' => :python,
+      'rake' => :ruby,
+      'raydebug' => :raydebug,
+      'rb' => :ruby,
+      'rbw' => :ruby,
+      'rhtml' => :rhtml,
+      'rjs' => :ruby,
+      'rpdf' => :ruby,
+      'rxml' => :ruby,
+      'sch' => :scheme,
+      'sql' => :sql,
+      'ss' => :scheme,
+      'xhtml' => :xhtml,
+      'xml' => :xml,
+      'yaml' => :yaml,
+      'yml' => :yaml,
+    }
+    for cpp_alias in %w[cc cpp cp cxx c++ C hh hpp h++ cu]
+      TypeFromExt[cpp_alias] = :cpp
     end
+    
+    TypeFromShebang = /\b(?:ruby|perl|python|sh)\b/
+    
+    TypeFromName = {
+      'Capfile' => :ruby,
+      'Rakefile' => :ruby,
+      'Rantfile' => :ruby,
+    }
+    
   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