ruby-filemagic 0.6.2-x86-mingw32

data/lib/filemagic/ext.rb

@@ -0,0 +1,99 @@
+require 'filemagic'
+
+module FileMagic::Ext
+
+  def self.included(base)
+    base.class_eval {
+      extend ClassMethods
+      include InstanceMethods
+    }
+  end
+
+  module ClassMethods
+
+    def file_type(file, *flags)
+      raise NotImplementedError, 'must be implemented by including class'
+    end
+
+    def file(file, *flags)
+      file_type(file, *flags)
+    end
+
+    def mime_type(file, *flags)
+      file_type(file, *flags.unshift(:mime))
+    end
+
+    alias_method :mime, :mime_type
+
+    def content_type(file, *flags)
+      mime_type(file, *flags << { simplified: true })
+    end
+
+  end
+
+  module InstanceMethods
+
+    def file_type(*flags)
+      self.class.file_type(self, *flags)
+    end
+
+    alias_method :file, :file_type
+
+    def mime_type(*flags)
+      self.class.mime_type(self, *flags)
+    end
+
+    alias_method :mime, :mime_type
+
+    def content_type(*flags)
+      self.class.content_type(self, *flags)
+    end
+
+  end
+
+end
+
+class File
+
+  include FileMagic::Ext
+
+  def self.file_type(file, *flags)
+    FileMagic.fm(*flags).file(file.respond_to?(:path) ? file.path : file)
+  rescue FileMagic::FileMagicError
+  end
+
+end
+
+class String
+
+  include FileMagic::Ext
+
+  def self.file_type(string, *flags)
+    FileMagic.fm(*flags).buffer(string)
+  rescue FileMagic::FileMagicError
+  end
+
+end
+
+if $0 == __FILE__
+  f = __FILE__
+  p f
+
+  p File.file_type(f)
+  p File.mime_type(f)
+  p File.content_type(f)
+
+  f = File.new(f)
+  p f
+
+  p f.file_type
+  p f.mime_type
+  p f.content_type
+
+  s = '#! /usr/bin/ruby'
+  p s
+
+  p s.file_type
+  p s.mime_type
+  p s.content_type
+end

data/lib/filemagic/version.rb

@@ -0,0 +1,27 @@
+class FileMagic
+
+  module Version
+
+    MAJOR = 0
+    MINOR = 6
+    TINY  = 2
+
+    class << self
+
+      # Returns array representation.
+      def to_a
+        [MAJOR, MINOR, TINY]
+      end
+
+      # Short-cut for version string.
+      def to_s
+        to_a.join('.')
+      end
+
+    end
+
+  end
+
+  VERSION = Version.to_s
+
+end

data/lib/filemagic.rb

