libmagic_rb 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: add88dc48d3eda81cd55f1eafd163822b50452852b1f0ae0121b3de36e2f5588
-  data.tar.gz: 60b7af94ac6e809f16ae22b1c7aac8eb3eab68b4be76c2437217bc6da32be58a
+  metadata.gz: 3454c7cacca3a0bdadab38245dce9a2f972adbfb463c04fcc991ce1e811e374b
+  data.tar.gz: 4a370cbf2bdcc7be23d4d01db291999b9e2ce00a6e989c000a3d996130f32249
 SHA512:
-  metadata.gz: d694f12d7d3211dc40e0e1eedbac222bb232a529f5ac9a27fdc3a7f58f2c0238cebacff4ed4490931abc0fd46baee72aa84402863809b938fe9d65f9bf781c61
-  data.tar.gz: 8a2f6b16efe5644f66cbe45dab50b0ef671592fd0d586cd2a51edc09bdd0b993c903eed617f748567e50b1db4c6c02a36577af98b653fa9a1b5466f5c615ead2
+  metadata.gz: aa7b33034bc5b16974b895e261014327397086bdf7fdad9aad44f6c74e1f93f712f04976c8f297765b33f887447ef6cd8e04a420e6efa8baf6418c21d13a1525
+  data.tar.gz: 7291f521933719b1f2062c137f6b33697d6dde0a291ec330ebbcc68400b68c5019654802e60df049af7d0b74caf7b7ef46cfd6ff58eef5179d3f1be38d23811e

data/ext/libmagic/definitions.h

@@ -1,4 +1,4 @@
 #define RB_UNWRAP(cookie) \
-	magic_t *cookie ; \
-	TypedData_Get_Struct(self, magic_t, &fileType, cookie) ; \
-	if(!*cookie) rb_raise(rb_eFileClosedError, "Magic cookie already closed") ;
+	magic_t *cookie; \
+	TypedData_Get_Struct(self, magic_t, &fileType, cookie); \
+	if(!*cookie) rb_raise(rb_eFileClosedError, "Magic cookie already closed");

data/ext/libmagic/func.h

@@ -10,13 +10,13 @@
 	Returns self.
 */
 
