ruby-filemagic 0.6.2-x86-mingw32

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 119c4a11a9e3df55d70340d9b32ff3c508741ef0
+  data.tar.gz: 89d8685a9ccf5762433c78b873135be2bd0af1fe
+SHA512:
+  metadata.gz: 6257197e6afb3f26a54ba3045f14ffa69d549c37099dd25d03aa394831f0c5aa156038dc28302b93cae7373264e0a45382c8947835bf271fae5ad4ebca1898e7
+  data.tar.gz: 544f82f2f42d3c337fec1bfb985f33c737697423a954790588420c3c7f0e4820a503232cef16e581c2faca684b81277be3d2d83eb2b1d6bdfeb6dc4b3e06d084

data/ChangeLog

@@ -0,0 +1,92 @@
+# markup: rd
+
+= Revision history for ruby-filemagic
+
+== 0.6.2 [2015-02-06]
+
+* Improved Windows support (issue #10 by Matt Hoyle).
+* Fixed FileMagic.path to account for missing magic file.
+
+== 0.6.1 [2014-08-19]
+
+* Account for options passed to FileMagic.fm (issue #7 by Adam Wróbel).
+
+== 0.6.0 [2014-05-16]
+
+* Required Ruby version >= 1.9.3.
+* New method FileMagic#list (+magic_list+).
+* New method FileMagic#load (+magic_load+).
+* New method FileMagic.path (+magic_getpath+).
+* New method FileMagic.magic_version.
+* New method FileMagic.flags.
+* New flag +no_check_builtin+.
+* Tests print libmagic version and path.
+* Internal refactoring.
+
+== 0.5.2 [2014-04-24]
+
+* Use MAGIC_VERSION if available.
+* Made tests more robust.
+
+== 0.5.1 [2014-04-15]
+
+* New method FileMagic#io.
+* Housekeeping.
+
+== 0.5.0 [2013-12-19]
+
+* Removed usage of +RARRAY_PTR+ (cf. Ruby bug
+  {#8399}[https://bugs.ruby-lang.org/issues/8399]).
+* Housekeeping.
+
+== 0.4.2 [2010-09-16]
+
+* Not all versions/distributions have file/patchlevel.h
+
+== 0.4.1 [2010-09-15]
+
+* Added MAGIC_VERSION
+* Fixed example script
+
+== 0.4.0 [2010-09-14]
+
+* 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
+
+== 0.3.0 [2010-09-10]
+
+* Ruby 1.9.2 compatibility (Martin Carpenter)
+* Exposed flags as symbols (Martin Carpenter)
+
+== 0.2.2 [2010-03-02]
+
+* Allow '.' when abbreviating mime types (Eric Schwartz)
+* Cleanup and project file fixes
+
+== 0.2.1 [2008-09-18]
+
+* Added mahoro source file and tests for reference and inspiration
+* We have a Rubyforge project now! :-)
+
+== 0.2.0 [2008-09-12]
+
+* 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!
+
+== 0.1.1 [2003-07-30]
+
+* Added manual close method
+* Added unit test suite
+
+== 0.1.0 [2003-07-28]
+
+* Initial release.

data/README

@@ -0,0 +1,101 @@
+= FileMagic Library Binding
+
+== VERSION
+
+This documentation refers to filemagic version 0.6.2
+
+
+== DESCRIPTION
+
+FileMagic extension module. See also libmagic(3), file(1) and magic(4).
+
+=== Constants
+
+<tt>MAGIC_NONE</tt>::     No flags
+<tt>MAGIC_DEBUG</tt>::    Turn on debugging
+<tt>MAGIC_SYMLINK</tt>::  Follow symlinks
+<tt>MAGIC_COMPRESS</tt>:: Check inside compressed files
+<tt>MAGIC_DEVICES</tt>::  Look at the contents of devices
+<tt>MAGIC_MIME</tt>::     Return a mime string
+<tt>MAGIC_CONTINUE</tt>:: Return all matches, not just the first
+<tt>MAGIC_CHECK</tt>::    Print warnings to stderr
+
+=== Methods
+
+<tt>file(filename)</tt>::    Returns a textual description of the contents
+                             of the filename argument
+<tt>buffer(string)</tt>::    Returns a textual description of the contents
+                             of the string argument
+<tt>check(filename)</tt>::   Checks the validity of entries in the database
+                             file passed in as filename
+<tt>compile(filename)</tt>:: Compiles the database file passed in as filename
+<tt>close()</tt>::           Closes the magic database and frees any memory
+                             allocated
+
+=== Synospis
+
+  require 'filemagic'
+
+  p FileMagic::VERSION
+  p FileMagic::MAGIC_VERSION
+
+  p FileMagic.new.flags
+
+  FileMagic.open(:mime) { |fm|
+    p fm.flags
+    p fm.file(__FILE__)
+    p fm.file(__FILE__, true)
+
+    fm.flags = [:raw, :continue]
+    p fm.flags
+  }
+
+  fm = FileMagic.new
+  p fm.flags
+
+  mime = FileMagic.mime
+  p mime.flags
+
+=== Installation
+
+Install the gem:
+
+  sudo gem install ruby-filemagic
+
+The file(1) library and headers are required.
+
+
+== LINKS
+
+Homepage::      http://www.darwinsys.com/file/
+Documentation:: https://blackwinter.github.com/ruby-filemagic
+Source code::   https://github.com/blackwinter/ruby-filemagic
+RubyGem::       https://rubygems.org/gems/ruby-filemagic
+Travis CI::     https://travis-ci.org/blackwinter/ruby-filemagic
+
+
+== AUTHORS
+
+* Travis Whitton <mailto:tinymountain@gmail.com> (Original author)
+* Jens Wille <mailto:jens.wille@gmail.com>
+
+
+== CREDITS
+
+* Martin Carpenter <mailto:mcarpenter@free.fr> for Ruby 1.9.2 compatibility
+  and other improvements.
+
+
+== 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,34 @@
+require_relative 'lib/filemagic/version'
+
+begin
+  require 'hen'
+
+  file mgc = 'lib/filemagic/magic.mgc' do
+    dir = ENV['WITH_CROSS_MAGIC']
+
+    dir && File.exist?(src = File.join(dir, 'magic', File.basename(mgc))) ?
+      cp(src, mgc) : File.binwrite(mgc, "\x1C\x04\x1E\xF1\x0C".ljust(248, "\0"))
+  end
+
+  Hen.lay! {{
+    gem: {
+      name:        %q{ruby-filemagic},
+      version:     FileMagic::VERSION,
+      summary:     'Ruby bindings to the magic(4) library',
+      authors:     ['Travis Whitton', 'Jens Wille'],
+      email:       'jens.wille@gmail.com',
+      license:     %q{Ruby},
+      homepage:    :blackwinter,
+      local_files: [mgc],
+      extension:   {
+        with_cross_gnurx: lambda { |dir| [dir] },
+        with_cross_magic: lambda { |dir| [src =
+          File.join(dir, 'src'), File.join(src, '.libs')] }
+      },
+
+      required_ruby_version: '>= 1.9.3'
+    }
+  }}
+rescue LoadError => err
+  warn "Please install the `hen' gem. (#{err})"
+end

data/TODO

@@ -0,0 +1,7 @@
+* 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
+
+* Properly document C methods
+* Convert tests to RSpec
+* Add Rake tasks

data/ext/filemagic/extconf.rb

@@ -0,0 +1,16 @@
+require 'mkmf'
+
+$CFLAGS << ' -Wall' if ENV['WALL']
+$LDFLAGS << ' -static-libgcc'
+
+dir_config('magic')
+dir_config('gnurx')
+
+have_library('gnurx')
+
+if have_library('magic', 'magic_open') && have_header('magic.h')
+  have_header('file/patchlevel.h')
+  create_makefile('filemagic/ruby_filemagic')
+else
+  abort '*** ERROR: missing required library to compile this module'
+end

data/ext/filemagic/filemagic.c

@@ -0,0 +1,310 @@
+#include "filemagic.h"
+
+/* Returns the magic path */
+static VALUE
+rb_magic_getpath(VALUE klass) {
+  const char *path = magic_getpath(NULL, 0);
+  return path != NULL ? rb_str_new2(path) : Qnil;
+}
+
+/* Converts flags to integer */
+static VALUE
+rb_magic_flags(VALUE klass, VALUE flags) {
+  VALUE map = rb_const_get(cFileMagic, rb_intern("FLAGS_BY_SYM")), f, g;
+  int i = MAGIC_NONE, j;
+
+  if (TYPE(flags) != T_ARRAY) {
+    rb_raise(rb_eTypeError,
+      "wrong argument type %s (expected Array)",
+      rb_obj_classname(flags));
+  }
+
+  for (j = 0; j < RARRAY_LEN(flags); j++) {
+    f = rb_ary_entry(flags, 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);
+}
+
+/* FileMagic.new */
+static VALUE
+rb_magic_new(int argc, VALUE *argv, VALUE klass) {
+  VALUE obj, args[2];
+  magic_t ms;
+
+  if (rb_block_given_p()) {
+    rb_warn(
+      "FileMagic.new() does not take a block; use FileMagic.open() instead");
+  }
+
+  if (argc > 0 && TYPE(args[1] = argv[argc - 1]) == T_HASH) {
+    argc--;
+  }
+  else {
+    args[1] = rb_hash_new();
+  }
+
+  args[0] = rb_magic_flags(klass, rb_ary_new4(argc, argv));
+
+  if ((ms = magic_open(NUM2INT(args[0]))) == NULL) {
+    rb_raise(rb_FileMagicError,
+      "failed to initialize magic cookie (%d)", errno || -1);
+  }
+
+  if (magic_load(ms, NULL) == -1) {
+    rb_raise(rb_FileMagicError,
+      "failed to load database: %s", magic_error(ms));
+  }
+
+  obj = Data_Wrap_Struct(klass, 0, rb_magic_free, ms);
+  rb_obj_call_init(obj, 2, args);
+
+  return obj;
+}
+
+static void
+rb_magic_free(magic_t ms) {
+  magic_close(ms);
+}
+
+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, "iflags", 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_ary_entry(keys, i);
+    m = rb_str_plus(rb_obj_as_string(k), 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) {
+  magic_t ms;
+
+  if (RTEST(rb_magic_closed_p(self))) {
+    return Qnil;
+  }
+
+  GetMagicSet(self, ms);
+  rb_magic_free(ms);
+
+  /* This keeps rb_magic_free from trying to free closed objects */
+  DATA_PTR(self) = NULL;
+
+  rb_iv_set(self, "closed", Qtrue);
+
+  return Qnil;
+}
+
+static VALUE
+rb_magic_closed_p(VALUE self) {
+  return rb_attr_get(self, rb_intern("closed"));
+}
+
+/* Return a string describing file */
+RB_MAGIC_TYPE(file, FILE)
+
+/* Return a string describing the string buffer */
+RB_MAGIC_TYPE(buffer, BUFFER)
+
+/* 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("iflags"))), 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 ms object */
+static VALUE
+rb_magic_setflags(VALUE self, VALUE flags) {
+  magic_t ms;
+
+  GetMagicSet(self, ms);
+
+  rb_iv_set(self, "iflags",
+    flags = rb_magic_flags(CLASS_OF(self), rb_Array(flags)));
+
+  return INT2FIX(magic_setflags(ms, NUM2INT(flags)));
+}
+
+/* Lists a magic database file */
+RB_MAGIC_APPRENTICE(list)
+
+/* Loads a magic database file */
+RB_MAGIC_APPRENTICE(load)
+
+/* Checks validity of a magic database file */
+RB_MAGIC_APPRENTICE(check)
+
+/* Compiles a magic database file */
+RB_MAGIC_APPRENTICE(compile)
+
+void
+Init_ruby_filemagic() {
+  char version[8] = "0";
+  cFileMagic = rb_define_class("FileMagic", rb_cObject);
+
+#if defined(FILE_VERSION_MAJOR)
+  RB_MAGIC_SET_VERSION(FILE_VERSION_MAJOR, patchlevel)
+#elif defined(MAGIC_VERSION)
+  RB_MAGIC_SET_VERSION(MAGIC_VERSION / 100, MAGIC_VERSION % 100)
+#endif
+
+  rb_define_const(cFileMagic, "MAGIC_VERSION", rb_str_new2(version));
+
+  rb_define_singleton_method(cFileMagic, "path",  rb_magic_getpath,  0);
+  rb_define_singleton_method(cFileMagic, "flags", rb_magic_flags,    1);
+  rb_define_singleton_method(cFileMagic, "new",   rb_magic_new,     -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, "list",       rb_magic_list,     -1);
+  rb_define_method(cFileMagic, "load",       rb_magic_load,     -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
+  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_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
+  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_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_ENCODING
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_ENCODING", INT2FIX(MAGIC_NO_CHECK_ENCODING));
+#endif
+#if defined(MAGIC_NO_CHECK_BUILTIN) && MAGIC_VERSION > 514
+  /* defined in b5be901 (2010-01-28, 5.05), but broken until 38e0136 (2013-08-15, 5.15) */
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_BUILTIN",  INT2FIX(MAGIC_NO_CHECK_BUILTIN));
+#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
+#ifdef MAGIC_NO_CHECK_TROFF
+  rb_define_const(cFileMagic, "MAGIC_NO_CHECK_TROFF",    INT2FIX(MAGIC_NO_CHECK_TROFF));
+#endif
+}

data/ext/filemagic/filemagic.h

@@ -0,0 +1,98 @@
+#ifndef FILEMAGIC_H
+#define FILEMAGIC_H
+
+#include "ruby.h"
+#include <math.h>
+#include <errno.h>
+#include <magic.h>
+#ifdef HAVE_FILE_PATCHLEVEL_H
+#include <file/patchlevel.h>
+#endif
+
+#define GetMagicSet(obj, ms) {\
+  if (RTEST(rb_magic_closed_p(obj))) {\
+    rb_raise(rb_eRuntimeError, "closed stream");\
+  }\
+  else {\
+    Data_Get_Struct((obj), struct magic_set, (ms));\
+  }\
+}
+
+#define RB_MAGIC_TYPE_FILE   magic_file(ms, str)
+#define RB_MAGIC_TYPE_BUFFER magic_buffer(ms, str, RSTRING_LEN(arg))
+
+#define RB_MAGIC_TYPE(what, WHAT) \
+static VALUE \
+rb_magic_##what(int argc, VALUE *argv, VALUE self) {\
+  VALUE arg, simple, res;\
+  const char *str, *type;\
+  magic_t ms;\
+\
+  rb_scan_args(argc, argv, "11", &arg, &simple);\
+\
+  str = StringValuePtr(arg);\
+  GetMagicSet(self, ms);\
+\
+  if ((type = RB_MAGIC_TYPE_##WHAT) == NULL) {\
+    rb_raise(rb_FileMagicError, "failed lookup: %s", magic_error(ms));\
+  }\
+\
+  res = rb_str_new2(type);\
+\
+  if (NIL_P(simple)) {\
+    simple = rb_attr_get(self, rb_intern("@simplified"));\
+  }\
+\
+  if (RTEST(simple)) {\
+    rb_funcall(res, rb_intern("downcase!"), 0);\
+\
+    return rb_funcall(res, rb_intern("slice"), 2,\
+      rb_const_get(cFileMagic, rb_intern("SIMPLE_RE")), INT2FIX(1));\
+  }\
+  else {\
+    return res;\
+  }\
+}
+
+#define RB_MAGIC_APPRENTICE(what) \
+static VALUE \
+rb_magic_##what(int argc, VALUE *argv, VALUE self) {\
+  VALUE str;\
+  const char *file;\
+  magic_t ms;\
+\
+  file = rb_scan_args(argc, argv, "01", &str) == 1 ? StringValuePtr(str) : NULL;\
+\
+  GetMagicSet(self, ms);\
+\
+  return magic_##what(ms, file) ? Qfalse : Qtrue;\
+}
+
+#define RB_MAGIC_SET_VERSION(m, p) sprintf(version, "%d.%02d", m, p);
+
+static VALUE cFileMagic, rb_FileMagicError;
+
+static VALUE rb_magic_getpath(VALUE);
+static VALUE rb_magic_flags(VALUE, VALUE);
+
+static VALUE rb_magic_new(int, VALUE*, VALUE);
+static void rb_magic_free(magic_t);
+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_list(int, VALUE*, VALUE);
+static VALUE rb_magic_load(int, VALUE*, VALUE);
+static VALUE rb_magic_check(int, VALUE*, VALUE);
+static VALUE rb_magic_compile(int, VALUE*, VALUE);
+
+void Init_ruby_filemagic(void);
+
+#endif /* FILEMAGIC_H */