ruby-filemagic 0.2.1

data/CHANGELOG

@@ -0,0 +1,28 @@
+--------------------------------------------------------------------------------
+7/28/2003 version 0.1.0
+
+o Initial release.
+
+--------------------------------------------------------------------------------
+7/30/2003 version 0.1.1
+
+o Added manual close method
+o Added unit test suite
+
+--------------------------------------------------------------------------------
+9/12/2008 version 0.2.0
+
+o Modified C API
+  o Uniform C function prefix rb_magic_ (instead of magick_)
+  o Uniform Ruby method prefix fm_ (instead of none)
+  o More magic(4) constants (if available)
+o Added Ruby wrapper for more rubyish interface
+o Added extensions for File and String core classes
+o Added/updated project files
+o Now available as a Rubygem!
+
+--------------------------------------------------------------------------------
+9/18/2008 version 0.2.1
+
+o Added mahoro source file and tests for reference and inspiration
+o We have a Rubyforge project now! :-)

data/README

@@ -0,0 +1,69 @@
+= FileMagic Library Binding
+
+== VERSION
+
+This documentation refers to filemagic version 0.2.1
+
+
+== DESCRIPTION
+
+=== Revised version
+
+September 12, 2008 Jens Wille <jens.wille@uni-koeln.de>
+
+Similar to Ricardo[http://github.com/ricardochimal/ruby-filemagic]
+I wanted this project to make some progress. My needs went a bit
+farther than his, though ;-) Enjoy anyway!
+
+Install the gem from github[http://github.com]:
+
+  sudo gem install blackwinter-ruby-filemagic --source http://gems.github.com
+
+=== Original package
+
+July 28, 2003 Travis Whitton <tinymountain@gmail.com>
+
+This is one of my first ruby bindings, so suggestions are welcome. See
+filemagic.rd and test.rb for usage.
+
+to install, run these commands:
+
+  ruby extconf.rb
+  make
+  su
+  make install
+
+the file(1) library and headers are required.
+I have file 0.4.3.
+
+Enjoy!
+Travis
+
+
+== LINKS
+
+* <http://grub.ath.cx/filemagic/>
+* <http://github.com/blackwinter/ruby-filemagic>
+* <http://ruby-filemagic.rubyforge.org/>
+* <http://rubyforge.org/projects/ruby-filemagic>
+
+
+== AUTHORS
+
+* Travis Whitton <mailto:tinymountain@gmail.com> (Original author)
+* Jens Wille <mailto:jens.wille@uni-koeln.de>
+
+
+== COPYING
+
+The filemagic extension library is copywrited free software by Travis Whitton
+<tinymountain@gmail.com>. You can redistribute it under the terms specified in
+the COPYING file of the Ruby distribution.
+
+
+== WARRANTY
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.

data/Rakefile

@@ -0,0 +1,26 @@
+require %q{lib/filemagic/version}
+
+begin
+  require 'hen'
+
+  Hen.lay! {{
+    :rubyforge => {
+      :package  => 'ruby-filemagic',
+      :project  => 'ruby-filemagic',
+      :rdoc_dir => nil
+    },
+
+    :gem => {
+      :version          => FileMagic::VERSION,
+      :summary          => 'Ruby bindings to the magic(4) library',
+      :authors          => ['Travis Whitton', 'Jens Wille'],
+      :email            => ['tinymountain@gmail.com', 'jens.wille@uni-koeln.de'],
+      :homepage         => 'http://ruby-filemagic.rubyforge.org/',
+      :files            => FileList['lib/**/*.rb', 'ext/**/*.c', 'test/*'].to_a,
+      :extensions       => FileList['ext/**/extconf.rb'].to_a,
+      :extra_files      => FileList['[A-Z]*', 'info/*'].to_a
+    }
+  }}
+rescue LoadError
+  abort "Please install the 'hen' gem first."
+end

data/TODO

@@ -0,0 +1,9 @@
+o Find a better way to handle magic_load than just defaulting to NULL
+o Find a way to make magic_check work on NULL
+o [DONE] Find a way to make magic_setflags work
+o Refactor code into initialize instead of new
+o [DONE?] Enable blocks for automatic cleanup:
+
+FileMagic.open("somefile.txt") do |file|
+  # close is called at the end of this block
+end

data/ext/extconf.rb

@@ -0,0 +1,8 @@
+require 'mkmf'
+
+dir_config("magic")
+if have_library("magic", "magic_open") and have_header("magic.h")
+  create_makefile("filemagic")
+else
+  print "***  ERROR: missing required library to compile this module\n"
+end

data/ext/filemagic.c

@@ -0,0 +1,213 @@
+/*********************************************************
+
+ filemagic.c
+
+ a Ruby extension to bind Ruby to the libmagic library
+ (ftp://ftp.astron.com/pub/file/)
+
+ patterned very closely off of audiofile.c by jaredj which
+ is patterned very very closely off of gdbm.c by matz ;-)
+
+ $Author: twhitton $
+ $Date: 2003/07/30 13:25:10 $
+
+*********************************************************/
+
+#include "ruby.h"
+#include <magic.h>
+
+static VALUE cFileMagic, rb_FileMagicError;
+
+#define GetMagicCookie(obj, cookie) {\
+  if (rb_funcall(obj, rb_intern("closed?"), 0))\
+    rb_raise(rb_eRuntimeError, "closed stream");\
+  Data_Get_Struct(obj, struct magic_set, cookie);\
+}
+
+/* 
+ GC never seems to happen until the program terminates, but this is called
+ on any unclosed objects
+*/
+static void rb_magic_free(magic_t cookie) {
+  magic_close(cookie);
+}
+
+static VALUE rb_magic_init(VALUE self, VALUE flags) {
+}
+
+/* Frees resources allocated */
+static VALUE rb_magic_close(VALUE self) {
+  magic_t cookie;
+
+  GetMagicCookie(self, cookie);
+  magic_close(cookie);
+
+  /* This keeps rb_magic_free from trying to free closed objects */
+  RDATA(self)->data = NULL;
+
+  return Qnil;
+}
+
+/* FileMagic.new */
+static VALUE rb_magic_new(VALUE class, VALUE flags) {
+  VALUE obj;
+  magic_t cookie;
+
+  cookie = magic_open(NUM2INT(flags));
+  if (cookie == NULL)
+    rb_fatal("out of memory");
+  if (magic_load(cookie, NULL) == -1)
+    rb_fatal("%s", magic_error(cookie));
+
+  obj = Data_Wrap_Struct(class, 0, rb_magic_free, cookie);
+  rb_obj_call_init(obj, 1, &flags);
+
+  return obj;
+}
+
+/* Return a string describing file */
+static VALUE rb_magic_file(VALUE self, VALUE file) {
+  const char *m;
+  magic_t cookie;
+
+  m = STR2CSTR(file);
+  GetMagicCookie(self, cookie);
+  if ((m = magic_file(cookie, m)) == NULL)
+    rb_raise(rb_FileMagicError, magic_error(cookie));
+
+  return rb_str_new2(m);
+}
+
+/* Return a string describing the string buffer */
+static VALUE rb_magic_buffer(VALUE self, VALUE buffer) {
+  int i = RSTRING(buffer)->len;
+  const char *m;
+  magic_t cookie;
+
+  m = STR2CSTR(buffer);
+  GetMagicCookie(self, cookie);
+  if ((m = magic_buffer(cookie, m, i)) == NULL)
+    rb_raise(rb_FileMagicError, magic_error(cookie));
+
+  return rb_str_new2(m);
+}
+
+/* Set flags on the cookie object */
+static VALUE rb_magic_setflags(VALUE self, VALUE flags) {
+  int retval;
+  magic_t cookie;
+
+  GetMagicCookie(self, cookie);
+  retval = magic_setflags(cookie, NUM2INT(flags));
+
+  return INT2FIX(retval);
+}
+
+/* Checks validity of a magic database file */
+static VALUE rb_magic_check(VALUE self, VALUE file) {
+  int retval;
+  const char *m;
+  magic_t cookie;
+
+  GetMagicCookie(self, cookie);
+  m = STR2CSTR(file);
+  retval = magic_check(cookie, m);
+
+  return INT2FIX(retval);
+}
+
+/* Compiles a magic database file */
+static VALUE rb_magic_compile(VALUE self, VALUE file) {
+  int retval;
+  const char *m;
+  magic_t cookie;
+
+  GetMagicCookie(self, cookie);
+  m = STR2CSTR(file);
+  retval = magic_compile(cookie, m);
+
+  return INT2FIX(retval);
+}
+
+void Init_filemagic() {
+  cFileMagic = rb_define_class("FileMagic", rb_cObject);
+
+  rb_define_singleton_method(cFileMagic, "fm_new", rb_magic_new, 1);
+
+  rb_define_method(cFileMagic, "fm_initialize", rb_magic_init,     1);
+  rb_define_method(cFileMagic, "fm_close",      rb_magic_close,    0);
+  rb_define_method(cFileMagic, "fm_file",       rb_magic_file,     1);
+  rb_define_method(cFileMagic, "fm_buffer",     rb_magic_buffer,   1);
+  rb_define_method(cFileMagic, "fm_setflags",   rb_magic_setflags, 1);
+  rb_define_method(cFileMagic, "fm_check",      rb_magic_check,    1);
+  rb_define_method(cFileMagic, "fm_compile",    rb_magic_compile,  1);
+
+  rb_FileMagicError = rb_define_class_under(cFileMagic, "FileMagicError", rb_eStandardError);
+
+  #ifdef MAGIC_NONE
+  rb_define_const(cFileMagic, "MAGIC_NONE",              INT2FIX(MAGIC_NONE));
+  #endif
+  #ifdef MAGIC_DEBUG
+  rb_define_const(cFileMagic, "MAGIC_DEBUG",             INT2FIX(MAGIC_DEBUG));
+  #endif
+  #ifdef MAGIC_SYMLINK
+  rb_define_const(cFileMagic, "MAGIC_SYMLINK",           INT2FIX(MAGIC_SYMLINK));
+  #endif
+  #ifdef MAGIC_COMPRESS
+  rb_define_const(cFileMagic, "MAGIC_COMPRESS",          INT2FIX(MAGIC_COMPRESS));
+  #endif
+  #ifdef MAGIC_DEVICES
+  rb_define_const(cFileMagic, "MAGIC_DEVICES",           INT2FIX(MAGIC_DEVICES));
+  #endif
+  #ifdef MAGIC_MIME_TYPE
+  rb_define_const(cFileMagic, "MAGIC_MIME_TYPE",         INT2FIX(MAGIC_MIME_TYPE));
+  #endif
+  #ifdef MAGIC_CONTINUE
+  rb_define_const(cFileMagic, "MAGIC_CONTINUE",          INT2FIX(MAGIC_CONTINUE));
+  #endif
+  #ifdef MAGIC_CHECK
+  rb_define_const(cFileMagic, "MAGIC_CHECK",             INT2FIX(MAGIC_CHECK));
+  #endif
+  #ifdef MAGIC_PRESERVE_ATIME
+  rb_define_const(cFileMagic, "MAGIC_PRESERVE_ATIME",    INT2FIX(MAGIC_PRESERVE_ATIME));
+  #endif
+  #ifdef MAGIC_RAW
+  rb_define_const(cFileMagic, "MAGIC_RAW",               INT2FIX(MAGIC_RAW));
+  #endif
+  #ifdef MAGIC_ERROR
+  rb_define_const(cFileMagic, "MAGIC_ERROR",             INT2FIX(MAGIC_ERROR));
+  #endif
+  #ifdef MAGIC_MIME_ENCODING
+  rb_define_const(cFileMagic, "MAGIC_MIME_ENCODING",     INT2FIX(MAGIC_MIME_ENCODING));
+  #endif
+  #ifdef MAGIC_MIME
+  rb_define_const(cFileMagic, "MAGIC_MIME",              INT2FIX(MAGIC_MIME));
+  #endif
+  #ifdef MAGIC_NO_CHECK_COMPRESS
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_COMPRESS", INT2FIX(MAGIC_NO_CHECK_COMPRESS));
+  #endif
+  #ifdef MAGIC_NO_CHECK_TAR
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_TAR",      INT2FIX(MAGIC_NO_CHECK_TAR));
+  #endif
+  #ifdef MAGIC_NO_CHECK_SOFT
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_SOFT",     INT2FIX(MAGIC_NO_CHECK_SOFT));
+  #endif
+  #ifdef MAGIC_NO_CHECK_APPTYPE
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_APPTYPE",  INT2FIX(MAGIC_NO_CHECK_APPTYPE));
+  #endif
+  #ifdef MAGIC_NO_CHECK_ELF
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_ELF",      INT2FIX(MAGIC_NO_CHECK_ELF));
+  #endif
+  #ifdef MAGIC_NO_CHECK_ASCII
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_ASCII",    INT2FIX(MAGIC_NO_CHECK_ASCII));
+  #endif
+  #ifdef MAGIC_NO_CHECK_TROFF
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_TROFF",    INT2FIX(MAGIC_NO_CHECK_TROFF));
+  #endif
+  #ifdef MAGIC_NO_CHECK_TOKENS
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_TOKENS",   INT2FIX(MAGIC_NO_CHECK_TOKENS));
+  #endif
+  #ifdef MAGIC_NO_CHECK_FORTRAN
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_FORTRAN",  INT2FIX(MAGIC_NO_CHECK_FORTRAN));
+  #endif
+}

