ruby-filemagic 0.3.0 → 0.4.0

data/CHANGELOG

@@ -1,28 +1,49 @@
 --------------------------------------------------------------------------------
 7/28/2003 version 0.1.0
 
-o Initial release.
+* Initial release.
 
 --------------------------------------------------------------------------------
 7/30/2003 version 0.1.1
 
-o Added manual close method
-o Added unit test suite
+* Added manual close method
+* 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!
+* Modified C API
+  * Uniform C function prefix rb_magic_ (instead of magick_)
+  * Uniform Ruby method prefix fm_ (instead of none)
+  * More magic(4) constants (if available)
+* Added Ruby wrapper for more rubyish interface
+* Added extensions for File and String core classes
+* Added/updated project files
+* 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! :-)
+* Added mahoro source file and tests for reference and inspiration
+* We have a Rubyforge project now! :-)
+
+--------------------------------------------------------------------------------
+3/2/2010 version 0.2.2
+
+* Allow '.' when abbreviating mime types (Eric Schwartz)
+* Cleanup and project file fixes
+
+--------------------------------------------------------------------------------
+9/10/2010 version 0.3.0
+
+* Ruby 1.9.2 compatibility (Martin Carpenter)
+* Exposed flags as symbols (Martin Carpenter)
+
+--------------------------------------------------------------------------------
+9/14/2010 version 0.4.0
+
+* Brushed up C layer
+  * Moved most of the Ruby stuff to C
+  * No longer expose internal state (@closed, @flags)
+  * No longer expose internal C methods (fm_*)
+  * Updated for magic(4) version 5.04

data/README

@@ -2,7 +2,7 @@
 
 == VERSION
 
-This documentation refers to filemagic version 0.3.0
+This documentation refers to filemagic version 0.4.0
 
 
 == DESCRIPTION
@@ -15,14 +15,10 @@ 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 Rubyforge[http://rubyforge.org]:
+Install the gem:
 
   sudo gem install ruby-filemagic
 
-or 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>

data/Rakefile

@@ -16,7 +16,7 @@ begin
       :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,
+      :files       => FileList['lib/**/*.rb', 'ext/**/*.[ch]', 'test/*'].to_a,
       :extensions  => FileList['ext/**/extconf.rb'].to_a,
       :extra_files => FileList['[A-Z]*', 'info/*'].to_a
     }

data/TODO

@@ -1,9 +1,8 @@
-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:
+* Find a better way to handle magic_load than just defaulting to NULL
+* Find a way to make magic_check work on NULL
+* Refactor code into initialize instead of new
 
-FileMagic.open("somefile.txt") do |file|
-  # close is called at the end of this block
-end
+* Expose magic(4) version (how?)
+* Properly document C methods
+* Convert tests to RSpec
+* Add Rake tasks

data/ext/extconf.rb

@@ -1,8 +1,9 @@
 require 'mkmf'
 
-dir_config("magic")
-if have_library("magic", "magic_open") and have_header("magic.h")
-  create_makefile("filemagic")
+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

@@ -13,91 +13,161 @@
 
 *********************************************************/
 
-#include "ruby.h"
-#include <magic.h>
+#include "filemagic.h"
 
-static VALUE cFileMagic, rb_FileMagicError;
+/* FileMagic.new */
+static VALUE
+rb_magic_new(int argc, VALUE *argv, VALUE class) {
+  VALUE obj, args[2];
+  magic_t cookie;
 
-#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);\
-}
+  if (rb_block_given_p()) {
+    rb_warn("FileMagic::new() does not take block; use FileMagic::open() instead");
+  }
 
