coderay 1.0.0 → 1.0.0.598.pre

data/lib/coderay/encoders/xml.rb

@@ -1,40 +1,38 @@
 module CodeRay
 module Encoders
-  
+
   # = XML Encoder
   #
   # Uses REXML. Very slow.
   class XML < Encoder
-    
+
     register_for :xml
-    
+
     FILE_EXTENSION = 'xml'
-    
-    autoload :REXML, 'rexml/document'
-    
+
+    require 'rexml/document'
+
     DEFAULT_OPTIONS = {
       :tab_width => 8,
       :pretty => -1,
       :transitive => false,
     }
-    
+
   protected
+
     def setup options
-      super
-      
       @doc = REXML::Document.new
       @doc << REXML::XMLDecl.new
       @tab_width = options[:tab_width]
       @root = @node = @doc.add_element('coderay-tokens')
     end
-    
+
     def finish options
+      @out = ''
       @doc.write @out, options[:pretty], options[:transitive], true
-      
-      super
+      @out
     end
     
-  public
     def text_token text, kind
       if kind == :space
         token = @node

data/lib/coderay/encoders/yaml.rb

@@ -1,50 +1,48 @@
-autoload :YAML, 'yaml'
-
 module CodeRay
 module Encoders
-  
+
   # = YAML Encoder
   #
   # Slow.
   class YAML < Encoder
-    
+
     register_for :yaml
-    
+
     FILE_EXTENSION = 'yaml'
-    
+
   protected
     def setup options
-      super
-      
-      @data = []
+      require 'yaml'
+      @out = []
     end
     
     def finish options
-      output ::YAML.dump(@data)
+      @out.to_a.to_yaml
     end
     
   public
+    
     def text_token text, kind
-      @data << [text, kind]
+      @out << [text, kind]
     end
     
     def begin_group kind
-      @data << [:begin_group, kind]
+      @out << [:begin_group, kind]
     end
     
     def end_group kind
-      @data << [:end_group, kind]
+      @out << [:end_group, kind]
     end
     
     def begin_line kind
-      @data << [:begin_line, kind]
+      @out << [:begin_line, kind]
     end
     
     def end_line kind
-      @data << [:end_line, kind]
+      @out << [:end_line, kind]
     end
     
   end
-  
+
 end
 end

data/lib/coderay/for_redcloth.rb

@@ -45,7 +45,7 @@ module CodeRay
           if !opts[:lang] && RedCloth::VERSION.to_s >= '4.2.0'
             # simulating pre-4.2 behavior
             if opts[:text].sub!(/\A\[(\w+)\]/, '')
-              if CodeRay::Scanners[$1].lang == :text
+              if CodeRay::Scanners[$1].plugin_id == :plaintext
                 opts[:text] = $& + opts[:text]
               else
                 opts[:lang] = $1

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[file_name]
-  #  
-  #  # return :text if the file type is unknown
-  #  lang = FileType.fetch file_name, :text
-  #  
-  #  # try the shebang line, too
-  #  lang = FileType.fetch file_name, :text, 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
+
+# = 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
-      
-      # 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
+
+      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
-      
-    protected
-      
-      def shebang filename
-        return unless File.exist? filename
+      type
+    end
+    
+  protected
+    
+    def shebang filename
+      begin
         File.open filename, 'r' do |f|
           if first_line = f.gets
             if type = first_line[TypeFromShebang]
@@ -72,70 +72,185 @@ module CodeRay
             end
           end
         end
+      rescue IOError
+        nil
       end
-      
     end
-    
-    TypeFromExt = {
-      'c'        => :c,
-      'cfc'      => :xml,
-      'cfm'      => :xml,
-      'clj'      => :clojure,
-      'css'      => :css,
-      'diff'     => :diff,
-      'dpr'      => :delphi,
-      'gemspec'  => :ruby,
-      'groovy'   => :groovy,
-      'gvy'      => :groovy,
-      'h'        => :c,
-      'haml'     => :haml,
-      'htm'      => :page,
-      'html'     => :page,
-      'html.erb' => :erb,
-      'java'     => :java,
-      'js'       => :java_script,
-      'json'     => :json,
-      'mab'      => :ruby,
-      'pas'      => :delphi,
-      'patch'    => :diff,
-      'php'      => :php,
-      'php3'     => :php,
-      'php4'     => :php,
-      'php5'     => :php,
-      'prawn'    => :ruby,
-      'py'       => :python,
-      'py3'      => :python,
-      'pyw'      => :python,
-      'rake'     => :ruby,
-      'raydebug' => :raydebug,
-      'rb'       => :ruby,
-      'rbw'      => :ruby,
-      'rhtml'    => :erb,
-      'rjs'      => :ruby,
-      'rpdf'     => :ruby,
-      'ru'       => :ruby,
-      'rxml'     => :ruby,
-      # 'sch'      => :scheme,
-      'sql'      => :sql,
-      # 'ss'       => :scheme,
-      'xhtml'    => :page,
-      '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
+
+  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
-    
-    TypeFromShebang = /\b(?:ruby|perl|python|sh)\b/
-    
-    TypeFromName = {
-      'Capfile'  => :ruby,
-      'Rakefile' => :ruby,
-      'Rantfile' => :ruby,
-      'Gemfile'  => :ruby,
-    }
-    
+
+    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
+    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