data/info/example.rb

@@ -0,0 +1,28 @@
+#! /usr/bin/ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'filemagic'
+
+puts FileMagic.new.flags
+
+FileMagic.open(:mime) { |fm|
+  puts fm.flags
+  puts fm.file(__FILE__)
+
+  fm.setflags(:raw, :continue)
+  puts fm.flags
+}
+
+fm = FileMagic.new
+puts fm.flags
+
+mime = FileMagic.mime
+puts mime.flags
+
+ARGV.each { |file|
+  puts fm.file(file)
+  puts fm.file(file, true)
+
+  puts mime.file(file)
+  puts mime.file(file, true)
+}

data/info/filemagic.rd

@@ -0,0 +1,36 @@
+=begin
+
+= FileMagic extension module SEE ALSO libmagic(3), file(1) and magic(4)
+== FileMagic
+=== Constants
+: MAGIC_NONE
+     No flags
+: MAGIC_DEBUG
+     Turn on debuggin
+: MAGIC_SYMLINK
+     Follow symlinks
+: MAGIC_COMPRESS
+     Check inside compressed files
+: MAGIC_DEVICES
+     Look at the contents of devices
+: MAGIC_MIME
+     Return a mime string
+: MAGIC_CONTINUE
+     Return all matches, not just the first
+: MAGIC_CHECK
+     Print warnings to stderr
+
+=== Methods
+: file(filename)
+    returns a textual description of the contents of the filename argument
+: buffer(string)
+    returns a textual description of the contents of the string argument
+: check(filename)
+    checks the validity of entries in the colon separated database files
+    passed in as filename
+: compile(filename)
+    compile the the colon separated list of database files passed in as
+    filename
+: close()
+    closes the magic database and frees any memory allocated. if memory
+    is a concern, use this.

