mahoro 0.2 → 0.3

data/magic.sample

@@ -0,0 +1,5 @@
+# Ruby scripts
+0	search/1/b	#!\ /usr/bin/ruby	Ruby script text executable
+0	search/1/b	#!\ /usr/local/bin/ruby	Ruby script text executable
+0	search/1	#!/usr/bin/env\ ruby	Ruby script text executable
+0	search/1	#!\ /usr/bin/env\ ruby	Ruby script text executable

data/mahoro.c

@@ -8,21 +8,19 @@
 #ifndef RSTRING_LEN
 #  define RSTRING_LEN(s)->len
 #endif
-
-struct MagicCookie
-{
-	magic_t cookie;
-};
+#ifndef RSTRING_PTR
+#  define RSTRING_PTR(s)->ptr
+#endif
 
 static VALUE cMahoro;
 static VALUE eMahoroError;
 
 static void
 mahoro_free(ptr)
-	struct MagicCookie *ptr;
+	void *ptr;
 {
-	magic_close(ptr->cookie);
-	xfree(ptr);
+	if (ptr)
+		magic_close((magic_t)ptr);
 }
 
 static VALUE
@@ -39,14 +37,13 @@ mahoro_initialize(argc, 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);
+				path = StringValueCStr(vpath);
 			}
 			/* fallthrough */
 		case 1:
@@ -63,9 +60,7 @@ mahoro_initialize(argc, argv, self)
 		                      magic_error(cookie));
 	}
 
-	ptr = ALLOC(struct MagicCookie);
-	ptr->cookie = cookie;
-	DATA_PTR(self) = ptr;
+	DATA_PTR(self) = cookie;
 
 	return self;
 }