-/* 
- 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);
+  if (argc > 0 && TYPE(args[1] = argv[argc - 1]) == T_HASH) {
+    argc--;
+  }
+  else {
+    args[1] = rb_hash_new();
+  }
+
+  args[0] = rb_magic_flags_to_int(argc, argv);
+  if ((cookie = magic_open(NUM2INT(args[0]))) == 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, 2, args);
+
+  return obj;
 }
 
-static VALUE rb_magic_init(VALUE self, VALUE flags) {
+static VALUE
+rb_magic_init(int argc, VALUE *argv, VALUE self) {
+  VALUE flags, options, keys, k, m;
+  ID mid;
+  int i;
+
+  if (rb_scan_args(argc, argv, "11", &flags, &options) == 1) {
+    options = rb_hash_new();
+  }
+
+  rb_iv_set(self, "_flags", flags);
+  rb_iv_set(self, "closed", Qfalse);
+
+  keys = rb_funcall(options, rb_intern("keys"), 0);
+
+  for (i = 0; i < RARRAY_LEN(keys); i++) {
+    k = rb_funcall(keys, rb_intern("[]"), 1, INT2FIX(i));
+    m = rb_funcall(rb_funcall(k, rb_intern("to_s"), 0),
+      rb_intern("+"), 1, rb_str_new2("=")
+    );
+
+    if (rb_respond_to(self, mid = rb_intern(StringValueCStr(m)))) {
+      rb_funcall(self, mid, 1, rb_hash_aref(options, k));
+    }
+    else {
+      k = rb_funcall(k, rb_intern("inspect"), 0);
+      rb_raise(rb_eArgError, "illegal option: %s", StringValueCStr(k));
+    }
+  }
+
   return Qnil;
 }
 
 /* Frees resources allocated */
