SoundSoftware Code Site

#!/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.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

    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 = {

    'c' => :c,

    'css' => :css,

    'diff' => :diff,

    'dpr' => :delphi,

    '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' => :debug,

    'rb' => :ruby,

    'rbw' => :ruby,

    'rhtml' => :rhtml,

    '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 = {

    '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

    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