data/lib/filemagic.rb

@@ -0,0 +1,177 @@
+require 'filemagic.so'
+
+class FileMagic
+
+  # Map abbreviated flag names to their values (:name => Constant).
+  MAGIC_FLAGS = [
+    :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
+    :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_ascii,     # Don't check for ascii files
+    :no_check_troff,     # Don't check ascii/troff
+    :no_check_tokens,    # Don't check ascii/tokens
+    :no_check_fortran    # Don't check ascii/fortran
+  ].inject({}) { |flags, flag|
+    const = "MAGIC_#{flag.to_s.upcase}"
+    flags.update(flag => const_defined?(const) && const_get(const))
+  }
+
+  attr_reader :flags
+  attr_writer :simplified
+
+  @fm = Hash.new { |fm, flags|
+    fm.has_key?(key = flags.to_s) ? fm[key] : fm[key] = new(*flags)
+  }
+
+  class << self
+
+    # Provide a "magic singleton" ;-)
+    def fm(*flags)
+      @fm.delete(flags.to_s) if @fm[flags].closed?
+      @fm[flags]
+    end
+
+    # Clear our instance cache.
+    def clear!
+      @fm.each_value { |fm| fm.close }
+      @fm.clear
+    end
+
+    # Allow shorter names for flags; now also takes options.
+    def new(*flags)
+      warn "warning: FileMagic::new() does not take block; use FileMagic::open() instead" if block_given?
+
+      options = flags.last.is_a?(Hash) ? flags.pop : {}
+
+      fm = fm_new(build_flags(*flags))
+
+      options.each { |option, value|
+        if fm.respond_to?(method = "#{option}=")
+          fm.send(method, value)
+        else
+          raise ArgumentError, "illegal option: #{option.inspect}"
+        end
+      }
+
+      fm
+    end
+
+    # Just like #new, but takes an optional block, in which case #close is called at the end.
+    def open(*flags)
+      fm = new(*flags)
+
+      if block_given?
+        begin
+          yield fm
+        ensure
+          fm.close
+        end
+      end
+
+      fm
+    end
+
+    # Just a short-cut ;-)
+    def mime(*flags, &block)
+      open(:mime, *flags, &block)
+    end
+
+    # Build the actual flags from the named flags passed as arguments.
+    def build_flags(*flags)
+      _flags = *flags
+
+      unless _flags.is_a?(Integer)
+        _flags = MAGIC_NONE
+
+        flags.flatten.each { |flag|
+          if value = flag.is_a?(Integer) ? flag : MAGIC_FLAGS[flag.to_sym]
+            _flags |= value
+          else
+            raise ArgumentError, "#{value.nil? ? 'no such flag' : 'flag not available'}: #{flag}"
+          end
+        }
+      end
+
+      _flags
+    end
+
+  end
+
+  # The actual processing happens in #new.
+  def initialize(*flags)
+    fm_initialize(*flags)
+
+    @flags  = *flags
+    @closed = false
+  end
+
+  def close
+    return if closed?
+
+    fm_close
+    @closed = true
+  end
+
+  # Optionally cut off additional information after mime-type.
+  def file(file, simplified = simplified?)
+    simplify_mime(fm_file(file), simplified)
+  end
+
+  # Optionally cut off additional information after mime-type.
+  def buffer(buffer, simplified = simplified?)
+    simplify_mime(fm_buffer(buffer), simplified)
+  end
+
+  def setflags(*flags)
+    previous_flags, @flags = @flags, self.class.build_flags(*flags)
+    fm_setflags(@flags)
+
+    previous_flags
+  end
+  alias_method :flags=, :setflags
+
+  def check(file = "\0")
+    fm_check(file)
+  end
+  alias_method :valid?, :check
+
+  def compile(file)
+    fm_compile(file)
+  end
+
+  def simplified?
+    @simplified
+  end
+
+  def closed?
+    @closed
+  end
+
+  def inspect
+    str = super
+    str.insert(-2, ' (closed)') if closed?
+    str
+  end
+
+  private
+
+  def simplify_mime(mime, simplified = true)
+    simplified ? mime[/([\w\/-]+)/, 1].downcase : mime
+  end
+
+end