@@ -0,0 +1,142 @@
+begin
+  require "filemagic/#{RUBY_VERSION[/\d+.\d+/]}/ruby_filemagic"
+rescue LoadError => err
+  raise if err.respond_to?(:path) && !err.path
+  require 'filemagic/ruby_filemagic'
+end
+
+require 'filemagic/version'
+
+class FileMagic
+
+  DEFAULT_MAGIC = __FILE__.sub(/\.rb\z/, '/magic.mgc')
+
+  ENV['MAGIC'] ||= DEFAULT_MAGIC unless path
+
+  # Map flag names to their values (:name => Integer).
+  FLAGS_BY_SYM = [
+    :none,               # No flags
+    :debug,              # Turn on debugging
+    :symlink,            # Follow symlinks
+    :compress,           # Check inside compressed files
+    :devices,            # Look at the contents of devices
+    :mime_type,          # Return only the MIME type
+    :continue,           # Return all matches
+    :check,              # Print warnings to stderr
+    :preserve_atime,     # Restore access time on exit
+    :raw,                # Don't translate unprint chars
+    :error,              # Handle ENOENT etc as real errors
+    :mime_encoding,      # Return only the MIME encoding
+    :mime,               # MAGIC_MIME_TYPE | MAGIC_MIME_ENCODING
+    :apple,              # Return the Apple creator and type
+    :no_check_compress,  # Don't check for compressed files
+    :no_check_tar,       # Don't check for tar files
+    :no_check_soft,      # Don't check magic entries
+    :no_check_apptype,   # Don't check application type
+    :no_check_elf,       # Don't check for elf details
+    :no_check_text,      # Don't check for text files
+    :no_check_cdf,       # Don't check for cdf files
+    :no_check_tokens,    # Don't check ascii/tokens
+    :no_check_encoding,  # Don't check text encodings
+    :no_check_builtin,   # No built-in tests; only consult the magic file
+
+    # Defined for backwards compatibility (renamed)
+    :no_check_ascii,     # MAGIC_NO_CHECK_TEXT
+
+    # Defined for backwards compatibility; do nothing
+    :no_check_fortran,   # Don't check ascii/fortran
+    :no_check_troff      # Don't check ascii/troff
+  ].inject({}) { |flags, flag|
+    const = "MAGIC_#{flag.to_s.upcase}"
+    flags.update(flag => const_defined?(const) && const_get(const))
+  }
+
+  # Map flag values to their names (Integer => :name).
+  FLAGS_BY_INT = FLAGS_BY_SYM.invert.update(0 => :none)
+
+  # Extract "simple" MIME type.
+  SIMPLE_RE = %r{([.\w\/-]+)}
+
+  @fm = {}
+
+  class << self
+
+    # Provide a "magic singleton".
+    def fm(*flags)
+      options = flags.last.is_a?(Hash) ? flags.pop : {}
+
+      if fm = @fm[key = [flags = flags(flags), options]]
+        return fm unless fm.closed?
+      end
+
+      @fm[key] = new(flags, options)
+    end
+
+    # Clear our instance cache.
+    def clear!
+      @fm.each_value(&:close).clear
+    end
+
+    # Just like #new, but takes an optional block, in which case #close
+    # is called at the end and the value of the block is returned.
+    def open(*flags)
+      fm = new(*flags)
+
+      if block_given?
+        begin
+          yield fm
+        ensure
+          fm.close
+        end
+      else
+        fm
+      end
+    end
+
+    # Just a short-cut to #open with the +mime+ flag set.
+    def mime(*flags, &block)
+      open(:mime, *flags, &block)
+    end
+
+    def magic_version(default = MAGIC_VERSION)
+      default != '0' ? default :
+        user_magic_version ||
+        auto_magic_version ||
+        [default, 'unknown']
+    end
+
+    private
+
+    def user_magic_version(key = 'MAGIC_VERSION')
+      [ENV[key], 'user-specified'] if ENV[key]
+    end
+
+    def auto_magic_version
+      require 'nuggets/file/which'
+
+      if cmd = File.which_command([
+        'dpkg-query -f \'${Version}\' -W libmagic-dev',
+        'file -v'
+      ])
+        [%x{#{cmd}}[/\d+\.\d+/], 'auto-detected']
+      end
+    rescue LoadError
+    end
+
+  end
+
+  attr_writer :simplified
+
+  def simplified?
+    @simplified
+  end
+
+  def io(io, length = 8)
+    buffer(io.read(length))
+  end
+
+  def inspect
+    super.insert(-2, closed? ? ' (closed)' : '')
+  end
+
+end

data/lib/ruby-filemagic.rb

@@ -0,0 +1 @@
+require 'filemagic'

data/test/filemagic_test.rb

@@ -0,0 +1,227 @@
+require 'test/unit'
+require 'filemagic'
+
+class TestFileMagic < Test::Unit::TestCase
+
+  magic_version, origin = FileMagic.magic_version
+  MAGIC_VERSION = magic_version.to_f
+
+  warn <<-EOT
+
+libmagic version: #{MAGIC_VERSION}#{" (#{origin})" if origin}
+magic file from #{FileMagic.path}
+
+  EOT
+
+  def test_file
+    fm = FileMagic.new(FileMagic::MAGIC_NONE)
+
+    python_script = match_version(
+      0    => 'a python script, ASCII text executable',
+      5.11 => 'Python script, ASCII text executable'
+    )
+
+    res = fm.file(path_to('pyfile'))
+    assert_equal(python_script, res)
+
+    if File.symlink?(path_to('pylink'))
+      res = fm.file(path_to('pylink'))
+      assert_equal("symbolic link to `pyfile'", res.strip)
+    end
+
+    fm.close
+    fm = FileMagic.new(FileMagic::MAGIC_SYMLINK)
+
+    res = fm.file(path_to('pylink'))
+    assert_equal(python_script, res)
+
+    fm.close
+    fm = FileMagic.new(FileMagic::MAGIC_SYMLINK | FileMagic::MAGIC_MIME)
+
+    res = fm.file(path_to('pylink'))
+    assert_equal('text/plain; charset=us-ascii', res)
+
+    fm.close
+    fm = FileMagic.new(FileMagic::MAGIC_COMPRESS)
+
+    res = fm.file(path_to('pyfile-compressed.gz'))
+    gzip_compressed = 'gzip compressed data, was "pyfile-compressed"'
+    assert_match(Gem.win_platform? ? /^#{gzip_compressed}/ :
+                 /^#{python_script} \(#{gzip_compressed}/, res)
+
+    fm.close
+  end
+
+  def test_buffer
+    fm = FileMagic.new(FileMagic::MAGIC_NONE)
+    res = fm.buffer("#!/bin/sh\n")
+    fm.close
+    assert_equal('POSIX shell script, ASCII text executable', res)
+  end
+
+  def test_check
+    return if Gem.win_platform?
+    fm = FileMagic.new(FileMagic::MAGIC_NONE)
+    res = silence_stderr { fm.check(path_to('perl')) }
+    fm.close
+    assert(res)
+  end
+
+  def test_check_compiled
+    return if MAGIC_VERSION <= 5.09
+    fm = FileMagic.new(FileMagic::MAGIC_NONE)
+    res = silence_stderr { fm.check(path_to('perl.mgc')) }
+    fm.close
+    assert(res)
+  end
+
+  def test_compile
+    assert(File.writable?('.'), "can't write to current directory")
+    fm = FileMagic.new(FileMagic::MAGIC_NONE)
+    res = fm.compile(path_to('perl'))
+    fm.close
+    assert(res)
+    File.unlink(path_to('perl.mgc', '.'))
+  end
+
+  def test_block
+    block_fm = nil
+    res = FileMagic.open(FileMagic::MAGIC_NONE) { |fm|
+      block_fm = fm
+      fm.file(path_to('pyfile'))
+    }
+    assert_equal(match_version(
+      0    => 'a python script, ASCII text executable',
+      5.11 => 'Python script, ASCII text executable'
+    ), res)
+    assert block_fm.closed?
+  end
+
+  def test_flags_to_int
+    assert_raise(TypeError) { FileMagic.flags(0) }
+    assert_equal(0, FileMagic.flags([FileMagic::MAGIC_NONE]))
+    assert_equal(0, FileMagic.flags([:none]))
+    assert_equal(0, FileMagic.flags([]))
+    assert_equal(1072, FileMagic.flags([:mime, :continue]))
+  end
+
+  def test_setflags
+    fm = FileMagic.new(FileMagic::MAGIC_NONE)
+    assert_equal([], fm.flags)
+    fm.flags = FileMagic::MAGIC_SYMLINK
+    assert_equal([:symlink], fm.flags)
+    fm.close
+  end
+
+  def test_abbr
+    fm = FileMagic.new(:mime, :continue)
+    assert_equal([:mime_type, :continue, :mime_encoding], fm.flags)
+    fm.flags = :symlink
+    assert_equal([:symlink], fm.flags)
+    fm.close
+  end
+
+  def test_close
+    fm = FileMagic.new
+    fm.close
+    assert fm.closed?
+    fm.close
+    assert fm.closed?
+  end
+
+  # tests adapted from mahoro:
+
+  def test_mahoro_file
+    fm = FileMagic.new
+    fm.flags = FileMagic::MAGIC_NONE
+    assert_equal(match_version(
+      0    => 'ASCII C program text',
+      5.11 => 'C source, ASCII text'
+    ), fm.file(path_to('mahoro.c')))
+  end
+
+  def test_mahoro_mime_file
+    fm = FileMagic.new
+    fm.flags = FileMagic::MAGIC_MIME
+    assert_equal('text/x-c; charset=us-ascii', fm.file(path_to('mahoro.c')))
+  end
+
+  def test_mahoro_buffer
+    fm = FileMagic.new
+    fm.flags = FileMagic::MAGIC_NONE
+    assert_equal(match_version(
+      0    => 'ASCII C program text',
+      5.11 => 'C source, ASCII text'
+    ), fm.buffer(File.read(path_to('mahoro.c'))))
+  end
+
+  def test_mahoro_mime_buffer
+    fm = FileMagic.new
+    fm.flags = FileMagic::MAGIC_MIME
+    assert_equal('text/x-c; charset=us-ascii', fm.buffer(File.read(path_to('mahoro.c'))))
+  end
+
+  def test_mahoro_valid
+    fm = FileMagic.new
+    assert(silence_stderr { fm.valid? }, 'Default database was not valid.')
+  end
+
+  # test abbreviating mime types
+
+  def test_abbrev_mime_type
+    fm = FileMagic.mime
+
+    refute fm.simplified?
+    assert_equal('text/plain; charset=us-ascii', fm.file(path_to('perl')))
+
+    fm.simplified = true
+    assert fm.simplified?
+    assert_equal('text/plain', fm.file(path_to('perl')))
+    assert_equal(match_version(
+      0    => 'application/vnd.ms-office',
+      5.11 => 'application/msword',
+      5.14 => 'application/vnd.ms-office'
+    ), fm.file(path_to('excel-example.xls')))
+  end
+
+  def test_singleton
+    fm1 = FileMagic.fm
+    assert_equal(fm1, FileMagic.fm)
+
+    refute fm1.simplified?
+    assert_equal('ASCII text', fm1.file(path_to('perl')))
+
+    fm2 = FileMagic.fm(:mime)
+    assert_equal(fm2, FileMagic.fm(:mime))
+    refute_equal(fm2, fm1)
+
+    refute fm2.simplified?
+    assert_equal('text/plain; charset=us-ascii', fm2.file(path_to('perl')))
+
+    fm3 = FileMagic.fm(:mime, simplified: true)
+    assert_equal(fm3, FileMagic.fm(:mime, simplified: true))
+    refute_equal(fm3, fm2)
+    refute_equal(fm3, fm1)
+
+    assert fm3.simplified?
+    assert_equal('text/plain', fm3.file(path_to('perl')))
+  end
+
+  # utility methods:
+
+  def path_to(file, dir = File.dirname(__FILE__))
+    File.join(dir, file)
+  end
+
+  def silence_stderr
+    require 'nuggets/io/redirect'
+    $stderr.redirect { yield }
+  rescue LoadError
+    yield
+  end
+
+  def match_version(versions)
+    versions.sort_by { |k,| -k }.find { |k,| k <= MAGIC_VERSION }.last
+  end
+
+end

data/test/leaktest.rb

@@ -0,0 +1,16 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'filemagic'
+
+warn "watch -n 1 'ps aux | grep [l]eaktest'"
+
+def do_file(filename)
+  fm = FileMagic.new(0)
+  file = fm.file(filename)
+  fm.close
+  return file
+end
+
+loop do
+  puts do_file($0)
+  sleep 1
+end

data/test/mahoro.c

@@ -0,0 +1,187 @@
+/*
+ * This file is Public Domain.
+ */
+
+#include <ruby.h>
+#include <magic.h>
+
+struct MagicCookie
+{
+	magic_t cookie;
+};
+
+static VALUE cMahoro;
+static VALUE eMahoroError;
+
+static void
+mahoro_free(ptr)
+	struct MagicCookie *ptr;
+{
+	magic_close(ptr->cookie);
+	free(ptr);
+}
+
+static VALUE
+mahoro_allocate(klass)
+	VALUE klass;
+{
+	return Data_Wrap_Struct(klass, 0, mahoro_free, 0);
+}
+
+static VALUE
+mahoro_initialize(argc, argv, self)
+	int argc;
+	VALUE *argv, self;
+{
+	int flags = MAGIC_NONE;
+	char *path = 0;
+	struct MagicCookie *ptr;
+	magic_t cookie;
+	VALUE vpath, vflags;
+
+	switch(rb_scan_args(argc, argv, "02", &vflags, &vpath)) {
+		case 2:
+			if(!NIL_P(vpath)) {
+				path = StringValuePtr(vpath);
+			}
+			/* fallthrough */
+		case 1:
+			flags = FIX2INT(vflags);
+			break;
+	}
+
+	if(!(cookie = magic_open(flags))) {
+		rb_raise(eMahoroError, "failed to initialize magic cookie");
+	}
+
+	if(magic_load(cookie, path)) {
+		rb_raise(eMahoroError, "failed to load database: %s",
+		                      magic_error(cookie));
+	}
+
+	ptr = ALLOC(struct MagicCookie);
+	ptr->cookie = cookie;
+	DATA_PTR(self) = ptr;
+
+	return self;
+}
+
+static VALUE
+mahoro_file(self, path)
+	VALUE self, path;
+{
+	const char *msg;
+	magic_t cookie = ((struct MagicCookie *) DATA_PTR(self))->cookie;
+
+	if(!(msg = magic_file(cookie, StringValuePtr(path)))) {
+		rb_raise(eMahoroError, "failed lookup: %s", magic_error(cookie));
+	}
+
+	return rb_str_new2(msg);
+}
+
+static VALUE
+mahoro_buffer(self, input)
+	VALUE self, input;
+{
+	const char *msg;
+	magic_t cookie = ((struct MagicCookie *) DATA_PTR(self))->cookie;
+
+	if(!(msg = magic_buffer(cookie, StringValuePtr(input),
+	                                RSTRING(StringValue(input))->len))) {
+		rb_raise(eMahoroError, "failed lookup: %s", magic_error(cookie));
+	}
+
+	return rb_str_new2(msg);
+}
+
+static VALUE
+mahoro_set_flags(self, flags)
+	VALUE self, flags;
+{
+	magic_t cookie = ((struct MagicCookie *) DATA_PTR(self))->cookie;
+
+	return INT2FIX(magic_setflags(cookie, FIX2INT(flags)));
+}
+
+static VALUE
+mahoro_check(argc, argv, self)
+	int argc;
+	VALUE *argv, self;
+{
+	char *path = 0;
+	VALUE vpath;
+	magic_t cookie = ((struct MagicCookie *) DATA_PTR(self))->cookie;
+
+	switch(rb_scan_args(argc, argv, "01", &vpath)) {
+		case 1:
+			if(!NIL_P(vpath)) { 
+				path = StringValuePtr(vpath);
+			}
+			break;
+	}
+
+	if(!magic_check(cookie, path)) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+static VALUE
+mahoro_compile(klass, path)
+	VALUE klass, path;
+{
+	magic_t cookie = magic_open(MAGIC_NONE);
+
+	if(magic_compile(cookie, StringValuePtr(path))) {
+		rb_raise(eMahoroError, "failed compile: %s", magic_error(cookie));
+	}
+
+	magic_close(cookie);
+
+	return Qtrue;
+}
+
+static VALUE
+mahoro_load(self, path)
+	VALUE self, path;
+{
+	magic_t cookie = ((struct MagicCookie *) DATA_PTR(self))->cookie;
+
+	if(magic_load(cookie, StringValuePtr(path))) {
+		rb_raise(eMahoroError, "failed load: %s", magic_error(cookie));
+	}
+
+	return self;
+}
+
+void Init_mahoro(void)
+{
+	cMahoro      = rb_define_class("Mahoro", rb_cObject);
+	eMahoroError = rb_define_class_under(cMahoro, "Error", rb_eStandardError);
+
+	rb_const_set(cMahoro, rb_intern("NONE"), INT2FIX(MAGIC_NONE));
+	rb_const_set(cMahoro, rb_intern("DEBUG"), INT2FIX(MAGIC_DEBUG));
+	rb_const_set(cMahoro, rb_intern("SYMLINK"), INT2FIX(MAGIC_SYMLINK));
+	rb_const_set(cMahoro, rb_intern("COMPRESS"), INT2FIX(MAGIC_COMPRESS));
+	rb_const_set(cMahoro, rb_intern("DEVICES"), INT2FIX(MAGIC_DEVICES));
+	rb_const_set(cMahoro, rb_intern("MIME"), INT2FIX(MAGIC_MIME));
+	rb_const_set(cMahoro, rb_intern("CONTINUE"), INT2FIX(MAGIC_CONTINUE));
+	rb_const_set(cMahoro, rb_intern("CHECK"), INT2FIX(MAGIC_CHECK));
+	rb_const_set(cMahoro, rb_intern("PRESERVE_ATIME"),
+	                      INT2FIX(MAGIC_PRESERVE_ATIME));
+	rb_const_set(cMahoro, rb_intern("RAW"), INT2FIX(MAGIC_RAW));
+	rb_const_set(cMahoro, rb_intern("ERROR"), INT2FIX(MAGIC_ERROR));
+
+	rb_define_alloc_func(cMahoro, mahoro_allocate);
+	rb_define_method(cMahoro, "initialize", mahoro_initialize, -1);
+	rb_define_method(cMahoro, "file", mahoro_file, 1);
+	rb_define_method(cMahoro, "buffer", mahoro_buffer, 1);
+	rb_define_method(cMahoro, "flags=", mahoro_set_flags, 1);
+	rb_define_method(cMahoro, "valid?", mahoro_check, -1);
+	rb_define_singleton_method(cMahoro, "compile", mahoro_compile, 1);
+	rb_define_method(cMahoro, "load", mahoro_load, 1);
+}
+
+/* arch-tag: mahoro */