-VALUE _closeGlobal_(volatile VALUE self) {
-	RB_UNWRAP(cookie) ;
+VALUE _closeGlobal_(VALUE self) {
+	RB_UNWRAP(cookie);
 
-	magic_close(*cookie) ;
-	*cookie = NULL ;
-	rb_ivar_set(self, rb_intern("@closed"), Qtrue) ;
-	return self ;
+	magic_close(*cookie);
+	*cookie = NULL;
+	rb_ivar_set(self, rb_intern("@closed"), Qtrue);
+	return self;
 }
 
 /*
@@ -36,24 +36,26 @@ VALUE _closeGlobal_(volatile VALUE self) {
 	Returns self.
 */
 
-VALUE _loadGlobal_(volatile VALUE self, volatile VALUE dbPath) {
-	char *databasePath = NULL ;
+VALUE _loadGlobal_(VALUE self, VALUE dbPath) {
+	char *databasePath = NULL;
 
 	if (RB_TYPE_P(dbPath, T_STRING)) {
-		databasePath = StringValuePtr(dbPath) ;
-		rb_iv_set(self, "@db", dbPath) ;
-	} else if(RB_TYPE_P(dbPath, T_STRING)) {
-		rb_iv_set(self, "@db", Qnil) ;
+		databasePath = StringValuePtr(dbPath);
+		rb_iv_set(self, "@db", dbPath);
 	}
 
 	// Check if the database is a valid file or not
 	// Raises ruby error which will return.
-	RB_UNWRAP(cookie) ;
+	RB_UNWRAP(cookie);
 
-	if(databasePath) magic_validate_db(*cookie, databasePath) ;
-	magic_load(*cookie, databasePath) ;
+	if(databasePath) magic_validate_db(*cookie, databasePath);
 
-	return self ;
+	if (magic_load(*cookie, databasePath) == -1) {
+		rb_raise(rb_eRuntimeError, "Failed to load magic database: %s", magic_error(*cookie));
+	}
+
+
+	return self;
 }
 
 /*
@@ -70,28 +72,31 @@ VALUE _loadGlobal_(volatile VALUE self, volatile VALUE dbPath) {
 		Returns String or nil.
 */
 
-VALUE _checkGlobal_(volatile VALUE self) {
-	RB_UNWRAP(cookie) ;
+VALUE _checkGlobal_(VALUE self) {
+	RB_UNWRAP(cookie);
 
 	// Database path
-	VALUE db = rb_iv_get(self, "@db") ;
+	VALUE db = rb_iv_get(self, "@db");
 
-	char *database = NULL ;
+	char *database = NULL;
 	if(RB_TYPE_P(db, T_STRING)) {
-		database = StringValuePtr(db) ;
+		database = StringValuePtr(db);
 	}
 
 	// File path
-	VALUE f = rb_iv_get(self, "@file") ;
-	char *file = StringValuePtr(f) ;
+	VALUE f = rb_iv_get(self, "@file");
+	char *file = StringValuePtr(f);
 
-	if(database) magic_validate_db(*cookie, database) ;
-	magic_load(*cookie, database) ;
+	if(database) magic_validate_db(*cookie, database);
 
-	fileReadable(file) ;
-	const char *mt = magic_file(*cookie, file) ;
+	if (magic_load(*cookie, database) == -1) {
+		rb_raise(rb_eRuntimeError, "Failed to load magic database: %s", magic_error(*cookie));
+	}
 
-	return mt ? rb_str_new_cstr(mt) : Qnil ;
+	fileReadable(file);
+	const char *mt = magic_file(*cookie, file);
+
+	return mt ? rb_str_new_cstr(mt) : Qnil;
 }
 
 /*
@@ -106,18 +111,18 @@ VALUE _checkGlobal_(volatile VALUE self) {
 		# => #<LibmagicRb:0x00005581018f35e0 @closed=true, @db=nil, @file="/usr/share/dict/words", @mode=1106>
 */
 
-VALUE _getParamGlobal_(volatile VALUE self, volatile VALUE param) {
+VALUE _getParamGlobal_(VALUE self, VALUE param) {
 	#if MAGIC_VERSION > 525
-		RB_UNWRAP(cookie) ;
+		RB_UNWRAP(cookie);
 
-		unsigned int _param = NUM2UINT(param) ;
-		unsigned long value ;
+		unsigned int _param = NUM2UINT(param);
+		unsigned long value;
 
-		int status = magic_getparam(*cookie, _param, &value) ;
-		if (status) return Qnil ;
-		return ULONG2NUM(value) ;
+		int status = magic_getparam(*cookie, _param, &value);
+		if (status) return Qnil;
+		return ULONG2NUM(value);
 	#else
-		return Qnil ;
+		return Qnil;
 	#endif
 }
 
@@ -142,22 +147,22 @@ VALUE _getParamGlobal_(volatile VALUE self, volatile VALUE param) {
 	Returns Integer or nil on failure.
 */
 
-VALUE _setParamGlobal_(volatile VALUE self, volatile VALUE param, volatile VALUE paramVal) {
+VALUE _setParamGlobal_(VALUE self, VALUE param, VALUE paramVal) {
 	#if MAGIC_VERSION > 525
-		unsigned int _param = NUM2UINT(param) ;
-		unsigned long _paramVal = NUM2ULONG(paramVal) ;
+		unsigned int _param = NUM2UINT(param);
+		unsigned long _paramVal = NUM2ULONG(paramVal);
 
-		RB_UNWRAP(cookie) ;
+		RB_UNWRAP(cookie);
 
-		unsigned long value ;
-		magic_setparam(*cookie, _param, &_paramVal) ;
+		unsigned long value;
+		magic_setparam(*cookie, _param, &_paramVal);
 
-		int status = magic_getparam(*cookie, _param, &value) ;
-		if (status) return Qnil ;
+		int status = magic_getparam(*cookie, _param, &value);
+		if (status) return Qnil;
 
-		return ULONG2NUM((int)value) ;
+		return ULONG2NUM((int)value);
 	#else
-		return Qnil ;
+		return Qnil;
 	#endif
 }
 
@@ -180,23 +185,26 @@ VALUE _setParamGlobal_(volatile VALUE self, volatile VALUE param, volatile VALUE
 	Returns either String or nil.
 */
 
-VALUE _bufferGlobal_(volatile VALUE self, volatile VALUE string) {
-	RB_UNWRAP(cookie) ;
+VALUE _bufferGlobal_(VALUE self, VALUE string) {
+	RB_UNWRAP(cookie);
 
-	VALUE db = rb_iv_get(self, "@db") ;
+	VALUE db = rb_iv_get(self, "@db");
 
-	char *database = NULL ;
+	char *database = NULL;
 	if(RB_TYPE_P(db, T_STRING)) {
-		database = StringValuePtr(db) ;
+		database = StringValuePtr(db);
 	}
 
-	if(database) magic_validate_db(*cookie, database) ;
-	magic_load(*cookie, database) ;
+	if(database) magic_validate_db(*cookie, database);
+
+	if (magic_load(*cookie, database) == -1) {
+		rb_raise(rb_eRuntimeError, "Failed to load magic database: %s", magic_error(*cookie));
+	}
 
-	char *buffer = StringValuePtr(string) ;
-	const char *buf = magic_buffer(*cookie, buffer, strlen(buffer)) ;
+	char *buffer = StringValuePtr(string);
+	const char *buf = magic_buffer(*cookie, buffer, strlen(buffer));
 
-	return buf ? rb_str_new_cstr(buf) : Qnil ;
+	return buf ? rb_str_new_cstr(buf) : Qnil;
 }
 
 /*
@@ -229,20 +237,20 @@ VALUE _bufferGlobal_(volatile VALUE self, volatile VALUE string) {
 		=> #<LibmagicRb:0x000055cf280a9b30 @closed=true, @db=nil, @file=".", @mode=1106>
 */
 
-VALUE _listGlobal_(volatile VALUE self) {
-	RB_UNWRAP(cookie) ;
+VALUE _listGlobal_(VALUE self) {
+	RB_UNWRAP(cookie);
 
-	VALUE db = rb_iv_get(self, "@db") ;
+	VALUE db = rb_iv_get(self, "@db");
 
-	char *database = NULL ;
+	char *database = NULL;
 	if (RB_TYPE_P(db, T_STRING)) {
-		database = StringValuePtr(db) ;
+		database = StringValuePtr(db);
 	}
 
-	if(database) magic_validate_db(*cookie, database) ;
-	int status = magic_list(*cookie, database) ;
+	if(database) magic_validate_db(*cookie, database);
+	int status = magic_list(*cookie, database);
 
-	return INT2FIX(status) ;
+	return INT2FIX(status);
 }
 
 /*
@@ -276,16 +284,16 @@ VALUE _listGlobal_(volatile VALUE self) {
 		# => #<LibmagicRb:0x00005583732e1070 @closed=true, @db=nil, @file=".", @mode=256>
 */
 
-VALUE _setflagsGlobal_(volatile VALUE self, volatile VALUE flags) {
-	unsigned int flag = NUM2UINT(flags) ;
+VALUE _setflagsGlobal_(VALUE self, VALUE flags) {
+	unsigned int flag = NUM2UINT(flags);
 
-	RB_UNWRAP(cookie) ;
-	int status = magic_setflags(*cookie, flag) ;
+	RB_UNWRAP(cookie);
+	int status = magic_setflags(*cookie, flag);
 
 	if (status) {
-		return Qnil ;
+		return Qnil;
 	} else {
-		rb_ivar_set(self, rb_intern("@mode"), flags) ;
-		return flags ;
+		rb_ivar_set(self, rb_intern("@mode"), flags);
+		return flags;
 	}
 }

data/ext/libmagic/magic.c

@@ -18,37 +18,35 @@
 /*
 * Errors
 */
-VALUE rb_eFileNotFoundError ;
-VALUE rb_eFileNotReadableError ;
-VALUE rb_eInvalidDBError ;
-VALUE rb_eIsDirError ;
-VALUE rb_eFileClosedError ;
+VALUE rb_eFileNotFoundError;
+VALUE rb_eFileNotReadableError;
+VALUE rb_eInvalidDBError;
+VALUE rb_eIsDirError;
+VALUE rb_eFileClosedError;
 
 // Garbage collect
-void file_free(void **data) {
-	if(*data) {
-		magic_close(*data) ;
-		*data = NULL ;
+void file_free(void *data) {
+	if(data) {
+		magic_close(*(void **)data);
+		*(void **)data = NULL;
 	}
 
-	free(data) ;
+	free(data);
 }
 
 // Filetype
 static rb_data_type_t fileType = {
 	.wrap_struct_name = "file",
-
 	.function = {
 		.dmark = NULL,
 		.dfree = file_free,
 	},
-
 	.data = NULL,
 
 	#ifdef RUBY_TYPED_FREE_IMMEDIATELY
 	.flags = RUBY_TYPED_FREE_IMMEDIATELY
 	#endif
-} ;
+};
 
 #include "validations.h"
 #include "func.h"
@@ -67,62 +65,69 @@ static rb_data_type_t fileType = {
 	`mode: LibmagicRb::MAGIC_CHECK | LibmagicRb::MAGIC_SYMLINK | Libmagic_MAGIC_MIME`
 	If `mode` key is nil, it will default to `MAGIC_MIME | MAGIC_CHECK | MAGIC_SYMLINK`
 */
-static VALUE _check_(volatile VALUE obj, volatile VALUE args) {
+static VALUE _check_(VALUE obj, VALUE args) {
 	if(!RB_TYPE_P(args, T_HASH)) {
-		rb_raise(rb_eArgError, "Expected hash as argument.") ;
+		rb_raise(rb_eArgError, "Expected hash as argument.");
 	}
 
 	// Database Path
-	VALUE argDBPath = rb_hash_aref(args, ID2SYM(rb_intern("db"))) ;
+	VALUE argDBPath = rb_hash_aref(args, ID2SYM(rb_intern("db")));
 
-	char *databasePath ;
-	if (RB_TYPE_P(argDBPath, T_NIL)) {
-		databasePath = NULL ;
-	} else if (!RB_TYPE_P(argDBPath, T_STRING)) {
-		rb_raise(rb_eArgError, "Database name must be an instance of String.") ;
-	} else {
-		databasePath = StringValuePtr(argDBPath) ;
+	char *databasePath = NULL;
+	if (!NIL_P(argDBPath)) {
+		if (!RB_TYPE_P(argDBPath, T_STRING)) {
+			rb_raise(rb_eArgError, "Database name must be an instance of String.");
+		}
+
+		databasePath = StringValuePtr(argDBPath);
 	}
 
 	// File path
-	VALUE argFilePath = rb_hash_aref(args, ID2SYM(rb_intern("file"))) ;
+	VALUE argFilePath = rb_hash_aref(args, ID2SYM(rb_intern("file")));
 	if (RB_TYPE_P(argFilePath, T_NIL)) {
-		rb_raise(rb_eArgError, "Expected `file:\" key as a string, got nil instead") ;
+		rb_raise(rb_eArgError, "Expected `file:\" key as a string, got nil instead");
 	} else if (!RB_TYPE_P(argFilePath, T_STRING)) {
-		rb_raise(rb_eArgError, "Filename must be an instance of String.") ;
+		rb_raise(rb_eArgError, "Filename must be an instance of String.");
 	}
-	char *checkPath = StringValuePtr(argFilePath) ;
+	char *checkPath = StringValuePtr(argFilePath);
 
 	// Modes
-	VALUE argModes = rb_hash_aref(args, ID2SYM(rb_intern("mode"))) ;
-	unsigned int modes ;
+	VALUE argModes = rb_hash_aref(args, ID2SYM(rb_intern("mode")));
+	unsigned int modes;
 	if(RB_TYPE_P(argModes, T_NIL)) {
-		modes = MAGIC_MIME | MAGIC_CHECK | MAGIC_SYMLINK ;
+		modes = MAGIC_MIME | MAGIC_CHECK | MAGIC_SYMLINK;
 	} else if (!RB_TYPE_P(argModes, T_FIXNUM)) {
-		rb_raise(rb_eArgError, "Modes must be an instance of Integer. Check LibmagicRb.constants() or LibmagicRb.lsmodes().") ;
+		rb_raise(rb_eArgError, "Modes must be an instance of Integer. Check LibmagicRb.constants() or LibmagicRb.lsmodes().");
 	} else {
-		modes = FIX2UINT(argModes) ;
+		modes = FIX2UINT(argModes);
 	}
 
 	// Checks
-	struct magic_set *magic = magic_open(modes) ;
+	struct magic_set *magic = magic_open(modes);
+
+	if (!magic) {
+		rb_raise(rb_eRuntimeError, "Failed to initialize magic cookie.");
+	}
 
 	// Check if the database is a valid file or not
 	// Raises ruby error which will return.
-	fileReadable(checkPath) ;
+	fileReadable(checkPath);
 
 	if(databasePath) {
-		magic_validate_db(magic, databasePath) ;
+		magic_validate_db(magic, databasePath);
 	}
 
-	magic_load(magic, databasePath) ;
+	if (magic_load(magic, databasePath) == -1) {
+		magic_close(magic);
+		rb_raise(rb_eInvalidDBError, "Failed to load magic database: %s", magic_error(magic));
+	}
 
-	const char *mt = magic_file(magic, checkPath) ;
+	const char *mt = magic_file(magic, checkPath);
 
-	VALUE retVal = mt ? rb_str_new_cstr(mt) : Qnil ;
-	magic_close(magic) ;
+	VALUE retVal = mt ? rb_str_new_cstr(mt) : Qnil;
+	magic_close(magic);
 
-	return retVal ;
+	return retVal;
 }
 
 /*
@@ -162,65 +167,70 @@ static VALUE _check_(volatile VALUE obj, volatile VALUE args) {
 	Flags/modes applied to cookie, will not affect cookie2 as well. Think of them as totally different containers.
 	Of course, you must close cookies when you don't need them. Otherwise it can use memories unless GC is triggered.
 */
-VALUE rb_libmagicRb_initialize(volatile VALUE self, volatile VALUE args) {
+VALUE rb_libmagicRb_initialize(VALUE self, VALUE args) {
 	// Database Path
 	if(!RB_TYPE_P(args, T_HASH)) {
-		rb_raise(rb_eArgError, "Expected hash as argument.") ;
+		rb_raise(rb_eArgError, "Expected hash as argument.");
 	}
 
-	VALUE argDBPath = rb_hash_aref(args, ID2SYM(rb_intern("db"))) ;
+	VALUE argDBPath = rb_hash_aref(args, ID2SYM(rb_intern("db")));
 
 	if (RB_TYPE_P(argDBPath, T_NIL)) {
-		rb_ivar_set(self, rb_intern("@db"), Qnil) ;
+		rb_ivar_set(self, rb_intern("@db"), Qnil);
 	} else if (!RB_TYPE_P(argDBPath, T_STRING)) {
-		rb_raise(rb_eArgError, "Database name must be an instance of String.") ;
+		rb_raise(rb_eArgError, "Database name must be an instance of String.");
 	} else {
-		rb_ivar_set(self, rb_intern("@db"), argDBPath) ;
+		rb_ivar_set(self, rb_intern("@db"), argDBPath);
 	}
 
 	// File path
-	VALUE argFilePath = rb_hash_aref(args, ID2SYM(rb_intern("file"))) ;
+	VALUE argFilePath = rb_hash_aref(args, ID2SYM(rb_intern("file")));
 	if (RB_TYPE_P(argFilePath, T_NIL)) {
-		rb_raise(rb_eArgError, "Expected `file:\" key as a string, got nil instead") ;
+		rb_raise(rb_eArgError, "Expected `file:\" key as a string, got nil instead");
 	} else if (!RB_TYPE_P(argFilePath, T_STRING)) {
-		rb_raise(rb_eArgError, "Filename must be an instance of String.") ;
+		rb_raise(rb_eArgError, "Filename must be an instance of String.");
 	}
-	rb_ivar_set(self, rb_intern("@file"), argFilePath) ;
+	rb_ivar_set(self, rb_intern("@file"), argFilePath);
 
 	// Modes
-	VALUE argModes = rb_hash_aref(args, ID2SYM(rb_intern("mode"))) ;
-	unsigned int modes ;
+	VALUE argModes = rb_hash_aref(args, ID2SYM(rb_intern("mode")));
+	unsigned int modes;
 	if(RB_TYPE_P(argModes, T_NIL)) {
-		modes = MAGIC_MIME | MAGIC_CHECK | MAGIC_SYMLINK ;
+		modes = MAGIC_MIME | MAGIC_CHECK | MAGIC_SYMLINK;
 	} else if (!RB_TYPE_P(argModes, T_FIXNUM)) {
-		rb_raise(rb_eArgError, "Modes must be an instance of Integer. Check LibmagicRb.constants() or LibmagicRb.lsmodes().") ;
+		rb_raise(rb_eArgError, "Modes must be an instance of Integer. Check LibmagicRb.constants() or LibmagicRb.lsmodes().");
 	} else {
-		modes = FIX2UINT(argModes) ;
+		modes = FIX2UINT(argModes);
 	}
-	rb_ivar_set(self, rb_intern("@mode"), UINT2NUM(modes)) ;
+	rb_ivar_set(self, rb_intern("@mode"), UINT2NUM(modes));
 
-	rb_ivar_set(self, rb_intern("@closed"), Qfalse) ;
+	rb_ivar_set(self, rb_intern("@closed"), Qfalse);
 
-	RB_UNWRAP(cookie) ;
-	magic_setflags(*cookie, modes) ;
+	RB_UNWRAP(cookie);
+	magic_setflags(*cookie, modes);
 
-	return self ;
+	return self;
 }
 
-VALUE initAlloc(volatile VALUE self) {
-	magic_t *cookie ;
-	cookie = malloc(sizeof(*cookie)) ;
-	*cookie = magic_open(0) ;
+VALUE initAlloc(VALUE self) {
+	magic_t *cookie;
+	cookie = malloc(sizeof(*cookie));
+
+	if (!cookie) {
+		rb_raise(rb_eNoMemError, "Failed to allocate memory for magic cookie.");
+	}
+
+	*cookie = magic_open(0);
 
-	return TypedData_Wrap_Struct(self, &fileType, cookie) ;
+	return TypedData_Wrap_Struct(self, &fileType, cookie);
 }
 
 void Init_main() {
-	rb_global_variable(&rb_eFileNotFoundError) ;
-	rb_global_variable(&rb_eFileNotReadableError) ;
-	rb_global_variable(&rb_eInvalidDBError) ;
-	rb_global_variable(&rb_eIsDirError) ;
-	rb_global_variable(&rb_eFileClosedError) ;
+	rb_global_variable(&rb_eFileNotFoundError);
+	rb_global_variable(&rb_eFileNotReadableError);
+	rb_global_variable(&rb_eInvalidDBError);
+	rb_global_variable(&rb_eIsDirError);
+	rb_global_variable(&rb_eFileClosedError);
 
 	/*
 	* Libmagic Errors
@@ -229,74 +239,74 @@ void Init_main() {
 	/*
 		Adds ability to check mime-type of a file using the libmagic (magic(4)). It uses native extensions and it's quite performant.
 	*/
-	VALUE cLibmagicRb = rb_define_class("LibmagicRb", rb_cObject) ;
+	VALUE cLibmagicRb = rb_define_class("LibmagicRb", rb_cObject);
 
-	rb_eFileNotFoundError = rb_define_class_under(cLibmagicRb, "FileNotFound", rb_eRuntimeError) ;
-	rb_eFileNotReadableError = rb_define_class_under(cLibmagicRb, "FileUnreadable", rb_eRuntimeError) ;
-	rb_eInvalidDBError = rb_define_class_under(cLibmagicRb, "InvalidDBError", rb_eRuntimeError) ;
-	rb_eIsDirError = rb_define_class_under(cLibmagicRb, "IsDirError", rb_eRuntimeError) ;
-	rb_eFileClosedError = rb_define_class_under(cLibmagicRb, "FileClosedError", rb_eRuntimeError) ;
+	rb_eFileNotFoundError = rb_define_class_under(cLibmagicRb, "FileNotFound", rb_eRuntimeError);
+	rb_eFileNotReadableError = rb_define_class_under(cLibmagicRb, "FileUnreadable", rb_eRuntimeError);
+	rb_eInvalidDBError = rb_define_class_under(cLibmagicRb, "InvalidDBError", rb_eRuntimeError);
+	rb_eIsDirError = rb_define_class_under(cLibmagicRb, "IsDirError", rb_eRuntimeError);
+	rb_eFileClosedError = rb_define_class_under(cLibmagicRb, "FileClosedError", rb_eRuntimeError);
 
 	/*
 	* Constants
 	*/
-	modes(cLibmagicRb) ;
-	params(cLibmagicRb) ;
+	modes(cLibmagicRb);
+	params(cLibmagicRb);
 
 
 	#if MAGIC_VERSION > 525
-		char version[6] ;
-		sprintf(version, "%0.2f", magic_version() / 100.0) ;
+		char version[6];
+		sprintf(version, "%0.2f", magic_version() / 100.0);
 
 		/*
 			LibmagicRb::MAGIC_VERSION returns the magic version of the library.
 			For older libmagic version, this can be undefined, so this method will return "0" instead.
 		*/
-		rb_define_const(cLibmagicRb, "MAGIC_VERSION", rb_str_new_cstr(version)) ;
+		rb_define_const(cLibmagicRb, "MAGIC_VERSION", rb_str_new_cstr(version));
 	#else
-		rb_define_const(cLibmagicRb, "MAGIC_VERSION", rb_str_new_cstr("0")) ;
+		rb_define_const(cLibmagicRb, "MAGIC_VERSION", rb_str_new_cstr("0"));
 	#endif
 
 	/*
 	* Singleton Methods
 	*/
-	rb_define_singleton_method(cLibmagicRb, "check", _check_, 1) ;
-	rb_define_singleton_method(cLibmagicRb, "lsmodes", lsmodes, 0) ;
-	rb_define_singleton_method(cLibmagicRb, "lsparams", lsparams, 0) ;
+	rb_define_singleton_method(cLibmagicRb, "check", _check_, 1);
+	rb_define_singleton_method(cLibmagicRb, "lsmodes", lsmodes, 0);
+	rb_define_singleton_method(cLibmagicRb, "lsparams", lsparams, 0);
 
 	/*
 	* Instance Methods
 	*/
-	rb_define_alloc_func(cLibmagicRb, initAlloc) ;
+	rb_define_alloc_func(cLibmagicRb, initAlloc);
 
 	// LibmagicRb.new()
-	rb_define_method(cLibmagicRb, "initialize", rb_libmagicRb_initialize, 1) ;
+	rb_define_method(cLibmagicRb, "initialize", rb_libmagicRb_initialize, 1);
 
 	// Attributes
-	rb_define_attr(cLibmagicRb, "closed", 1, 0) ;
-	rb_define_attr(cLibmagicRb, "mode", 1, 0) ;
-	rb_define_attr(cLibmagicRb, "file", 1, 1) ;
-	rb_define_attr(cLibmagicRb, "db", 1, 1) ;
+	rb_define_attr(cLibmagicRb, "closed", 1, 0);
+	rb_define_attr(cLibmagicRb, "mode", 1, 0);
+	rb_define_attr(cLibmagicRb, "file", 1, 1);
+	rb_define_attr(cLibmagicRb, "db", 1, 1);
 
 	// Close database
-	rb_define_method(cLibmagicRb, "close", _closeGlobal_, 0) ;
-	rb_define_alias(cLibmagicRb, "closed?", "closed") ;
+	rb_define_method(cLibmagicRb, "close", _closeGlobal_, 0);
+	rb_define_alias(cLibmagicRb, "closed?", "closed");
 
 	// Load database
-	rb_define_method(cLibmagicRb, "load", _loadGlobal_, 1) ;
+	rb_define_method(cLibmagicRb, "load", _loadGlobal_, 1);
 
 	// Check for file mimetype
-	rb_define_method(cLibmagicRb, "check", _checkGlobal_, 0) ;
+	rb_define_method(cLibmagicRb, "check", _checkGlobal_, 0);
 
 	// Get and set params
-	rb_define_method(cLibmagicRb, "getparam", _getParamGlobal_, 1) ;
-	rb_define_method(cLibmagicRb, "setparam", _setParamGlobal_, 2) ;
+	rb_define_method(cLibmagicRb, "getparam", _getParamGlobal_, 1);
+	rb_define_method(cLibmagicRb, "setparam", _setParamGlobal_, 2);
 
 	// Set modes dynamically
-	rb_define_method(cLibmagicRb, "setflags", _setflagsGlobal_, 1) ;
-	rb_define_method(cLibmagicRb, "mode=", _setflagsGlobal_, 1) ;
+	rb_define_method(cLibmagicRb, "setflags", _setflagsGlobal_, 1);
+	rb_define_method(cLibmagicRb, "mode=", _setflagsGlobal_, 1);
 
 	// Miscellaneous
-	rb_define_method(cLibmagicRb, "magic_buffer", _bufferGlobal_, 1) ;
-	rb_define_method(cLibmagicRb, "magic_list", _listGlobal_, 0) ;
+	rb_define_method(cLibmagicRb, "magic_buffer", _bufferGlobal_, 1);
+	rb_define_method(cLibmagicRb, "magic_list", _listGlobal_, 0);
 }

data/ext/libmagic/modes.h

@@ -1,142 +1,158 @@
 // In the older versions, there were some missing constants. Don't define them at compile time.
 
 void modes(volatile VALUE rb_klass) {
-	rb_define_const(rb_klass, "MAGIC_NONE", INT2FIX(MAGIC_NONE)) ;
-	rb_define_const(rb_klass, "MAGIC_DEBUG", INT2FIX(MAGIC_DEBUG)) ;
-	rb_define_const(rb_klass, "MAGIC_SYMLINK", INT2FIX(MAGIC_SYMLINK)) ;
-	rb_define_const(rb_klass, "MAGIC_COMPRESS", INT2FIX(MAGIC_COMPRESS)) ;
-	rb_define_const(rb_klass, "MAGIC_DEVICES", INT2FIX(MAGIC_DEVICES)) ;
-	rb_define_const(rb_klass, "MAGIC_MIME_TYPE", INT2FIX(MAGIC_MIME_TYPE)) ;
-	rb_define_const(rb_klass, "MAGIC_MIME_ENCODING", INT2FIX(MAGIC_MIME_ENCODING)) ;
-	rb_define_const(rb_klass, "MAGIC_MIME", INT2FIX(MAGIC_MIME)) ;
-	rb_define_const(rb_klass, "MAGIC_CONTINUE", INT2FIX(MAGIC_CONTINUE)) ;
-	rb_define_const(rb_klass, "MAGIC_CHECK", INT2FIX(MAGIC_CHECK)) ;
-	rb_define_const(rb_klass, "MAGIC_PRESERVE_ATIME", INT2FIX(MAGIC_PRESERVE_ATIME)) ;
-	rb_define_const(rb_klass, "MAGIC_RAW", INT2FIX(MAGIC_RAW)) ;
-	rb_define_const(rb_klass, "MAGIC_ERROR", INT2FIX(MAGIC_ERROR)) ;
-	rb_define_const(rb_klass, "MAGIC_APPLE", INT2FIX(MAGIC_APPLE)) ;
+	rb_define_const(rb_klass, "MAGIC_NONE", INT2FIX(MAGIC_NONE));
+	rb_define_const(rb_klass, "MAGIC_DEBUG", INT2FIX(MAGIC_DEBUG));
+	rb_define_const(rb_klass, "MAGIC_SYMLINK", INT2FIX(MAGIC_SYMLINK));
+	rb_define_const(rb_klass, "MAGIC_COMPRESS", INT2FIX(MAGIC_COMPRESS));
+	rb_define_const(rb_klass, "MAGIC_DEVICES", INT2FIX(MAGIC_DEVICES));
+	rb_define_const(rb_klass, "MAGIC_MIME_TYPE", INT2FIX(MAGIC_MIME_TYPE));
+	rb_define_const(rb_klass, "MAGIC_MIME_ENCODING", INT2FIX(MAGIC_MIME_ENCODING));
+	rb_define_const(rb_klass, "MAGIC_MIME", INT2FIX(MAGIC_MIME));
+	rb_define_const(rb_klass, "MAGIC_CONTINUE", INT2FIX(MAGIC_CONTINUE));
+	rb_define_const(rb_klass, "MAGIC_CHECK", INT2FIX(MAGIC_CHECK));
+	rb_define_const(rb_klass, "MAGIC_PRESERVE_ATIME", INT2FIX(MAGIC_PRESERVE_ATIME));
+	rb_define_const(rb_klass, "MAGIC_RAW", INT2FIX(MAGIC_RAW));
+	rb_define_const(rb_klass, "MAGIC_ERROR", INT2FIX(MAGIC_ERROR));
+	rb_define_const(rb_klass, "MAGIC_APPLE", INT2FIX(MAGIC_APPLE));
 
 	#ifdef MAGIC_EXTENSION
-	rb_define_const(rb_klass, "MAGIC_EXTENSION", INT2FIX(MAGIC_EXTENSION)) ;
+	rb_define_const(rb_klass, "MAGIC_EXTENSION", INT2FIX(MAGIC_EXTENSION));
 	#endif
 
 	#ifdef MAGIC_COMPRESS_TRANSP
-	rb_define_const(rb_klass, "MAGIC_COMPRESS_TRANSP", INT2FIX(MAGIC_COMPRESS_TRANSP)) ;
+	rb_define_const(rb_klass, "MAGIC_COMPRESS_TRANSP", INT2FIX(MAGIC_COMPRESS_TRANSP));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_APPTYPE
-	rb_define_const(rb_klass, "MAGIC_NO_CHECK_APPTYPE", INT2FIX(MAGIC_NO_CHECK_APPTYPE)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_APPTYPE", INT2FIX(MAGIC_NO_CHECK_APPTYPE));
+	#endif
+
+	#ifdef MAGIC_NO_COMPRESS_FORK
+	rb_define_const(rb_klass, "MAGIC_NO_COMPRESS_FORK", INT2FIX(MAGIC_NO_COMPRESS_FORK));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_CDF
-	rb_define_const(rb_klass, "MAGIC_NO_CHECK_CDF", INT2FIX(MAGIC_NO_CHECK_CDF)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_CDF", INT2FIX(MAGIC_NO_CHECK_CDF));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_COMPRESS
-	rb_define_const(rb_klass, "MAGIC_NO_CHECK_COMPRESS", INT2FIX(MAGIC_NO_CHECK_COMPRESS)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_COMPRESS", INT2FIX(MAGIC_NO_CHECK_COMPRESS));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_ELF
-	rb_define_const(rb_klass, "MAGIC_NO_CHECK_ELF", INT2FIX(MAGIC_NO_CHECK_ELF)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_ELF", INT2FIX(MAGIC_NO_CHECK_ELF));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_ENCODING
-	rb_define_const(rb_klass, "MAGIC_NO_CHECK_ENCODING", INT2FIX(MAGIC_NO_CHECK_ENCODING)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_ENCODING", INT2FIX(MAGIC_NO_CHECK_ENCODING));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_SOFT
-	rb_define_const(rb_klass, "MAGIC_NO_CHECK_SOFT", INT2FIX(MAGIC_NO_CHECK_SOFT)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_SOFT", INT2FIX(MAGIC_NO_CHECK_SOFT));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_TAR
-	rb_define_const(rb_klass, "MAGIC_NO_CHECK_TAR", INT2FIX(MAGIC_NO_CHECK_TAR)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_TAR", INT2FIX(MAGIC_NO_CHECK_TAR));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_TEXT
-	rb_define_const(rb_klass, "MAGIC_NO_CHECK_TEXT", INT2FIX(MAGIC_NO_CHECK_TEXT)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_TEXT", INT2FIX(MAGIC_NO_CHECK_TEXT));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_TOKENS
-	rb_define_const(rb_klass, "MAGIC_NO_CHECK_TOKENS", INT2FIX(MAGIC_NO_CHECK_TOKENS)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_TOKENS", INT2FIX(MAGIC_NO_CHECK_TOKENS));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_JSON
-	rb_define_const(rb_klass, "MAGIC_NO_CHECK_JSON", INT2FIX(MAGIC_NO_CHECK_JSON)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_JSON", INT2FIX(MAGIC_NO_CHECK_JSON));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_CSV
-	rb_define_const(rb_klass, "MAGIC_NO_CHECK_CSV", INT2FIX(MAGIC_NO_CHECK_CSV)) ;
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_CSV", INT2FIX(MAGIC_NO_CHECK_CSV));
+	#endif
+
+	#ifdef MAGIC_NO_CHECK_SIMH
+	rb_define_const(rb_klass, "MAGIC_NO_CHECK_SIMH", INT2FIX(MAGIC_NO_CHECK_SIMH));
 	#endif
 }
 
 VALUE lsmodes(volatile VALUE obj) {
-	VALUE hash = rb_hash_new() ;
-
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NONE")), INT2FIX(MAGIC_NONE)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_DEBUG")), INT2FIX(MAGIC_DEBUG)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_SYMLINK")), INT2FIX(MAGIC_SYMLINK)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_COMPRESS")), INT2FIX(MAGIC_COMPRESS)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_DEVICES")), INT2FIX(MAGIC_DEVICES)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_MIME_TYPE")), INT2FIX(MAGIC_MIME_TYPE)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_MIME_ENCODING")), INT2FIX(MAGIC_MIME_ENCODING)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_MIME")), INT2FIX(MAGIC_MIME)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_CONTINUE")), INT2FIX(MAGIC_CONTINUE)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_CHECK")), INT2FIX(MAGIC_CHECK)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PRESERVE_ATIME")), INT2FIX(MAGIC_PRESERVE_ATIME)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_RAW")), INT2FIX(MAGIC_RAW)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_ERROR")), INT2FIX(MAGIC_ERROR)) ;
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_APPLE")), INT2FIX(MAGIC_APPLE)) ;
+	VALUE hash = rb_hash_new();
+
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NONE")), INT2FIX(MAGIC_NONE));
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_DEBUG")), INT2FIX(MAGIC_DEBUG));
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_SYMLINK")), INT2FIX(MAGIC_SYMLINK));
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_COMPRESS")), INT2FIX(MAGIC_COMPRESS));
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_DEVICES")), INT2FIX(MAGIC_DEVICES));
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_MIME_TYPE")), INT2FIX(MAGIC_MIME_TYPE));
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_MIME_ENCODING")), INT2FIX(MAGIC_MIME_ENCODING));
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_MIME")), INT2FIX(MAGIC_MIME));
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_CONTINUE")), INT2FIX(MAGIC_CONTINUE));
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_CHECK")), INT2FIX(MAGIC_CHECK));
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PRESERVE_ATIME")), INT2FIX(MAGIC_PRESERVE_ATIME));
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_RAW")), INT2FIX(MAGIC_RAW));
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_ERROR")), INT2FIX(MAGIC_ERROR));
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_APPLE")), INT2FIX(MAGIC_APPLE));
 	#ifdef MAGIC_EXTENSION
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_EXTENSION")), INT2FIX(MAGIC_EXTENSION)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_EXTENSION")), INT2FIX(MAGIC_EXTENSION));
 	#endif
 
 	#ifdef MAGIC_COMPRESS_TRANSP
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_COMPRESS_TRANSP")), INT2FIX(MAGIC_COMPRESS_TRANSP)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_COMPRESS_TRANSP")), INT2FIX(MAGIC_COMPRESS_TRANSP));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_APPTYPE
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_APPTYPE")), INT2FIX(MAGIC_NO_CHECK_APPTYPE)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_APPTYPE")), INT2FIX(MAGIC_NO_CHECK_APPTYPE));
+	#endif
+
+	#ifdef MAGIC_NO_COMPRESS_FORK
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_COMPRESS_FORK")), INT2FIX(MAGIC_NO_COMPRESS_FORK));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_CDF
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_CDF")), INT2FIX(MAGIC_NO_CHECK_CDF)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_CDF")), INT2FIX(MAGIC_NO_CHECK_CDF));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_COMPRESS
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_COMPRESS")), INT2FIX(MAGIC_NO_CHECK_COMPRESS)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_COMPRESS")), INT2FIX(MAGIC_NO_CHECK_COMPRESS));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_ELF
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_ELF")), INT2FIX(MAGIC_NO_CHECK_ELF)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_ELF")), INT2FIX(MAGIC_NO_CHECK_ELF));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_ENCODING
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_ENCODING")), INT2FIX(MAGIC_NO_CHECK_ENCODING)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_ENCODING")), INT2FIX(MAGIC_NO_CHECK_ENCODING));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_SOFT
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_SOFT")), INT2FIX(MAGIC_NO_CHECK_SOFT)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_SOFT")), INT2FIX(MAGIC_NO_CHECK_SOFT));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_TAR
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_TAR")), INT2FIX(MAGIC_NO_CHECK_TAR)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_TAR")), INT2FIX(MAGIC_NO_CHECK_TAR));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_TEXT
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_TEXT")), INT2FIX(MAGIC_NO_CHECK_TEXT)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_TEXT")), INT2FIX(MAGIC_NO_CHECK_TEXT));
 	#endif
 
 	#ifdef MAGIC_NO_CHECK_TOKENS
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_TOKENS")), INT2FIX(MAGIC_NO_CHECK_TOKENS)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_TOKENS")), INT2FIX(MAGIC_NO_CHECK_TOKENS));
 	#endif
 