data/lib/filemagic/ext.rb

@@ -0,0 +1,95 @@
+require 'filemagic'
+
+module FileMagic::Ext
+
+  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)
+      flags.unshift :mime
+      file_type(file, *flags)
+    end
+    alias_method :mime, :mime_type
+
+    def content_type(file, *flags)
+      flags << { :simplified => true }
+      mime_type(file, *flags)
+    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::InstanceMethods
+  extend  FileMagic::Ext::ClassMethods
+
+  def self.file_type(file, *flags)
+    FileMagic.fm(*flags).file(file.respond_to?(:path) ? file.path : file)
+  rescue FileMagic::FileMagicError
+    nil
+  end
+
+end
+
+class String
+
+  include FileMagic::Ext::InstanceMethods
+  extend  FileMagic::Ext::ClassMethods
+
+  def self.file_type(string, *flags)
+    FileMagic.fm(*flags).buffer(string)
+  rescue FileMagic::FileMagicError
+    nil
+  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 = 2
+    TINY  = 1
+
+    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/test/filemagic_test.rb

@@ -0,0 +1,124 @@
+require 'test/unit'
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'filemagic'
+
+class TestFileMagic < Test::Unit::TestCase
+
+  def test_file
+    fm = FileMagic.new(FileMagic::MAGIC_NONE)
+
+    res = fm.file(path_to('pyfile'))
+    assert_equal('a python script text executable', res)
+
+    if File.symlink?(path_to('pylink'))
+      res = fm.file(path_to('pylink'))
+      assert_equal("symbolic link to `pyfile'", res)
+    end
+
+    fm.close
+    fm = FileMagic.new(FileMagic::MAGIC_SYMLINK)
+
+    res = fm.file(path_to('pylink'))
+    assert_equal('a python script text executable', 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'))
+    assert_match(/^a python script text executable \(gzip compressed data, was "pyfile-compressed", from Unix/, res)
+
+    fm.close
+  end
+
+  def test_buffer
+    fm = FileMagic.new(FileMagic::MAGIC_NONE)
+    res = fm.buffer("#!/bin/sh\n")
+    fm.close
+    assert_match(/shell script text executable$/, res)
+  end
+
+  def test_check
+    fm = FileMagic.new(FileMagic::MAGIC_NONE)
+    res = fm.check(path_to('perl'))
+    fm.close
+    assert_equal(0, 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_equal(0, res)
+    File.unlink(path_to('perl.mgc', '.'))
+  end
+
+  def test_block
+    block_fm = FileMagic.open(FileMagic::MAGIC_NONE) { |fm|
+      res = fm.file(path_to('pyfile'))
+      assert_equal('a python script text executable', res)
+    }
+    assert block_fm.closed?
+  end
+
+  def test_setflags
+    fm = FileMagic.new(FileMagic::MAGIC_NONE)
+    assert_equal(FileMagic::MAGIC_NONE, fm.flags)
+    fm.setflags(FileMagic::MAGIC_SYMLINK)
+    assert_equal(FileMagic::MAGIC_SYMLINK, fm.flags)
+    fm.close
+  end
+
+  def test_abbr
+    fm = FileMagic.new(:mime, :continue)
+    assert_equal(FileMagic::MAGIC_MIME | FileMagic::MAGIC_CONTINUE, fm.flags)
+    fm.setflags(:symlink)
+    assert_equal(FileMagic::MAGIC_SYMLINK, fm.flags)
+    fm.close
+  end
+
+  # tests adapted from mahoro:
+
+  def test_mahoro_file
+    fm = FileMagic.new
+    fm.flags = FileMagic::MAGIC_NONE
+    assert_equal('ASCII C program 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('ASCII C program 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(fm.valid?, 'Default database was not valid.')
+  end
+
+  # utility methods:
+
+  def path_to(file, dir = File.dirname(__FILE__))
+    File.join(dir, file)
+  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 */

data/test/perl

@@ -0,0 +1,19 @@
+
+#------------------------------------------------------------------------------
+# perl:  file(1) magic for Larry Wall's perl language.
+#
+# The ``eval'' line recognizes an outrageously clever hack for USG systems.
+# Keith Waclena <keith@cerberus.uchicago.edu>
+# Send additions to <perl5-porters@perl.org>
+0	string/b	#!\ /bin/perl			perl script text executable
+0	string		eval\ "exec\ /bin/perl		perl script text
+0	string/b	#!\ /usr/bin/perl		perl script text executable
+0	string		eval\ "exec\ /usr/bin/perl	perl script text
+0	string/b	#!\ /usr/local/bin/perl		perl script text
+0	string		eval\ "exec\ /usr/local/bin/perl	perl script text executable
+0	string		eval\ '(exit\ $?0)'\ &&\ eval\ 'exec	perl script text
+
+# a couple more, by me
+# XXX: christos matches
+#0	regex		package		Perl5 module source text (via regex)
+0	string		package		Perl5 module source text

data/test/pyfile

@@ -0,0 +1 @@
+"""

data/test/pylink

@@ -0,0 +1 @@
+"""

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-filemagic
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: 
+- Travis Whitton
+- Jens Wille
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-09-18 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Ruby bindings to the magic(4) library
+email: 
+- tinymountain@gmail.com
+- jens.wille@uni-koeln.de
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README
+files: 
+- lib/filemagic/ext.rb
+- lib/filemagic/version.rb
+- lib/filemagic.rb
+- ext/filemagic.c
+- test/pyfile
+- test/pyfile-compressed.gz
+- test/perl
+- test/leaktest.rb
+- test/mahoro.c
+- test/filemagic_test.rb
+- test/pylink
+- README
+- CHANGELOG
+- TODO
+- Rakefile
+- info/filemagic.rd
+- info/example.rb
+has_rdoc: true
+homepage: http://ruby-filemagic.rubyforge.org/
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --main
+- README
+- --all
+- --inline-source
+- --title
+- ruby-filemagic Application documentation
+- --charset
+- UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: ruby-filemagic
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Ruby bindings to the magic(4) library
+test_files: []
+