@@ -75,9 +70,9 @@ mahoro_file(self, path)
 	VALUE self, path;
 {
 	const char *msg;
-	magic_t cookie = ((struct MagicCookie *) DATA_PTR(self))->cookie;
+	magic_t cookie = (magic_t)DATA_PTR(self);
 
-	if(!(msg = magic_file(cookie, StringValuePtr(path)))) {
+	if(!(msg = magic_file(cookie, StringValueCStr(path)))) {
 		rb_raise(eMahoroError, "failed lookup: %s", magic_error(cookie));
 	}
 
@@ -89,10 +84,12 @@ mahoro_buffer(self, input)
 	VALUE self, input;
 {
 	const char *msg;
-	magic_t cookie = ((struct MagicCookie *) DATA_PTR(self))->cookie;
+	magic_t cookie = (magic_t)DATA_PTR(self);
+
+	StringValue(input);
 
-	if(!(msg = magic_buffer(cookie, StringValuePtr(input),
-	                                RSTRING_LEN(StringValue(input))))) {
+	if(!(msg = magic_buffer(cookie, RSTRING_PTR(input),
+	                                RSTRING_LEN(input)))) {
 		rb_raise(eMahoroError, "failed lookup: %s", magic_error(cookie));
 	}
 
@@ -103,7 +100,7 @@ static VALUE
 mahoro_set_flags(self, flags)
 	VALUE self, flags;
 {
-	magic_t cookie = ((struct MagicCookie *) DATA_PTR(self))->cookie;
+	magic_t cookie = (magic_t)DATA_PTR(self);
 
 	return INT2FIX(magic_setflags(cookie, FIX2INT(flags)));
 }
@@ -115,12 +112,12 @@ mahoro_check(argc, argv, self)
 {
 	char *path = 0;
 	VALUE vpath;
-	magic_t cookie = ((struct MagicCookie *) DATA_PTR(self))->cookie;
+	magic_t cookie = (magic_t)DATA_PTR(self);
 
 	switch(rb_scan_args(argc, argv, "01", &vpath)) {
 		case 1:
-			if(!NIL_P(vpath)) { 
-				path = StringValuePtr(vpath);
+			if(!NIL_P(vpath)) {
+				path = StringValueCStr(vpath);
 			}
 			break;
 	}
@@ -133,27 +130,34 @@ mahoro_check(argc, argv, self)
 }
 
 static VALUE
-mahoro_compile(klass, path)
-	VALUE klass, path;
+mahoro_compile(self, path)
+	VALUE self, path;
 {
-	magic_t cookie = magic_open(MAGIC_NONE);
+	magic_t cookie = (magic_t)DATA_PTR(self);
 
-	if(magic_compile(cookie, StringValuePtr(path))) {
+	if(magic_compile(cookie, StringValueCStr(path))) {
 		rb_raise(eMahoroError, "failed compile: %s", magic_error(cookie));
 	}
 
-	magic_close(cookie);
-
 	return Qtrue;
 }
 
+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);
+}
+
 static VALUE
 mahoro_load(self, path)
 	VALUE self, path;
 {
-	magic_t cookie = ((struct MagicCookie *) DATA_PTR(self))->cookie;
+	magic_t cookie = (magic_t)DATA_PTR(self);
 
-	if(magic_load(cookie, StringValuePtr(path))) {
+	if(magic_load(cookie, StringValueCStr(path))) {
 		rb_raise(eMahoroError, "failed load: %s", magic_error(cookie));
 	}
 
@@ -165,18 +169,142 @@ 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"),
+	/* 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));
-	rb_const_set(cMahoro, rb_intern("RAW"), INT2FIX(MAGIC_RAW));
-	rb_const_set(cMahoro, rb_intern("ERROR"), INT2FIX(MAGIC_ERROR));
+
+	/*
+	 * 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);
@@ -184,7 +312,8 @@ void Init_mahoro(void)
 	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_singleton_method(cMahoro, "compile", mahoro_s_compile, 1);
+	rb_define_method(cMahoro, "compile", mahoro_compile, 1);
 	rb_define_method(cMahoro, "load", mahoro_load, 1);
 }
 

data/test.rb

@@ -22,12 +22,27 @@ class MahoroTestCase < Test::Unit::TestCase
 		}.include?(@m.file('mahoro.c')))
 	end
 
+	def test_null_byte_in_path
+		assert_raises(ArgumentError) { @m.file("mahoro.c\0foo") }
+	end
+
 	def test_buffer
 		@m.flags = Mahoro::NONE
 		assert_equal('ASCII C program text',
 		             @m.buffer(File.read('mahoro.c')))
 	end
 
+	def test_buffer_string_convert
+		tmp = File.read('mahoro.c')
+		buf = Struct.new(:to_str).new(tmp)
+		assert_equal('ASCII C program text', @m.buffer(buf))
+	end
+
+	def test_buffer_invalid
+		@m.flags = Mahoro::NONE
+		assert_raises(TypeError) { @m.buffer @m }
+	end
+
 	def test_mime_buffer
 		@m.flags = Mahoro::MIME
 		assert({
@@ -40,6 +55,25 @@ class MahoroTestCase < Test::Unit::TestCase
 		assert(@m.valid?, 'Default database was not valid.')
 	end
 
+	def test_valid_with_null
+		assert_raises(ArgumentError) { @m.valid? "mahoro.c\0" }
+	end
+
+	def test_compile
+		File.open(__FILE__) do |fp|
+			fp.flock File::LOCK_EX
+			assert Mahoro.compile("magic.sample")
+			assert_nothing_raised do
+				File.unlink("magic.sample.mgc")
+			end
+		end
+	end
+
+	def test_compile_bad
+		assert_raises(ArgumentError) do
+			Mahoro.compile "magic.sample\0"
+		end
+	end
 end
 
 # arch-tag: test

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: mahoro
 version: !ruby/object:Gem::Version 
-  hash: 15
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  version: "0.2"
+  prerelease: 
+  version: "0.3"
 platform: ruby
 authors: 
 - Shu-yu Guo
@@ -15,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-31 00:00:00 +00:00
+date: 2011-03-15 00:00:00 +00:00
 default_executable: 
 dependencies: []
 
@@ -36,6 +32,7 @@ extra_rdoc_files: []
 files: 
 - INSTALL
 - extconf.rb
+- magic.sample
 - mahoro.c
 - mahoro.gemspec
 - maintainership-transfer.mbox.gz
@@ -54,23 +51,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: mahoro
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: An interface to libmagic