mahoro 0.3 → 0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8e34a0f3eb2e9f8f9cebd7e149fc91188fe75cd8
+  data.tar.gz: b47106cf51c0f7aedab8a471c292f90684a301e0
+SHA512:
+  metadata.gz: d64e5576704b93552e4f89b2712ae9890862df5e3ed479ecd8d3d2906765e2db263e1ca7f2f85e563043550b4aacaad98013240498b60cf6d2f977ba8448b48b
+  data.tar.gz: d3a9f511611377d7561751d317a015a9ad964245731d15ea130453db0ac2143c90fe4db68a1652d0cb222b0d0a91927f6a7657fa0038e1c71341c9e5bd5a8aa4

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+*.log
+*.o
+*.so
+Makefile
+/doc
+/.ri
+*.tar.gz

data/GNUmakefile

@@ -0,0 +1,63 @@
+# maintainer jobs here, not needed for normal users
+all::
+
+.ri/created.rid: ext/mahoro/mahoro.c lib/mahoro/thread_safe.rb
+	rdoc --ri -o $(@D) $^
+
+order =
+order += Mahoro
+order += Mahoro.new
+order += Mahoro\#file
+order += Mahoro\#buffer
+order += Mahoro\#flags=
+order += Mahoro\#valid?
+order += Mahoro\#compile
+order += Mahoro.compile
+order += Mahoro::ThreadSafe
+
+www/API: .ri/created.rid
+	( \
+		for i in $(order); \
+		do \
+			ri --no-standard-docs -T -d .ri -w 80 "$$i" \
+				| col -b \
+				| grep -vF $(CURDIR)/.ri; \
+		done \
+	) > $@
+
+www/API.gz: www/API
+	gzip < $< > $@
+	touch -r $< $@
+
+www/README.gz: README
+	install -p -m 644 README www/
+	gzip < $< > $@
+	touch -r $< $@
+
+all:: www/API.gz www/README.gz
+clean:
+	$(RM) www/*
+
+ifneq ($(VERSION),)
+gem := mahoro-$(VERSION).gem
+$(gem): $(shell git ls-files)
+	VERSION=$(VERSION) gem build mahoro.gemspec
+
+tgz := mahoro-$(VERSION).tar.gz
+$(tgz): $(shell git ls-files)
+	git archive --format=tar --prefix=mahoro-$(VERSION)/ HEAD | \
+	  gzip -9 > $@
+else
+gem tgz:
+	@echo >&2 error VERSION not defined
+	@false
+endif
+
+package: $(gem) $(tgz)
+
+RSYNC = rsync
+publish_doc: all
+	$(RSYNC) --delete --exclude .gitignore -av \
+		www/ dcvr:/srv/bogomips/mahoro/
+
+.PHONY: publish_doc package

data/INSTALL

@@ -1,5 +1,27 @@
- INSTALL
-=========
+libmagic installation
+=====================
+
+Mahoro is a wrapper around libmagic[1], so it needs the libmagic
+development headers and libraries to run.  If your operating system
+provides libmagic development libraries and headers, you will not need
+the "--with-magic*" command-line options below.
+
+For Debian-based systems: apt-get install libmagic-dev
+For CentOS 6.x or similar RPM-based systems: yum install file-devel
+For CentOS 5.x or similar RPM-based systems: yum install file
+
+[1] - https://en.wikipedia.org/wiki/Libmagic
+
+INSTALL (from RubyGems)
+=======================
+
+The installation is simple, install libmagic and type the following:
+
+# gem install mahoro -- --with-magic-include=/path/to/include \
+                        --with-magic-lib=/path/to/lib
+
+INSTALL (from tarball)
+======================
 
 The installation is simple, install libmagic and type the following.
 

data/README

@@ -0,0 +1,16 @@
+Mahoro - a Ruby interface to libmagic
+
+An interface to libmagic to determine file types using "magic" numbers.
+This can be used in place of calling the file(1) command in Ruby scripts.
+Shu-yu Guo is the original author but all maintenance is handled by
+Eric Wong nowadays.
+
+documentation: http://bogomips.org/mahoro/API
+source: git clone git://bogomips.org/mahoro.git
+cgit web viewer: http://bogomips.org/mahoro.git/
+mailing list: mahoro@librelist.org (plain-text only, please)
+maintainer: Eric Wong <normalperson@yhbt.net>
+libmagic: https://en.wikipedia.org/wiki/Libmagic
+
+Feel free to contact Eric Wong privately via plain-text email if you're not
+comfortable with the public mailing list.

data/{extconf.rb → ext/mahoro/extconf.rb}

@@ -2,6 +2,8 @@ require 'mkmf'
 
 dir_config('magic')
 have_library('magic', 'magic_open')
+have_func('rb_thread_call_without_gvl')
+have_func('rb_thread_blocking_region')
 create_makefile('mahoro')
 
 # arch-tag: extconf

data/ext/mahoro/mahoro.c

@@ -0,0 +1,565 @@
+/*
+ * This file is Public Domain.
+ *
+ * Note: The current maintainer (Eric Wong) respects and preserves the
+ * original coding style of the original author (Shu-yu Guo) in case
+ * he ever chooses to return to this project.
+ */
+
+#include <ruby.h>
+#include <magic.h>
+#include "nogvl_compat.h"
+
+#ifndef RSTRING_LEN
+#  define RSTRING_LEN(s)->len
+#endif
+#ifndef RSTRING_PTR
+#  define RSTRING_PTR(s)->ptr
+#endif
+
+static VALUE eMahoroError;
+static ID id_to_path;
+
+struct nogvl_args {
+	magic_t cookie;
+	union {
+		const char *path;
+		int fd;
+	} as;
+};
+
+/* :nodoc: called automatically by GC */
+static void
+mahoro_free(ptr)
+	void *ptr;
+{
+	if (ptr)
+		magic_close((magic_t)ptr);
+}
+
+/* :nodoc: called automatically on Mahoro#initialize */
+static VALUE
+mahoro_allocate(klass)
+	VALUE klass;
+{
+	return Data_Wrap_Struct(klass, 0, mahoro_free, 0);
+}
+
+static void *
+nogvl_load(ptr)
+	void *ptr;
+{
+	struct nogvl_args *args = ptr;
+
+	return magic_load(args->cookie, args->as.path) ? ptr : NULL;
+}
+
+/*
+ * call-seq:
+ *	Mahoro.new(flags = Mahoro::NONE, path = nil)	->	mahoro_obj
+ *
+ * Create and initialize a new Mahoro object.
+ * +flags+ may be one or more of any combination of the Mahoro:: constants
+ * supported by Mahoro#flags=.
+ * +path+ (if not nil) is a colon-separated list of database files, see
+ * Mahoro#load.
+ *
+ * If +path+ is not given (or nil), the default database is used.
+ * Consult your libmagic(3) documentation for the location of that file
+ * as it varies by installation.
+ */
+static VALUE
+mahoro_initialize(argc, argv, self)
+	int argc;
+	VALUE *argv, self;
+{
+	int flags = MAGIC_NONE;
+	struct nogvl_args args;
+	VALUE vpath, vflags;
+
+	args.as.path = NULL;
+
+	switch(rb_scan_args(argc, argv, "02", &vflags, &vpath)) {
+		case 2:
+			if(!NIL_P(vpath)) {
+				args.as.path = StringValueCStr(vpath);
+			}
+			/* fallthrough */
+		case 1:
+			flags = FIX2INT(vflags);
+			break;
+	}
+
+	if(!(args.cookie = magic_open(flags))) {
+		rb_raise(eMahoroError, "failed to initialize magic cookie");
+	}
+
+	if(NOGVL(nogvl_load, &args, RUBY_UBF_IO, NULL)) {
+		rb_raise(eMahoroError, "failed to load database: %s",
+				      magic_error(args.cookie));
+	}
+
+	DATA_PTR(self) = args.cookie;
+
+	return self;
+}
+
+static void *
+nogvl_file(ptr)
+	void *ptr;
+{
+	struct nogvl_args *args = ptr;
+
+	return (void *)magic_file(args->cookie, args->as.path);
+}
+
+/*
+ * call-seq:
+ *	mahoro_obj.file(filename)	->	String
+ *
+ * Returns a textual description of the contents of the +filename+ given.
+ * Use Mahoro#buffer instead of this method if the contents of your
+ * file is already in memory.
+ * Raises Mahoro::Error on failed lookups.
+ */
+static VALUE
+mahoro_file(self, path)
+	VALUE self, path;
+{
+	const char *msg;
+	struct nogvl_args args;
+
+	args.cookie = (magic_t)DATA_PTR(self);
+
+	/* Pathname objects may be transformed via #to_path */
+	if (rb_respond_to(path, id_to_path))
+		path = rb_funcall(path, id_to_path, 0);
+
+	args.as.path = StringValueCStr(path);
+
+	if(!(msg = NOGVL(nogvl_file, &args, RUBY_UBF_IO, NULL))) {
+		rb_raise(eMahoroError, "failed lookup: %s",
+			magic_error(args.cookie));
+	}
+
+	return rb_str_new2(msg);
+}
+
+/*
+ * call-seq:
+ *	mahoro_obj.buffer(buffer)	->	String
+ *
+ * Returns a textual description of the contents of the +buffer+ given.
+ * +buffer+ should be a String object.
+ * Use Mahoro#file instead of this method if the contents is not already
+ * in memory (and possibly too large to fit into memory).
+ * Raises Mahoro::Error on failed lookups.
+ */
+static VALUE
+mahoro_buffer(self, input)
+	VALUE self, input;
+{
+	const char *msg;
+	magic_t cookie = (magic_t)DATA_PTR(self);
+
+	StringValue(input);
+
+	if(!(msg = magic_buffer(cookie, RSTRING_PTR(input),
+	                                RSTRING_LEN(input)))) {
+		rb_raise(eMahoroError, "failed lookup: %s", magic_error(cookie));
+	}
+
+	return rb_str_new2(msg);
+}
+
+/*
+ * call-seq:
+ *	mahoro_obj.flags = flags
+ *
+ * Change the behavior of an already-initialized Mahoro object.  The
+ * behavior of a Mahoro object is specified at load time, but may be
+ * changed after-the-fact.
+ * +flags+ is a bitwise (OR) mask of one or more of the following constants
+ * in the Mahoro namespace:
+ *
+ * - APPLE
+ * - CHECK
+ * - COMPRESS
+ * - CONTINUE
+ * - DEBUG
+ * - DEVICES
+ * - ERROR
+ * - MIME
+ * - MIME_ENCODING
+ * - MIME_TYPE
+ * - NONE
+ * - NO_CHECK_APPTYPE
+ * - NO_CHECK_COMPRESS
+ * - NO_CHECK_ELF
+ * - NO_CHECK_ENCODING
+ * - NO_CHECK_SOFT
+ * - NO_CHECK_TAR
+ * - NO_CHECK_TEXT
+ * - NO_CHECK_TOKENS
+ * - PRESERVE_ATIME
+ * - RAW
+ * - SYMLINK
+ */
+static VALUE
+mahoro_set_flags(self, flags)
+	VALUE self, flags;
+{
+	magic_t cookie = (magic_t)DATA_PTR(self);
+
+	return INT2FIX(magic_setflags(cookie, FIX2INT(flags)));
+}
+
+static void *
+nogvl_check(ptr)
+	void *ptr;
+{
+	struct nogvl_args *args = ptr;
+
+	return magic_check(args->cookie, args->as.path) ? ptr : NULL;
+}
+
+/*
+ * call-seq:
+ *	mahoro_obj.check(path = nil)	->	true or false
+ *
+ * This is used to check the validity of entries in the colon separated
+ * database files passed in as +path+.  If +path+ is not passed (or nil),
+ * this will check the default database.
+ */
+static VALUE
+mahoro_check(argc, argv, self)
+	int argc;
+	VALUE *argv, self;
+{
+	struct nogvl_args args;
+	VALUE vpath;
+
+	args.cookie = (magic_t)DATA_PTR(self);
+	args.as.path = NULL;
+
+	switch(rb_scan_args(argc, argv, "01", &vpath)) {
+		case 1:
+			if(!NIL_P(vpath)) {
+				args.as.path = StringValueCStr(vpath);
+			}
+			break;
+	}
+
+	if(!NOGVL(nogvl_check, &args, RUBY_UBF_IO, 0)) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+static void *
+nogvl_compile(ptr)
+	void *ptr;
+{
+	struct nogvl_args *args = ptr;
+
+	return magic_compile(args->cookie, args->as.path) ? ptr : NULL;
+}
+
+/*
+ * call-seq:
+ *	mahoro_obj.compile(path)	->	true
+ *
+ * Compile the the colon separated list of database files passed in as +path+.
+ * It returns true on success and raises Mahoro::Error on failure.
+ * Compiled files created are named from the +File.basename+ of each file
+ * argument with ".mgc" appended to it.
+ *
+ * There is no need to use this function if you are using the default magic(5)
+ * database on your operating system.  This is only needed if you require
+ * additional magic not in the default magic database.
+ *
+ * Users of this method are likely to need Mahoro#load (and vice-versa).
+ */
+static VALUE
+mahoro_compile(self, path)
+	VALUE self, path;
+{
+	struct nogvl_args args;
+
+	args.cookie = (magic_t)DATA_PTR(self);
+	args.as.path = StringValueCStr(path);
+
+	if(NOGVL(nogvl_compile, &args, RUBY_UBF_IO, NULL)) {
+		rb_raise(eMahoroError, "failed compile: %s",
+			magic_error(args.cookie));
+	}
+
+	return Qtrue;
+}
+
+/*
+ * call-seq:
+ *	Mahoro.compile(path)	->	true
+ *
+ * This is a wrapper around the Mahoro#compile instance method, but does not
+ * require an existing Mahoro object.  Use the instance method unless you only
+ * need to test the validity of a magic(5) database.
+ */
+static VALUE
+mahoro_s_compile(klass, path)
+	VALUE klass, path;
+{
+	VALUE m = rb_funcall(klass, rb_intern("new"), 0, 0);
+
+	return mahoro_compile(m, path);
+}
+
+/*
+ * call-seq:
+ *	mahoro_obj.load(path)	->	mahoro_obj
+ *
+ * Used to load the the colon-separated list of database files (+path+).
+ * The ".mgc" suffix will be added to each filename where appropriate.
+ * This will raise Mahoro::Error on failure.
+ *
+ * There is no need to use this function if you are using the default magic(5)
+ * database on your operating system.  This is only needed if you require
+ * additional magic not in the default magic database.
+ *
+ * The default database file is named by the MAGIC environment variable.
+ * Consult your libmagic installation documentation for the location of
+ * your default database file name.
+ *
+ * Users of this method are likely to need Mahoro#compile (and vice-versa).
+ */
+static VALUE
+mahoro_load(self, path)
+	VALUE self, path;
+{
+	struct nogvl_args args;
+
+	args.cookie = (magic_t)DATA_PTR(self);
+	args.as.path = StringValueCStr(path);
+
+	if(NOGVL(nogvl_load, &args, RUBY_UBF_IO, NULL)) {
+		rb_raise(eMahoroError, "failed load: %s",
+			magic_error(args.cookie));
+	}
+
+	return self;
+}
+
+void Init_mahoro(void)
+{
+	VALUE cMahoro;
+	/*
+	 * Mahoro is a simple interface to libmagic.
+	 *
+	 * Common use cases:
+	 *
+	 *	# initialize a Mahoro object for reading MIME types
+	 *	mahoro_obj = Mahoro.new(Mahoro::MIME)
+	 *
+	 *	# get the MIME type of a file on disk
+	 *	# This is ideal for large files which you do not need to
+	 *	# read in their entirety.
+	 *	mahoro_obj.file('/path/to/file.c') -> 'text/x-c'
+	 *
+	 *	# get the MIME type of a string buffer
+	 *	# This is only ideal if you already have the buffer in
+	 *	# memory or intend to process it soon
+	 *	str = File.read('/path/to/file.c')
+	 *	mahoro_obj.buffer(str) -> 'text/x-c'
+	 *
+	 *	# switch the Mahoro object to return an ASCII description
+	 *	mahoro_obj.flags = Mahoro::NONE
+	 *
+	 *	# Similar to the above example, but the Mahoro object
+	 *	# now returns a textual	description
+	 *	mahoro_obj.file('/path/to/file.c') -> 'ASCII C program text'
+	 *
+	 *	# Similar to the above example, but the Mahoro object
+	 *	# now returns a textual	description
+	 *	str = File.read('/path/to/file.c')
+	 *	mahoro_obj.buffer(str) -> 'ASCII C program text'
+	 *
+	 * Mahoro is not thread-safe by default, see Mahoro::ThreadSafe for
+	 * making this module thread-safe.
+	 *
+	 * More information about libmagic:
+	 * https://en.wikipedia.org/wiki/Libmagic
+	 *
+	 * Source code is available via git:
+	 *	git clone git://bogomips.org/mahoro.git
+	 *
+	 * And viewable with a web browser via cgit:
+	 *	http://bogomips.org/mahoro.git
+	 *
+	 * Eric Wong is the current maintainer of Mahoro.
+	 * Plain-text comments, questions, bug reports, patches and
+	 * pull requests are all highly welcome on the public mailing list:
+	 * mahoro@librelist.org
+	 *
+	 * You may contact Eric privately at normalperson@yhbt.net
+	 *
+	 * Please generate patches using the "git format-patch" command.
+	 * Use of "git send-email" to send a patch is recommended.
+	 * For reviewed patches, you may also send a pull request formatted
+	 * using the "git request-pull" command.
+	 *
+	 * Do not expect Eric to read HTML email under any circumstances.
+	 */
+	cMahoro      = rb_define_class("Mahoro", rb_cObject);
+	eMahoroError = rb_define_class_under(cMahoro, "Error", rb_eStandardError);
+
+	/* No special handling, the default */
+	rb_define_const(cMahoro, "NONE", INT2FIX(MAGIC_NONE));
+
+	/* print debugging messages to stderr */
+	rb_define_const(cMahoro, "DEBUG", INT2FIX(MAGIC_DEBUG));
+
+	/* Follow symlinks */
+	rb_define_const(cMahoro, "SYMLINK", INT2FIX(MAGIC_SYMLINK));
+
+	/* Check inside compressed files */
+	rb_define_const(cMahoro, "COMPRESS", INT2FIX(MAGIC_COMPRESS));
+
+	/* Look at the contents of devices */
+	rb_define_const(cMahoro, "DEVICES", INT2FIX(MAGIC_DEVICES));
+
+#ifdef MAGIC_MIME_TYPE
+	/*
+	 * Return only the MIME type
+	 * This constant may not be defined on older systems.
+	 */
+	rb_define_const(cMahoro, "MIME_TYPE", INT2FIX(MAGIC_MIME_TYPE));
+#endif
+
+	/* Return all matches */
+	rb_define_const(cMahoro, "CONTINUE", INT2FIX(MAGIC_CONTINUE));
+
+	/*
+	 * Check the magic database for consistency and
+	 * print warnings to stderr
+	 */
+	rb_define_const(cMahoro, "CHECK", INT2FIX(MAGIC_CHECK));
+
+	/* preserve access time of files analyzed */
+	rb_define_const(cMahoro, "PRESERVE_ATIME",
+	                      INT2FIX(MAGIC_PRESERVE_ATIME));
+
+	/*
+	 * Don't translate unprintable characters to a \\ooo octal
+	 * representation
+	 */
+	rb_define_const(cMahoro, "RAW", INT2FIX(MAGIC_RAW));
+
+	/*
+	 * Treat operating system errors while trying to open files
+	 * and follow symlinks as real errors, instead of printing
+	 * them in the magic buffer.
+	 */
+	rb_define_const(cMahoro, "ERROR", INT2FIX(MAGIC_ERROR));
+
+#ifdef MAGIC_MIME_ENCODING
+	/*
+	 * Return a MIME encoding, instead of a textual description.
+	 * This constant may not be defined on older systems.
+	 */
+	rb_define_const(cMahoro, "MIME_ENCODING", INT2FIX(MAGIC_MIME_ENCODING));
+#endif
+
+	/* return both MIME type and encoding */
+	rb_define_const(cMahoro, "MIME", INT2FIX(MAGIC_MIME));
+
+#ifdef MAGIC_APPLE
+	/*
+	 * Return both Apple creator and type.
+	 * This constant may not be defined on older systems.
+	 */
+	rb_define_const(cMahoro, "APPLE", INT2FIX(MAGIC_APPLE));
+#endif
+
+#ifdef MAGIC_NO_CHECK_COMPRESS
+	/*
+	 * Don't check for or inside compressed files.
+	 * This constant may not be defined on older systems.
+	 */
+	rb_define_const(cMahoro, "NO_CHECK_COMPRESS",
+		        INT2FIX(MAGIC_NO_CHECK_COMPRESS));
+#endif
+
+#ifdef MAGIC_NO_CHECK_TAR
+	/*
+	 * Don't examine tar files.
+	 * This constant may not be defined on older systems.
+	 */
+	rb_define_const(cMahoro, "NO_CHECK_TAR", INT2FIX(MAGIC_NO_CHECK_TAR));
+#endif
+
+#ifdef MAGIC_NO_CHECK_SOFT
+	/*
+	 * Don't consult magic files.
+	 * This constant may not be defined on older systems.
+	 */
+	rb_define_const(cMahoro, "NO_CHECK_SOFT", INT2FIX(MAGIC_NO_CHECK_SOFT));
+#endif
+
+#ifdef MAGIC_NO_CHECK_APPTYPE
+	/*
+	 * Don't check application type (EMX only).
+	 * This constant may not be defined on older systems.
+	 */
+	rb_define_const(cMahoro, "NO_CHECK_APPTYPE",
+	                INT2FIX(MAGIC_NO_CHECK_APPTYPE));
+#endif
+
+#ifdef MAGIC_NO_CHECK_ELF
+	/*
+	 * Don't check for ELF details.
+	 * This constant may not be defined on older systems.
+	 */
+	rb_define_const(cMahoro, "NO_CHECK_ELF", INT2FIX(MAGIC_NO_CHECK_ELF));
+#endif
+
+#ifdef MAGIC_NO_CHECK_ASCII
+	/*
+	 * Don't check for various types of ASCII text files.
+	 * This constant may not be defined on older systems.
+	 */
+	rb_define_const(cMahoro, "NO_CHECK_TEXT",
+	                INT2FIX(MAGIC_NO_CHECK_ASCII));
+#endif
+
+#ifdef MAGIC_NO_CHECK_TOKENS
+	/*
+	 * Don't check for known tokens inside ASCII files.
+	 * This constant may not be defined on older systems.
+	 */
+	rb_define_const(cMahoro, "NO_CHECK_TOKENS",
+	                INT2FIX(MAGIC_NO_CHECK_TOKENS));
+#endif
+
+#ifdef MAGIC_NO_CHECK_ENCODING
+	/*
+	 * Don't check for text encodings.
+	 * This constant may not be defined on older systems.
+	 */
+	rb_define_const(cMahoro, "NO_CHECK_ENCODING",
+	                INT2FIX(MAGIC_NO_CHECK_ENCODING));
+#endif
+
+	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_s_compile, 1);
+	rb_define_method(cMahoro, "compile", mahoro_compile, 1);
+	rb_define_method(cMahoro, "load", mahoro_load, 1);
+	id_to_path = rb_intern("to_path");
+}
+
+/* arch-tag: mahoro */