-static VALUE rb_magic_close(VALUE self) {
+static VALUE
+rb_magic_close(VALUE self) {
   magic_t cookie;
 
+  if (RTEST(rb_magic_closed_p(self))) {
+    return Qnil;
+  }
+
   GetMagicCookie(self, cookie);
   magic_close(cookie);
 
   /* This keeps rb_magic_free from trying to free closed objects */
   RDATA(self)->data = NULL;
 
+  rb_iv_set(self, "closed", Qtrue);
+
   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;
+static VALUE
+rb_magic_closed_p(VALUE self) {
+  return rb_attr_get(self, rb_intern("closed"));
 }
 
 /* Return a string describing file */
-static VALUE rb_magic_file(VALUE self, VALUE file) {
+static VALUE
+rb_magic_file(int argc, VALUE *argv, VALUE self) {
+  VALUE file, s;
   const char *m;
   magic_t cookie;
 
+  rb_scan_args(argc, argv, "11", &file, &s);
+
   m = StringValuePtr(file);
   GetMagicCookie(self, cookie);
-  if ((m = magic_file(cookie, m)) == NULL)
-    rb_raise(rb_FileMagicError, magic_error(cookie));
 
-  return rb_str_new2(m);
+  if ((m = magic_file(cookie, m)) == NULL) {
+    rb_raise(rb_FileMagicError, "%s", magic_error(cookie));
+  }
+
+  return rb_magic_apply_simple(self, m, s);
 }
 
 /* Return a string describing the string buffer */
-static VALUE rb_magic_buffer(VALUE self, VALUE buffer) {
-  int i = RSTRING_LEN(buffer);
+static VALUE
+rb_magic_buffer(int argc, VALUE *argv, VALUE self) {
+  VALUE buffer, s;
   const char *m;
   magic_t cookie;
 
+  rb_scan_args(argc, argv, "11", &buffer, &s);
+
   m = StringValuePtr(buffer);
   GetMagicCookie(self, cookie);
-  if ((m = magic_buffer(cookie, m, i)) == NULL)
-    rb_raise(rb_FileMagicError, magic_error(cookie));
 
-  return rb_str_new2(m);
+  if ((m = magic_buffer(cookie, m, RSTRING_LEN(buffer))) == NULL) {
+    rb_raise(rb_FileMagicError, "%s", magic_error(cookie));
+  }
+
+  return rb_magic_apply_simple(self, m, s);
+}
+
+/* Get the flags as array of symbols */
+static VALUE
+rb_magic_getflags(VALUE self) {
+  VALUE ary = rb_ary_new();
+  VALUE map = rb_const_get(cFileMagic, rb_intern("FLAGS_BY_INT"));
+  int i = NUM2INT(rb_attr_get(self, rb_intern("_flags"))), j = 0;
+
+  while ((i -= j) > 0) {
+    j = pow(2, (int)(log(i) / log(2)));
+    rb_ary_unshift(ary, rb_hash_aref(map, INT2FIX(j)));
+  }
+
+  return ary;
 }
 
 /* Set flags on the cookie object */
-static VALUE rb_magic_setflags(VALUE self, VALUE flags) {
+static VALUE
+rb_magic_setflags(VALUE self, VALUE flags) {
   int retval;
   magic_t cookie;
 
+  flags = rb_Array(flags);
+  flags = rb_magic_flags_to_int(RARRAY_LEN(flags), RARRAY_PTR(flags));
+  rb_iv_set(self, "_flags", flags);
+
   GetMagicCookie(self, cookie);
   retval = magic_setflags(cookie, NUM2INT(flags));
 
@@ -105,20 +175,24 @@ static VALUE rb_magic_setflags(VALUE self, VALUE flags) {
 }
 
 /* Checks validity of a magic database file */
-static VALUE rb_magic_check(VALUE self, VALUE file) {
+static VALUE
+rb_magic_check(int argc, VALUE *argv, VALUE self) {
+  VALUE s;
+  const char *file;
   int retval;
-  const char *m;
   magic_t cookie;
 
+  file = rb_scan_args(argc, argv, "01", &s) == 1 ? StringValuePtr(s) : NULL;
+
   GetMagicCookie(self, cookie);
-  m = StringValuePtr(file);
-  retval = magic_check(cookie, m);
+  retval = magic_check(cookie, file);
 
   return INT2FIX(retval);
 }
 
 /* Compiles a magic database file */
-static VALUE rb_magic_compile(VALUE self, VALUE file) {
+static VALUE
+rb_magic_compile(VALUE self, VALUE file) {
   int retval;
   const char *m;
   magic_t cookie;
@@ -130,85 +204,165 @@ static VALUE rb_magic_compile(VALUE self, VALUE file) {
   return INT2FIX(retval);
 }
 
-void Init_filemagic() {
+static VALUE
+rb_magic_flags_to_int(int argc, VALUE *argv) {
+  VALUE map = rb_const_get(cFileMagic, rb_intern("FLAGS_BY_SYM"));
+  VALUE f, g;
+  int i = MAGIC_NONE, j;
+
+  for (j = 0; j < argc; j++) {
+    f = argv[j];
+
+    switch (TYPE(f)) {
+      case T_SYMBOL:
+        if (RTEST(g = rb_hash_aref(map, f))) {
+          f = g;
+          /* fall through */
+        }
+        else {
+          f = rb_funcall(f, rb_intern("inspect"), 0);
+          rb_raise(rb_eArgError,
+            "%s: %s", NIL_P(g) ? "no such flag" : "flag not available",
+            StringValueCStr(f)
+          );
+          break;
+        }
+      case T_FIXNUM:
+        i |= NUM2INT(f);
+        break;
+      default:
+        rb_raise(rb_eTypeError,
+          "wrong argument type %s (expected Fixnum or Symbol)",
+          rb_obj_classname(f)
+        );
+    }
+  }
+
+  return INT2FIX(i);
+}
+
+static VALUE
+rb_magic_apply_simple(VALUE self, const char *m, VALUE s) {
+  VALUE str = rb_str_new2(m);
+
+  if (RTEST(NIL_P(s) ? rb_attr_get(self, rb_intern("@simplified")) : s)) {
+    rb_funcall(str, rb_intern("downcase!"), 0);
+
+    return rb_funcall(str, rb_intern("slice"), 2,
+      rb_const_get(cFileMagic, rb_intern("SIMPLE_RE")),
+      INT2FIX(1)
+    );
+  }
+  else {
+    return str;
+  }
+}
+
+/*
+ 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);
+}
+
+void
+Init_filemagic() {
   cFileMagic = rb_define_class("FileMagic", rb_cObject);
 
-  rb_define_singleton_method(cFileMagic, "fm_new", rb_magic_new, 1);
+  rb_define_singleton_method(cFileMagic, "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_define_method(cFileMagic, "initialize", rb_magic_init,     -1);
+  rb_define_method(cFileMagic, "close",      rb_magic_close,     0);
+  rb_define_method(cFileMagic, "closed?",    rb_magic_closed_p,  0);
+  rb_define_method(cFileMagic, "file",       rb_magic_file,     -1);
+  rb_define_method(cFileMagic, "buffer",     rb_magic_buffer,   -1);
+  rb_define_method(cFileMagic, "flags",      rb_magic_getflags,  0);
+  rb_define_method(cFileMagic, "flags=",     rb_magic_setflags,  1);
+  rb_define_method(cFileMagic, "check",      rb_magic_check,    -1);
+  rb_define_method(cFileMagic, "compile",    rb_magic_compile,   1);
+
+  rb_alias(cFileMagic, rb_intern("valid?"), rb_intern("check"));
 
   rb_FileMagicError = rb_define_class_under(cFileMagic, "FileMagicError", rb_eStandardError);
 
-  #ifdef MAGIC_NONE
+#ifdef MAGIC_NONE
   rb_define_const(cFileMagic, "MAGIC_NONE",              INT2FIX(MAGIC_NONE));
-  #endif
-  #ifdef MAGIC_DEBUG
+#endif
+#ifdef MAGIC_DEBUG
   rb_define_const(cFileMagic, "MAGIC_DEBUG",             INT2FIX(MAGIC_DEBUG));
-  #endif
-  #ifdef MAGIC_SYMLINK
+#endif
+#ifdef MAGIC_SYMLINK
   rb_define_const(cFileMagic, "MAGIC_SYMLINK",           INT2FIX(MAGIC_SYMLINK));
-  #endif
-  #ifdef MAGIC_COMPRESS
+#endif
+#ifdef MAGIC_COMPRESS
   rb_define_const(cFileMagic, "MAGIC_COMPRESS",          INT2FIX(MAGIC_COMPRESS));
-  #endif
-  #ifdef MAGIC_DEVICES
+#endif
+#ifdef MAGIC_DEVICES
   rb_define_const(cFileMagic, "MAGIC_DEVICES",           INT2FIX(MAGIC_DEVICES));
-  #endif
-  #ifdef MAGIC_MIME_TYPE
+#endif
+#ifdef MAGIC_MIME_TYPE
   rb_define_const(cFileMagic, "MAGIC_MIME_TYPE",         INT2FIX(MAGIC_MIME_TYPE));
-  #endif
-  #ifdef MAGIC_CONTINUE
+#endif
+#ifdef MAGIC_CONTINUE
   rb_define_const(cFileMagic, "MAGIC_CONTINUE",          INT2FIX(MAGIC_CONTINUE));
-  #endif
-  #ifdef MAGIC_CHECK
+#endif
+#ifdef MAGIC_CHECK
   rb_define_const(cFileMagic, "MAGIC_CHECK",             INT2FIX(MAGIC_CHECK));
-  #endif
-  #ifdef MAGIC_PRESERVE_ATIME
+#endif
+#ifdef MAGIC_PRESERVE_ATIME
   rb_define_const(cFileMagic, "MAGIC_PRESERVE_ATIME",    INT2FIX(MAGIC_PRESERVE_ATIME));
-  #endif
-  #ifdef MAGIC_RAW
+#endif
+#ifdef MAGIC_RAW
   rb_define_const(cFileMagic, "MAGIC_RAW",               INT2FIX(MAGIC_RAW));
-  #endif
-  #ifdef MAGIC_ERROR
+#endif
+#ifdef MAGIC_ERROR
   rb_define_const(cFileMagic, "MAGIC_ERROR",             INT2FIX(MAGIC_ERROR));
-  #endif
-  #ifdef MAGIC_MIME_ENCODING
+#endif
+#ifdef MAGIC_MIME_ENCODING
   rb_define_const(cFileMagic, "MAGIC_MIME_ENCODING",     INT2FIX(MAGIC_MIME_ENCODING));
-  #endif
-  #ifdef MAGIC_MIME
+#endif
+#ifdef MAGIC_MIME
   rb_define_const(cFileMagic, "MAGIC_MIME",              INT2FIX(MAGIC_MIME));
-  #endif
-  #ifdef MAGIC_NO_CHECK_COMPRESS
+#endif
+#ifdef MAGIC_APPLE
+  rb_define_const(cFileMagic, "MAGIC_APPLE",             INT2FIX(MAGIC_APPLE));
+#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
+#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
+#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
+#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
+#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
+#endif
+#ifdef MAGIC_NO_CHECK_TEXT
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_TEXT",     INT2FIX(MAGIC_NO_CHECK_TEXT));
+#endif
+#ifdef MAGIC_NO_CHECK_CDF
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_CDF",      INT2FIX(MAGIC_NO_CHECK_CDF));
+#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
+#endif
+#ifdef MAGIC_NO_CHECK_ENCODING
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_ENCODING", INT2FIX(MAGIC_NO_CHECK_ENCODING));
+#endif
+#ifdef MAGIC_NO_CHECK_ASCII
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_ASCII",    INT2FIX(MAGIC_NO_CHECK_ASCII));
+#endif
+#ifdef MAGIC_NO_CHECK_FORTRAN
   rb_define_const(cFileMagic, "MAGIC_NO_CHECK_FORTRAN",  INT2FIX(MAGIC_NO_CHECK_FORTRAN));
-  #endif
+#endif
+#ifdef MAGIC_NO_CHECK_TROFF
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_TROFF",    INT2FIX(MAGIC_NO_CHECK_TROFF));
+#endif
 }

data/ext/filemagic.h

@@ -0,0 +1,48 @@
+#ifndef __FILEMAGIC_H_
+#define __FILEMAGIC_H_
+
+#include "ruby.h"
+#include <magic.h>
+#include <math.h>
+
+/* Ruby 1.8.5 compatibility */
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(s) (RARRAY(s)->len)
+#endif
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(s) (RARRAY(s)->ptr)
+#endif
+
+#define GetMagicCookie(obj, cookie) {\
+  if (RTEST(rb_magic_closed_p(obj)))\
+    rb_raise(rb_eRuntimeError, "closed stream");\
+  Data_Get_Struct(obj, struct magic_set, cookie);\
+}
+
+static VALUE cFileMagic, rb_FileMagicError;
+
+static VALUE rb_magic_new(int, VALUE*, VALUE);
+static VALUE rb_magic_init(int, VALUE*, VALUE);
+
+static VALUE rb_magic_close(VALUE);
+static VALUE rb_magic_closed_p(VALUE);
+static VALUE rb_magic_file(int, VALUE*, VALUE);
+static VALUE rb_magic_buffer(int, VALUE*, VALUE);
+static VALUE rb_magic_getflags(VALUE);
+static VALUE rb_magic_setflags(VALUE, VALUE);
+static VALUE rb_magic_check(int, VALUE*, VALUE);
+static VALUE rb_magic_compile(VALUE, VALUE);
+
+static VALUE rb_magic_flags_to_int(int, VALUE*);
+static VALUE rb_magic_apply_simple(VALUE, const char*, VALUE);
+
+static void rb_magic_free(magic_t);
+void Init_filemagic(void);
+
+#endif /* __FILEMAGIC_H_ */

data/lib/filemagic.rb

@@ -17,15 +17,19 @@ class FileMagic
     :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_ascii,     # Don't check for ascii files
-    :no_check_troff,     # Don't check ascii/troff
+    :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_fortran    # Don't check ascii/fortran
+    :no_check_encoding,  # Don't check text encodings
+    :no_check_ascii,     # MAGIC_NO_CHECK_TEXT
+    :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))
@@ -34,7 +38,8 @@ class FileMagic
   # Map flag values to their names (Integer => :name).
   FLAGS_BY_INT = FLAGS_BY_SYM.invert.update(0 => :none)
 
-  attr_writer :simplified
+  # Extract "simple" MIME type
+  SIMPLE_RE = %r{([.\w\/-]+)}
 
   @fm = Hash.new { |fm, flags|
     fm.has_key?(key = flags.to_s) ? fm[key] : fm[key] = new(*flags)
@@ -42,7 +47,7 @@ class FileMagic
 
   class << self
 
-    # Provide a "magic singleton" ;-)
+    # Provide a "magic singleton".
     def fm(*flags)
       @fm.delete(flags.to_s) if @fm[flags].closed?
       @fm[flags]
@@ -54,26 +59,8 @@ class FileMagic
       @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.
+    # 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)
 
@@ -83,115 +70,26 @@ class FileMagic
         ensure
           fm.close
         end
+      else
+        fm
       end
-
-      fm
     end
 
-    # Just a short-cut ;-)
+    # Just a short-cut to #open with the +mime+ flag set.
     def mime(*flags, &block)
       open(:mime, *flags, &block)
     end
 
-    # Build the actual flags from the named flags passed as arguments.
-    def build_flags(*flags)
-      int_flags = *flags
-
-      unless int_flags.is_a?(Integer)
-        int_flags = MAGIC_NONE
-
-        flags.flatten.each { |flag|
-          if value = flag.is_a?(Integer) ? flag : FLAGS_BY_SYM[flag.to_sym]
-            int_flags |= value
-          else
-            err = value.nil? ? 'no such flag' : 'flag not available'
-            raise ArgumentError, "#{err}: #{flag}"
-          end
-        }
-      end
-
-      int_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
-
-  # Returns the flags as integer.
-  def int_flags
-    @flags.first
-  end
-
-  # Returns the flags as array of symbols.
-  def flags
-    int, flags, log2 = int_flags, [], Math.log(2)
-
-    while int > 0
-      flags << FLAGS_BY_INT[flag = 2 ** Math.log(int).div(log2)]
-      int -= flag
-    end
-
-    flags.reverse
-  end
-
-  # Optionally cut off additional information after mime-type.
-  def buffer(buffer, simplified = simplified?)
-    simplify_mime(fm_buffer(buffer), simplified)
-  end
-
-  def setflags(*flags)
-    @flags = [self.class.build_flags(*flags)]
-    fm_setflags(int_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
+  attr_writer :simplified
 
   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
+    super.insert(-2, closed? ? ' (closed)' : '')
   end
 
 end

data/lib/filemagic/ext.rb

@@ -23,6 +23,7 @@ module FileMagic::Ext
       flags.unshift :mime
       file_type(file, *flags)
     end
+
     alias_method :mime, :mime_type
 
     def content_type(file, *flags)
@@ -37,11 +38,13 @@ module FileMagic::Ext
     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)

data/lib/filemagic/version.rb

@@ -3,7 +3,7 @@ class FileMagic
   module Version
 
     MAJOR = 0
-    MINOR = 3
+    MINOR = 4
     TINY  = 0
 
     class << self

data/test/filemagic_test.rb

@@ -62,17 +62,19 @@ class TestFileMagic < Test::Unit::TestCase
   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)
+    block_fm = nil
+    res = FileMagic.open(FileMagic::MAGIC_NONE) { |fm|
+      block_fm = fm
+      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([], fm.flags)
-    fm.setflags(FileMagic::MAGIC_SYMLINK)
+    fm.flags = FileMagic::MAGIC_SYMLINK
     assert_equal([:symlink], fm.flags)
     fm.close
   end
@@ -80,11 +82,19 @@ class TestFileMagic < Test::Unit::TestCase
   def test_abbr
     fm = FileMagic.new(:mime, :continue)
     assert_equal([:mime_type, :continue, :mime_encoding] , fm.flags)
-    fm.setflags(:symlink)
+    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
@@ -120,7 +130,14 @@ class TestFileMagic < Test::Unit::TestCase
 
   def test_abbrev_mime_type
     fm = FileMagic.mime
-    assert_match(/\Aapplication\/vnd.ms-/, fm.file(path_to('excel-example.xls')))
+
+    assert !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('application/vnd.ms-office', fm.file(path_to('excel-example.xls')))
   end
 
   # utility methods:

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-filemagic
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 3
+  - 4
   - 0
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Travis Whitton
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-10 00:00:00 +02:00
+date: 2010-09-14 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -34,6 +34,7 @@ files:
 - lib/filemagic/ext.rb
 - lib/filemagic/version.rb
 - lib/filemagic.rb
+- ext/filemagic.h
 - ext/filemagic.c
 - test/pyfile
 - test/mahoro.c