-	#ifdef  MAGIC_NO_CHECK_CSV
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_CSV")), INT2FIX(MAGIC_NO_CHECK_CSV)) ;
+	#ifdef MAGIC_NO_CHECK_JSON
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_JSON")), INT2FIX(MAGIC_NO_CHECK_JSON));
+	#endif
+
+	#ifdef MAGIC_NO_CHECK_CSV
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_CSV")), INT2FIX(MAGIC_NO_CHECK_CSV));
 	#endif
 
-	#ifdef  MAGIC_NO_CHECK_CSV
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_JSON")), INT2FIX(MAGIC_NO_CHECK_JSON)) ;
+	#ifdef MAGIC_NO_CHECK_SIMH
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_SIMH")), INT2FIX(MAGIC_NO_CHECK_SIMH));
 	#endif
 
-	return hash ;
+	return hash;
 }

data/ext/libmagic/params.h

@@ -1,63 +1,63 @@
 void params(volatile VALUE rb_klass) {
 	#ifdef MAGIC_PARAM_INDIR_MAX
-	rb_define_const(rb_klass, "MAGIC_PARAM_INDIR_MAX", UINT2NUM(MAGIC_PARAM_INDIR_MAX)) ;
+	rb_define_const(rb_klass, "MAGIC_PARAM_INDIR_MAX", UINT2NUM(MAGIC_PARAM_INDIR_MAX));
 	#endif
 
 	#ifdef MAGIC_PARAM_NAME_MAX
-	rb_define_const(rb_klass, "MAGIC_PARAM_NAME_MAX", UINT2NUM(MAGIC_PARAM_NAME_MAX)) ;
+	rb_define_const(rb_klass, "MAGIC_PARAM_NAME_MAX", UINT2NUM(MAGIC_PARAM_NAME_MAX));
 	#endif
 
 	#ifdef MAGIC_PARAM_ELF_NOTES_MAX
-	rb_define_const(rb_klass, "MAGIC_PARAM_ELF_NOTES_MAX", UINT2NUM(MAGIC_PARAM_ELF_NOTES_MAX)) ;
+	rb_define_const(rb_klass, "MAGIC_PARAM_ELF_NOTES_MAX", UINT2NUM(MAGIC_PARAM_ELF_NOTES_MAX));
 	#endif
 
 	#ifdef MAGIC_PARAM_ELF_PHNUM_MAX
-	rb_define_const(rb_klass, "MAGIC_PARAM_ELF_PHNUM_MAX", UINT2NUM(MAGIC_PARAM_ELF_PHNUM_MAX)) ;
+	rb_define_const(rb_klass, "MAGIC_PARAM_ELF_PHNUM_MAX", UINT2NUM(MAGIC_PARAM_ELF_PHNUM_MAX));
 	#endif
 
 	#ifdef MAGIC_PARAM_ELF_SHNUM_MAX
-	rb_define_const(rb_klass, "MAGIC_PARAM_ELF_SHNUM_MAX", UINT2NUM(MAGIC_PARAM_ELF_SHNUM_MAX)) ;
+	rb_define_const(rb_klass, "MAGIC_PARAM_ELF_SHNUM_MAX", UINT2NUM(MAGIC_PARAM_ELF_SHNUM_MAX));
 	#endif
 
 	#ifdef MAGIC_PARAM_REGEX_MAX
-	rb_define_const(rb_klass, "MAGIC_PARAM_REGEX_MAX", UINT2NUM(MAGIC_PARAM_REGEX_MAX)) ;
+	rb_define_const(rb_klass, "MAGIC_PARAM_REGEX_MAX", UINT2NUM(MAGIC_PARAM_REGEX_MAX));
 	#endif
 
 	#ifdef MAGIC_PARAM_BYTES_MAX
-	rb_define_const(rb_klass, "MAGIC_PARAM_BYTES_MAX", UINT2NUM(MAGIC_PARAM_BYTES_MAX)) ;
+	rb_define_const(rb_klass, "MAGIC_PARAM_BYTES_MAX", UINT2NUM(MAGIC_PARAM_BYTES_MAX));
 	#endif
 }
 
 VALUE lsparams(volatile VALUE obj) {
-	VALUE hash = rb_hash_new() ;
+	VALUE hash = rb_hash_new();
 
 	#ifdef MAGIC_PARAM_INDIR_MAX
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_INDIR_MAX")), UINT2NUM(MAGIC_PARAM_INDIR_MAX)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_INDIR_MAX")), UINT2NUM(MAGIC_PARAM_INDIR_MAX));
 	#endif
 
 	#ifdef MAGIC_PARAM_NAME_MAX
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_NAME_MAX")), UINT2NUM(MAGIC_PARAM_NAME_MAX)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_NAME_MAX")), UINT2NUM(MAGIC_PARAM_NAME_MAX));
 	#endif
 
 	#ifdef MAGIC_PARAM_ELF_NOTES_MAX
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_ELF_NOTES_MAX")), UINT2NUM(MAGIC_PARAM_ELF_NOTES_MAX)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_ELF_NOTES_MAX")), UINT2NUM(MAGIC_PARAM_ELF_NOTES_MAX));
 	#endif
 
 	#ifdef MAGIC_PARAM_ELF_PHNUM_MAX
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_ELF_PHNUM_MAX")), UINT2NUM(MAGIC_PARAM_ELF_PHNUM_MAX)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_ELF_PHNUM_MAX")), UINT2NUM(MAGIC_PARAM_ELF_PHNUM_MAX));
 	#endif
 
 	#ifdef MAGIC_PARAM_ELF_SHNUM_MAX
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_ELF_SHNUM_MAX")), UINT2NUM(MAGIC_PARAM_ELF_SHNUM_MAX)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_ELF_SHNUM_MAX")), UINT2NUM(MAGIC_PARAM_ELF_SHNUM_MAX));
 	#endif
 
 	#ifdef MAGIC_PARAM_REGEX_MAX
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_REGEX_MAX")), UINT2NUM(MAGIC_PARAM_REGEX_MAX)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_REGEX_MAX")), UINT2NUM(MAGIC_PARAM_REGEX_MAX));
 	#endif
 
 	#ifdef MAGIC_PARAM_BYTES_MAX
-	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_BYTES_MAX")), UINT2NUM(MAGIC_PARAM_BYTES_MAX)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_PARAM_BYTES_MAX")), UINT2NUM(MAGIC_PARAM_BYTES_MAX));
 	#endif
 
-	return hash ;
+	return hash;
 }

data/ext/libmagic/validations.h

@@ -1,23 +1,23 @@
 void fileReadable(char *filePath) {
-	if(access(filePath, F_OK)) rb_raise(rb_eFileNotFoundError, "%s", filePath) ;
-	if(access(filePath, R_OK)) rb_raise(rb_eFileNotReadableError, "%s", filePath) ;
+	if(access(filePath, F_OK)) rb_raise(rb_eFileNotFoundError, "%s", filePath);
+	if(access(filePath, R_OK)) rb_raise(rb_eFileNotReadableError, "%s", filePath);
 }
 
 void magic_validate_db(magic_t cookie, char *databasePath) {
-	struct stat statbuf ;
+	struct stat statbuf;
 
 	if (stat(databasePath, &statbuf) != 0)
-		rb_raise(rb_eFileNotFoundError, "%s", databasePath) ;
+		rb_raise(rb_eFileNotFoundError, "%s", databasePath);
 
 	if(S_ISDIR(statbuf.st_mode))
-		rb_raise(rb_eIsDirError, "%s", databasePath) ;
+		rb_raise(rb_eIsDirError, "%s", databasePath);
 
-	if(access(databasePath, R_OK)) rb_raise(rb_eFileNotReadableError, "%s", databasePath) ;
+	if(access(databasePath, R_OK)) rb_raise(rb_eFileNotReadableError, "%s", databasePath);
 
-	int validFile = magic_check(cookie, databasePath) ;
+	int validFile = magic_check(cookie, databasePath);
 
 	if (validFile != 0) {
-		const char *err = magic_error(cookie) ;
-		rb_raise(rb_eInvalidDBError, "%s (%s is not a valid magic file)", err, databasePath) ;
+		const char *err = magic_error(cookie);
+		rb_raise(rb_eInvalidDBError, "%s (%s is not a valid magic file)", err, databasePath);
 	}
 }

data/lib/libmagic_rb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class LibmagicRb
-	VERSION = "0.1.2"
+	VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libmagic_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Cybergizer
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-06 00:00:00.000000000 Z
+date: 2024-09-27 00:00:00.000000000 Z
 dependencies: []
 description: Check filetype with libmagic
 email:
@@ -51,7 +51,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.21
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: Check filetype with libmagic