libmagic_rb 0.1.1.pre.alpha → 0.1.2.pre.gamma

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9742d29b9e36ec2a6de0079d215965133e97a7f9f03fc9d568b678c229e1c104
-  data.tar.gz: ebc7eccd373d353a3954946d0d88ef92956d478d36fbc4509c7c3cc029fa5de7
+  metadata.gz: 116d3dc132643a74f2a887128844a9faa5a4b0a53b7aded5e70bd296087ad005
+  data.tar.gz: 77f551eddaae7a4d1e70840608ec008cc509569d5c9153d0e07f7d710fc371e7
 SHA512:
-  metadata.gz: ea9103f6c7eb96a772e1d712f6a09547c753dee9561c3196de841d998c9200d1104b8fb03b702d8c025c438b9ad728658ff405ffc95e546afa7d834809bb75a7
-  data.tar.gz: 3d0d0bf0308e8472fd77019c3deb00a55869f5a2576b230682690d291023eff69700203b7ec13a3b4b0f1323824f2c61b2bfe281b0dca8ef33dc48c80c374fa5
+  metadata.gz: 804a95966aeca5e305ff5b6d18a733528dcbf179617cefb461bd779c0dbbb8aa044d6edeca9a55b2b04b62c8c6b8c69b82f8d0a4c7663eba43e6798b8ab51a31
+  data.tar.gz: fefe9f019f2decd1e85f7836eacbac01bc6c5e9f22beb22d5e271b903eed83d7b6e25d942e3460be4a2f92d9312faa4eaac477775b6c75c36e23d68035634813

data/README.md

@@ -1,35 +1,79 @@
-# LibmagicRb
+# LibmagicRb [![Gem Version](https://badge.fury.io/rb/libmagic_rb.svg)](https://rubygems.org/gems/libmagic_rb) ![Workflow Status](https://github.com/cybergizer-hq/libmagicrb/workflows/LibmagicRb%20Test/badge.svg)
+
 Adds ability to check mime-type of a file using the libmagic ([magic(4)](https://man7.org/linux/man-pages/man4/magic.4.html)).
 It uses native extensions and it's quite performant.
 
 ## Pre-Installation
-On Linux, you need to install libmagic.
+On Linux, you need to install libmagic. The version we recommend is at least 5.36.
+But if you have an older version of libmagic, it will compile and work flawlessly but with a few caveats:
+
++ Many constants (modes and params) will be not defined
++ LibmagicRb::MAGIC_VERSION constant will be set to 0.
++ Few methods will not work.
+  some methods that can return a String or Integer will return nil (like setparam and getparam).
+
+[ Do note that the minimum tested version is 5.11, older than that may fail to compile the gem ]
 
-##### Arch
+You also need Ruby > 1.9.0 in order to run this gem.
+
+With that info in mind, let's continue to the installation part for your Linux distributions...
+
+#### Arch / Manjaro / Archlabs / Garuda Linux / Hefftor Linux & other Arch Based Linux
 
 ```
-# pacman -S file gcc make
+# pacman -S ruby file gcc make --needed
 ```
 
-#### Debian / Ubuntu / Linux Mint / Kali / ParrotOS / RaspberryPi OS
+#### Debian / Ubuntu / Linux Mint / Deepin / Pop!_OS / RaspberryPi OS & other Debian Based Linux
 
 ```
-# apt install libmagic-dev ruby-dev gcc make
+# apt install ruby libmagic-dev ruby-dev gcc make
 ```
 
-#### Fedora
+#### Fedora / Amazon Linux / CentOS & Other RedHat Based Linux
 
 ```
-# yum install file-devel ruby-devel gcc make
+# yum install ruby file-devel ruby-devel gcc make
 ```
 
 #### OpenSUSE
 
 ```
-zypper in ruby ruby-devel file-devel gcc make
+# zypper in ruby ruby-devel file-devel gcc make
+```
+
+#### Gentoo
+
+There are already make, and magic.h available for Gentoo. You just need Ruby:
+
+```
+# emerge --ask dev-lang/ruby
+```
+
+#### DragonflyBSD / FreeBSD
+
+Versions upto 0.1.2 is tested on DragonflyBSD (Version 6.0-SYNTH).
+
+```
+# pkg install ruby devel/ruby-gems gcc gmake
+```
+
+#### MacOS
+
+You can install libmagic with homebrew:
+
+```
+$ brew install libmagic
+
+# if the link is already created is going to fail, don't worry about that
+$ brew link libmagic
 ```
 
-Mac is currently not supported but may support in the future.
+[ Source: [ eparreno/gist:1845561 ](https://gist.github.com/eparreno/1845561) ]
+
+#### Windows
+
+Windows is currently not tested, hence the support is unknown.
 
 ## Installation
 
@@ -51,6 +95,9 @@ Or install it yourself as:
 $ gem install libmagic_rb
 ```
 
+We recommend getting the gem only from Rubygems.org. Do not download this repo as zip, compile to install the gem.
+A rubygem version is released after various tests. Any branch here including Master branch can be unstable can even segfault your app. You've been warned!
+
 ## Usage
 The target of this gem is to add mime-type checking easily.
 
@@ -162,18 +209,19 @@ cookie.setparam(LibmagicRb::MAGIC_PARAM_REGEX_MAX, 2 ** 14) # => 16384; but can
 
 #### Notes:
 
-+ To get the parameters, you can refer to the [man page](https://man7.org/linux/man-pages/man3/magic_getflags.3.html).
-+ Cookie setparam returns the value after getting the param as well. So you don't need to confirm by calling getparam() again.
++ To get the parameters, you can run `LibmagicRb.lsparams()` for description, please refer to the [man page](https://man7.org/linux/man-pages/man3/magic_getflags.3.html).
++ `cookie.setparam()` returns the value after getting the param as well. So you don't need to confirm by calling getparam() again.
 + The maximum size depends on the parameter. But the value that can be passed should not be more than 2 ** 32.
++ On older versions of libmagic, where the function isn't available, both getparam() and setparam() will perform no operations, and return nil!
 
 ## Errors
 The following errors are implemented and raised on appropriate situation:
 
-1. LibmagicRb::FileNotFound: When the file is not found.
-2. LibmagicRb::FileUnreadable: When the file is unreadable.
-3. LibmagicRb::InvalidDBError: When the database given is invalid.
-4. LibmagicRb::IsDirError: When the database path is a directory.
-5. LibmagicRb::FileClosedError: When the file is already closed (closed?()) but you are trying to access the cookie.
+1. `LibmagicRb::FileNotFound`: When the file is not found.
+2. `LibmagicRb::FileUnreadable`: When the file is unreadable.
+3. `LibmagicRb::InvalidDBError`: When the database given is invalid.
+4. `LibmagicRb::IsDirError`: When the database path is a directory.
+5. `LibmagicRb::FileClosedError`: When the file is already closed (closed?()) but you are trying to access the cookie.
 
 ## Development
 

data/ext/libmagic/func.h

@@ -1,3 +1,15 @@
+/*
+	Closes a magic cookie. For example:
+
+		> cookie = LibmagicRb.new(file: '/usr/share/dict/words')
+		# => #<LibmagicRb:0x00005581019fa7e0 @closed=false, @db=nil, @file="/usr/share/dict/words", @mode=1106>
+
+		> cookie.close
+		# => #<LibmagicRb:0x00005581019fa7e0 @closed=true, @db=nil, @file="/usr/share/dict/words", @mode=1106>
+
+	Returns self.
+*/
+
 VALUE _closeGlobal_(volatile VALUE self) {
 	RB_UNWRAP(cookie) ;
 
@@ -7,6 +19,23 @@ VALUE _closeGlobal_(volatile VALUE self) {
 	return self ;
 }
 
+/*
+	Changes the database path. For example:
+		> cookie = LibmagicRb.new(file: '/usr/share/dict/words')
+		# => #<LibmagicRb:0x00005581019181b0 @closed=false, @db=nil, @file="/usr/share/dict/words", @mode=1106>
+
+		> cookie.db = '/usr/share/file/misc/magic.mgc'
+		# => "/usr/share/file/misc/magic.mgc"
+
+		> cookie.check
+		# => "text/plain; charset=utf-8"
+
+		> cookie.close
+		# => #<LibmagicRb:0x00005581019181b0 @closed=true, @db="/usr/share/file/misc/magic.mgc", @file="/usr/share/dict/words", @mode=1106>
+
+	Returns self.
+*/
+
 VALUE _loadGlobal_(volatile VALUE self, volatile VALUE dbPath) {
 	char *databasePath = NULL ;
 
@@ -27,6 +56,20 @@ VALUE _loadGlobal_(volatile VALUE self, volatile VALUE dbPath) {
 	return self ;
 }
 
+/*
+	Check a file with the magic database. For example:
+		> cookie = LibmagicRb.new(file: '/usr/share/dict/words')
+		# => #<LibmagicRb:0x00005581019181b0 @closed=false, @db=nil, @file="/usr/share/dict/words", @mode=1106>
+
+		> cookie.check
+		# => "text/plain; charset=utf-8"
+
+		> cookie.close
+		# => #<LibmagicRb:0x00005581019181b0 @closed=true, @db="/usr/share/file/misc/magic.mgc", @file="/usr/share/dict/words", @mode=1106>
+
+		Returns String or nil.
+*/
+
 VALUE _checkGlobal_(volatile VALUE self) {
 	RB_UNWRAP(cookie) ;
 
@@ -51,51 +94,188 @@ VALUE _checkGlobal_(volatile VALUE self) {
 	return mt ? rb_str_new_cstr(mt) : Qnil ;
 }
 
+/*
+	Get parameters for a cookie. For example:
+		cookie = LibmagicRb.new(file: '/usr/share/dict/words')
+		# => #<LibmagicRb:0x00005581018f35e0 @closed=false, @db=nil, @file="/usr/share/dict/words", @mode=1106>
+
+		> cookie.getparam(LibmagicRb::MAGIC_PARAM_NAME_MAX)
+		# => 50
+
+		> cookie.close
+		# => #<LibmagicRb:0x00005581018f35e0 @closed=true, @db=nil, @file="/usr/share/dict/words", @mode=1106>
+*/
+
 VALUE _getParamGlobal_(volatile VALUE self, volatile VALUE param) {
-	RB_UNWRAP(cookie) ;
+	#if MAGIC_VERSION > 525
+		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 ;
+	#endif
 }
 
+/*
+	Sets parameter for a cookie. For example:
+
+		> cookie = LibmagicRb.new(file: '/usr/share/dict/words')
+		# => #<LibmagicRb:0x00005581019f9840 @closed=false, @db=nil, @file="/usr/share/dict/words", @mode=1106>
+
+		> cookie.getparam(LibmagicRb::MAGIC_PARAM_NAME_MAX)
+		=> 50
+
+		> cookie.setparam(LibmagicRb::MAGIC_PARAM_NAME_MAX, 101)
+		# => 101
+
+		> cookie.getparam(LibmagicRb::MAGIC_PARAM_NAME_MAX)
+		# => 101
+
+		> cookie.close
+		# => #<LibmagicRb:0x00005581019f9840 @closed=true, @db=nil, @file="/usr/share/dict/words", @mode=1106>
+
+	Returns Integer or nil on failure.
+*/
+
 VALUE _setParamGlobal_(volatile VALUE self, volatile VALUE param, volatile VALUE paramVal) {
-	unsigned int _param = NUM2UINT(param) ;
-	unsigned long _paramVal = NUM2ULONG(paramVal) ;
+	#if MAGIC_VERSION > 525
+		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) ;
+		int status = magic_getparam(*cookie, _param, &value) ;
+		if (status) return Qnil ;
 
-	if (status) return Qnil ;
-	return ULONG2NUM((int)value) ;
+		return ULONG2NUM((int)value) ;
+	#else
+		return Qnil ;
+	#endif
 }
 
+/*
+	Returns a textual description of the contents of the buffer argument with length bytes size.
+
+	For example:
+
+		> cookie = LibmagicRb.new(file: '.')
+		# => #<LibmagicRb:0x00005582de0d1bf8 @closed=false, @db=nil, @file=".", @mode=1106>
+
+		> cookie.magic_buffer("%PDF-1.3\r\n")
+		# => "application/pdf; charset=us-ascii"
+
+		> cookie.close
+		# => #<LibmagicRb:0x00005582de0d1bf8 @closed=true, @db=nil, @file=".", @mode=1106>
+
+	Note that it automatically loads the database.
+
+	Returns either String or nil.
+*/
+
 VALUE _bufferGlobal_(volatile VALUE self, volatile VALUE string) {
 	RB_UNWRAP(cookie) ;
 
+	VALUE db = rb_iv_get(self, "@db") ;
+
+	char *database = NULL ;
+	if(RB_TYPE_P(db, T_STRING)) {
+		database = StringValuePtr(db) ;
+	}
+
+	if(database) magic_validate_db(*cookie, database) ;
+	magic_load(*cookie, database) ;
+
 	char *buffer = StringValuePtr(string) ;
-	const char *buf = magic_buffer(*cookie, buffer, sizeof(buffer)) ;
+	const char *buf = magic_buffer(*cookie, buffer, strlen(buffer)) ;
 
-	return rb_str_new_cstr(buf) ;
+	return buf ? rb_str_new_cstr(buf) : Qnil ;
 }
 
+/*
+	Dumps all magic entries in a human
+	readable format, dumping first the entries that are matched against
+	binary files and then the ones that match text files.
+
+	For example:
+
+
+		> cookie = LibmagicRb.new(file: '.')
+		# => #<LibmagicRb:0x000055cf280a9b30 @closed=false, @db=nil, @file=".", @mode=1106>
+
+		> cookie.magic_list
+		Set 0:
+		Binary patterns:
+		Strength = 500@47: Biosig/Brainvision Marker file [biosig/brainvision]
+		Strength = 490@122: Biosig/TMSiLOG [biosig/tmsilog]
+		Strength = 461@127: Biosig/SYNERGY [biosig/synergy]
+		Strength = 460@46: Biosig/Brainvision V-Amp file []
+		Strength = 410@45: Biosig/Brainvision data file []
+		Strength = 380@6: OpenSSH private key []
+		Strength = 370@1266: Novell message librarian data []
+		.
+		.
+		.
+		# => 0
+
+		> cookie.close
+		=> #<LibmagicRb:0x000055cf280a9b30 @closed=true, @db=nil, @file=".", @mode=1106>
+*/
+
 VALUE _listGlobal_(volatile VALUE self) {
 	RB_UNWRAP(cookie) ;
 
 	VALUE db = rb_iv_get(self, "@db") ;
-	char *database = StringValuePtr(db) ;
 
+	char *database = NULL ;
+	if (RB_TYPE_P(db, T_STRING)) {
+		database = StringValuePtr(db) ;
+	}
+
+	if(database) magic_validate_db(*cookie, database) ;
 	int status = magic_list(*cookie, database) ;
+
 	return INT2FIX(status) ;
 }
 
+/*
+	Set flags/modes for a cookie (not to be confused with params).
+	It's same setting mode through the setter cookie.mode = mode.
+
+	For example:
+
+		> cookie = LibmagicRb.new(file: '.')
+		# => #<LibmagicRb:0x00005583732e1070 @closed=false, @db=nil, @file=".", @mode=1106>
+
+		> cookie.check
+		# => "inode/directory; charset=binary"
+
+		> cookie.setflags(LibmagicRb::MAGIC_RAW)
+		# => 256
+
+		> cookie.check
+		# => "directory"
+
+		#### Similarly you can also do this ####
+
+		> cookie.mode = LibmagicRb::MAGIC_MIME
+		# => 1040
+
+		> cookie.check
+		# => "inode/directory; charset=binary"
+
+		#### Close the cookie when done ####
+		> cookie.close
+		# => #<LibmagicRb:0x00005583732e1070 @closed=true, @db=nil, @file=".", @mode=256>
+*/
+
 VALUE _setflagsGlobal_(volatile VALUE self, volatile VALUE flags) {
 	unsigned int flag = NUM2UINT(flags) ;
 

data/ext/libmagic/magic.c

@@ -1,6 +1,7 @@
 #include <magic.h>
 #include <stdio.h>
 #include <unistd.h>
+#include <sys/stat.h>
 #include "ruby.h"
 
 /*
@@ -10,6 +11,10 @@
 #include "params.h"
 #include "definitions.h"
 
+#ifndef MAGIC_VERSION
+#define MAGIC_VERSION 0
+#endif
+
 /*
 * Errors
 */
@@ -39,13 +44,30 @@ static rb_data_type_t fileType = {
 	},
 
 	.data = NULL,
-	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+
+	#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+	#endif
 } ;
 
 #include "validations.h"
 #include "func.h"
 
-VALUE _check_(volatile VALUE obj, volatile VALUE args) {
+/*
+	Directly check a file with LibmagicRb, without creating any sort of cookies:
+
+		LibmagicRb.check(file: '/tmp/', db: '/usr/share/file/misc/magic.mgc', mode: LibmagicRb::MAGIC_CHECK) # => "sticky, directory"
+
+	[file] The key `file:` is the filename to check. Should be a string
+
+	[db] The key `db:` can be left as nil. Or you can give it the path of the current magic database.
+
+	[mode] The key `mode` can be any of the LibmagicRb.lsmodes().
+	To combine modes you can use `|`. For example:
+	`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) {
 	if(!RB_TYPE_P(args, T_HASH)) {
 		rb_raise(rb_eArgError, "Expected hash as argument.") ;
 	}
@@ -103,6 +125,43 @@ VALUE _check_(volatile VALUE obj, volatile VALUE args) {
 	return retVal ;
 }
 
+/*
+	Intializes a magic cookie that can be used multiple times.
+	The benefit of this is to assgign various cookies and change flags of each cookie.
+
+	For example:
+
+		> cookie = LibmagicRb.new(file: '/tmp')
+		# => #<LibmagicRb:0x000055810139f738 @closed=false, @db=nil, @file="/tmp", @mode=1106>
+
+		> cookie.check
+		# => "inode/directory; charset=binary"
+
+		> cookie.setflags(LibmagicRb::MAGIC_RAW)
+		# => 256
+
+		> cookie.check
+		# => "sticky, directory"
+
+		> cookie2 = LibmagicRb.new(file: '/usr/share/dict/words')
+		# => #<LibmagicRb:0x000055810190a060 @closed=false, @db=nil, @file="/usr/share/dict/words", @mode=1106>
+
+		> cookie2.check
+		# => "text/plain; charset=utf-8"
+
+		> cookie.close
+		# => #<LibmagicRb:0x000055810139f738 @closed=true, @db=nil, @file="/tmp", @mode=256>
+
+		> cookie.closed?
+		# => true
+
+		> cookie2.closed?
+		# => false
+
+	Here in this example, we can't use cookie, but cookie2 is a different magic_t wrapper, so we can continue using that.
+	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) {
 	// Database Path
 	if(!RB_TYPE_P(args, T_HASH)) {
@@ -111,14 +170,11 @@ VALUE rb_libmagicRb_initialize(volatile VALUE self, volatile VALUE args) {
 
 	VALUE argDBPath = rb_hash_aref(args, ID2SYM(rb_intern("db"))) ;
 
-	char *databasePath ;
 	if (RB_TYPE_P(argDBPath, T_NIL)) {
-		databasePath = NULL ;
 		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.") ;
 	} else {
-		databasePath = StringValuePtr(argDBPath) ;
 		rb_ivar_set(self, rb_intern("@db"), argDBPath) ;
 	}
 
@@ -169,6 +225,10 @@ void Init_main() {
 	/*
 	* Libmagic Errors
 	*/
+
+	/*
+		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) ;
 
 	rb_eFileNotFoundError = rb_define_class_under(cLibmagicRb, "FileNotFound", rb_eRuntimeError) ;
@@ -183,9 +243,19 @@ void Init_main() {
 	modes(cLibmagicRb) ;
 	params(cLibmagicRb) ;
 
-	char version[6] ;
-	sprintf(version, "%0.2f", magic_version() / 100.0) ;
-	rb_define_const(cLibmagicRb, "MAGIC_VERSION", rb_str_new_cstr(version)) ;
+
+	#if MAGIC_VERSION > 525
+		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)) ;
+	#else
+		rb_define_const(cLibmagicRb, "MAGIC_VERSION", rb_str_new_cstr("0")) ;
+	#endif
 
 	/*
 	* Singleton Methods

data/ext/libmagic/modes.h

@@ -15,24 +15,57 @@ void modes(volatile VALUE rb_klass) {
 	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)) ;
+	#endif
+
+	#ifdef 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)) ;
+	#endif
+
+	#ifdef 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)) ;
+	#endif
+
+	#ifdef 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)) ;
+	#endif
+
+	#ifdef 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)) ;
+	#endif
+
+	#ifdef 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)) ;
+	#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
 }
 
@@ -53,24 +86,56 @@ VALUE lsmodes(volatile VALUE obj) {
 	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)) ;
+	#endif
+
+	#ifdef 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)) ;
+	#endif
+
+	#ifdef 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)) ;
+	#endif
+
+	#ifdef 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)) ;
+	#endif
+
+	#ifdef 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)) ;
+	#endif
+
+	#ifdef 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)) ;
+	#endif
 
 	#ifdef  MAGIC_NO_CHECK_CSV
-		rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_CSV")), INT2FIX(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)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("MAGIC_NO_CHECK_JSON")), INT2FIX(MAGIC_NO_CHECK_JSON)) ;
 	#endif
 
 	return hash ;

data/ext/libmagic/params.h

@@ -1,28 +1,62 @@
 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)) ;
+	#endif
+
+	#ifdef 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)) ;
+	#endif
+
+	#ifdef 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)) ;
+	#endif
+
+	#ifdef 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() ;
 
+	#ifdef 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)) ;
+	#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)) ;
+	#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)) ;
+	#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)) ;
+	#endif
+
+	#ifdef 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 ;

data/lib/libmagic_rb/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libmagic_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.1.pre.alpha
+  version: 0.1.2.pre.gamma
 platform: ruby
 authors:
 - Cybergizer
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-08-19 00:00:00.000000000 Z
+date: 2021-09-06 00:00:00.000000000 Z
 dependencies: []
 description: Check filetype with libmagic
 email: