ruby-magic 0.3.2 → 0.5.3

data/ext/magic/ruby-magic.h

@@ -10,11 +10,8 @@ extern "C" {
 
 #define MAGIC_SYNCHRONIZED(f, d) magic_lock(object, (f), (d))
 
-#define MAGIC_OBJECT(o) \
-	Data_Get_Struct(object, magic_object_t, (o))
-
-#define MAGIC_COOKIE(o, c) \
-	((c) = MAGIC_OBJECT((o))->cookie)
+#define MAGIC_OBJECT(o, t) \
+	TypedData_Get_Struct((o), rb_mgc_object_t, &rb_mgc_type, (t))
 
 #define MAGIC_CLOSED_P(o) RTEST(rb_mgc_close_p((o)))
 #define MAGIC_LOADED_P(o) RTEST(rb_mgc_load_p((o)))
@@ -25,64 +22,66 @@ extern "C" {
 			rb_mgc_warning |= BIT(i);	  \
 			rb_warn(__VA_ARGS__);		  \
 		}					  \
-	} while(0)
+	} while (0)
+
+#define MAGIC_ERRORS(t) ruby_magic_errors[(t)]
 
 #define MAGIC_ARGUMENT_TYPE_ERROR(o, ...) \
-	rb_raise(rb_eTypeError, error(E_ARGUMENT_TYPE_INVALID), CLASS_NAME((o)), __VA_ARGS__)
+	rb_raise(rb_eTypeError, MAGIC_ERRORS(E_ARGUMENT_TYPE_INVALID), CLASS_NAME((o)), __VA_ARGS__)
 
 #define MAGIC_GENERIC_ERROR(k, e, m) \
-	rb_exc_raise(magic_generic_error((k), (e), error(m)))
+	rb_exc_raise(magic_generic_error((k), (e), MAGIC_ERRORS(m)))
 
 #define MAGIC_LIBRARY_ERROR(c) \
-	rb_exc_raise(magic_library_error(rb_mgc_eMagicError, (c)))
+	rb_exc_raise(magic_library_error(rb_mgc_eMagicError, (c)->cookie))
 
 #define MAGIC_CHECK_INTEGER_TYPE(o) magic_check_type((o), T_FIXNUM)
 #define MAGIC_CHECK_STRING_TYPE(o)  magic_check_type((o), T_STRING)
 
-#define MAGIC_CHECK_ARGUMENT_MISSING(t, o)					     \
-	do {									     \
-		if ((t) < (o))							     \
-			rb_raise(rb_eArgError, error(E_ARGUMENT_MISSING), (t), (o)); \
-	} while(0)
-
-#define MAGIC_CHECK_ARRAY_EMPTY(o)							  \
-	do {										  \
-		if (RARRAY_EMPTY_P(o))							  \
-			rb_raise(rb_eArgError, "%s", error(E_ARGUMENT_TYPE_ARRAY_EMPTY)); \
-	} while(0)
-
 #define MAGIC_CHECK_ARRAY_OF_STRINGS(o) \
 	magic_check_type_array_of_strings((o))
 
+#define MAGIC_CHECK_ARGUMENT_MISSING(t, o)						    \
+	do {										    \
+		if ((t) < (o))								    \
+			rb_raise(rb_eArgError, MAGIC_ERRORS(E_ARGUMENT_MISSING), (t), (o)); \
+	} while (0)
+
+#define MAGIC_CHECK_ARRAY_EMPTY(o)								 \
+	do {											 \
+		if (RARRAY_EMPTY_P(o))								 \
+			rb_raise(rb_eArgError, "%s", MAGIC_ERRORS(E_ARGUMENT_TYPE_ARRAY_EMPTY)); \
+	} while (0)
+
+
 #define MAGIC_CHECK_OPEN(o)						  \
 	do {								  \
 		if (MAGIC_CLOSED_P(o))					  \
 			MAGIC_GENERIC_ERROR(rb_mgc_eLibraryError, EFAULT, \
 					    E_MAGIC_LIBRARY_CLOSED);	  \
-	} while(0)
+	} while (0)
 
 #define MAGIC_CHECK_LOADED(o)						 \
 	do {								 \
 		if (!MAGIC_LOADED_P(o))					 \
 			MAGIC_GENERIC_ERROR(rb_mgc_eMagicError, EFAULT,	 \
 					    E_MAGIC_LIBRARY_NOT_LOADED); \
-	} while(0)
+	} while (0)
 
 #define MAGIC_STRINGIFY(s) #s
 
 #define MAGIC_DEFINE_FLAG(c) \
-	rb_define_const(rb_cMagic, MAGIC_STRINGIFY(c), INT2NUM(MAGIC_##c));
+	rb_define_const(rb_cMagic, MAGIC_STRINGIFY(c), INT2NUM(MAGIC_##c))
 
 #define MAGIC_DEFINE_PARAMETER(c) \
-	rb_define_const(rb_cMagic, MAGIC_STRINGIFY(PARAM_##c), INT2NUM(MAGIC_PARAM_##c));
-
-#define error(t) errors[(t)]
+	rb_define_const(rb_cMagic, MAGIC_STRINGIFY(PARAM_##c), INT2NUM(MAGIC_PARAM_##c))
 
-enum error {
+enum ruby_magic_error {
 	E_UNKNOWN = 0,
 	E_NOT_ENOUGH_MEMORY,
 	E_ARGUMENT_MISSING,
 	E_ARGUMENT_TYPE_INVALID,
+	E_ARGUMENT_TYPE_UNKNOWN,
 	E_ARGUMENT_TYPE_ARRAY_EMPTY,
 	E_ARGUMENT_TYPE_ARRAY_STRINGS,
 	E_MAGIC_LIBRARY_INITIALIZE,
@@ -94,53 +93,53 @@ enum error {
 	E_FLAG_INVALID_TYPE
 };
 
-typedef struct parameter {
-	size_t value;
+struct parameter {
 	int tag;
-} parameter_t;
+	size_t value;
+};
 
-typedef union file {
+union file {
 	const char *path;
 	int fd;
-} file_t;
+};
 
-typedef struct buffers {
+struct buffers {
 	size_t count;
 	size_t *sizes;
 	void **pointers;
-} buffers_t;
+};
 
 typedef struct magic_object {
 	magic_t cookie;
 	VALUE mutex;
 	unsigned int database_loaded:1;
 	unsigned int stop_on_errors:1;
-} magic_object_t;
+} rb_mgc_object_t;
 
 typedef struct magic_arguments {
+	rb_mgc_object_t *magic_object;
 	union {
-		file_t file;
-		parameter_t parameter;
-		buffers_t buffers;
-	} type;
-	magic_t cookie;
+		struct parameter parameter;
+		union file file;
+		struct buffers buffers;
+	};
 	const char *result;
-	int flags;
 	int status;
-	unsigned int stop_on_errors:1;
-} magic_arguments_t;
+	int flags;
+} rb_mgc_arguments_t;
 
-typedef struct magic_exception {
+typedef struct magic_error {
 	const char *magic_error;
 	VALUE klass;
 	int magic_errno;
-} magic_exception_t;
+} rb_mgc_error_t;
 
-static const char *errors[] = {
+static const char * const ruby_magic_errors[] = {
 	[E_UNKNOWN]			= "an unknown error has occurred",
 	[E_NOT_ENOUGH_MEMORY]		= "cannot allocate memory",
 	[E_ARGUMENT_MISSING]		= "wrong number of arguments (given %d, expected %d)",
 	[E_ARGUMENT_TYPE_INVALID]	= "wrong argument type %s (expected %s)",
+	[E_ARGUMENT_TYPE_UNKNOWN]	= "unknown type 0x%x (0x%x given)",
 	[E_ARGUMENT_TYPE_ARRAY_EMPTY]	= "arguments list cannot be empty (expected array of String)",
 	[E_ARGUMENT_TYPE_ARRAY_STRINGS]	= "wrong argument type %s in arguments list (expected String)",
 	[E_MAGIC_LIBRARY_INITIALIZE]	= "failed to initialize Magic library",
@@ -153,38 +152,158 @@ static const char *errors[] = {
 	NULL
 };
 
+#if defined(MAGIC_CUSTOM_CHECK_TYPE)
+static const char * const magic_ruby_types[] = {
+	"", /* Not an object */
+	[T_OBJECT]	= "Object",
+	[T_CLASS]	= "Class",
+	[T_MODULE]	= "Module",
+	[T_FLOAT]	= "Float",
+	[T_STRING]	= "String",
+	[T_REGEXP]	= "Regexp",
+	[T_ARRAY]	= "Array",
+	[T_HASH]	= "Hash",
+	[T_STRUCT]	= "Struct",
+	[T_BIGNUM]	= "Integer",
+	[T_FILE]	= "File",
+	"", /* Internal use */
+	[T_MATCH]	= "MatchData",
+	[T_COMPLEX]	= "Complex",
+	[T_RATIONAL]	= "Rational",
+	"", /* Internal use */
+	[T_NIL]		= "nil",
+	[T_TRUE]	= "true",
+	[T_FALSE]	= "false",
+	[T_SYMBOL]	= "Symbol",
+	[T_FIXNUM]	= "Integer",
+	"", /* Internal use */
+	NULL
+};
+
+static const char *
+magic_ruby_type_name(int type)
+{
+	const char *name;
+
+	if (type >= ARRAY_SIZE(magic_ruby_types))
+		return NULL;
+
+	name = magic_ruby_types[type];
+	if (name)
+		return name;
+
+	return NULL;
+}
+
+static const char *
+magic_ruby_class_name(VALUE object)
+{
+	const char *name = NULL;
+
+	if (NIL_P(object))
+		name = "nil";
+	else if (RB_TYPE_P(object, T_TRUE))
+		name = "true";
+	else if (RB_TYPE_P(object, T_FALSE))
+		name = "false";
+	else
+		name = CLASS_NAME(object);
+
+	return name;
+}
+
+void
+magic_check_ruby_type(VALUE object, int type)
+{
+	const char *name;
+	int object_type = TYPE(object);
+
+	if (object == Qundef)
+		rb_bug("invalid type leaked to the Ruby space");
+
+	if (object_type > T_MASK || object_type == T_DATA)
+		goto error;
+
+	if (object_type == type)
+		return;
+
+	name = magic_ruby_type_name(type);
+	if (name)
+		rb_raise(rb_eTypeError,
+			 MAGIC_ERRORS(E_ARGUMENT_TYPE_INVALID),
+			 magic_ruby_class_name(object),
+			 name);
+error:
+	rb_raise(rb_eTypeError,
+		 MAGIC_ERRORS(E_ARGUMENT_TYPE_UNKNOWN),
+		 object_type,
+		 type);
+}
+#endif /* MAGIC_CUSTOM_CHECK_TYPE */
+
+static inline VALUE
+magic_strip(VALUE v)
+{
+	return (ARRAY_P(v) || STRING_P(v)) ?
+		rb_funcall(v, rb_intern("strip"), 0) :
+		Qnil;
+}
+
 static inline VALUE
 magic_shift(VALUE v)
 {
-	return ARRAY_P(v) ?			       \
-		rb_funcall(v, rb_intern("shift"), 0) : \
+	return ARRAY_P(v) ?
+		rb_funcall(v, rb_intern("shift"), 0) :
 		Qnil;
 }
 
 static inline VALUE
 magic_split(VALUE a, VALUE b)
 {
-	return (STRING_P(a) && STRING_P(b)) ?		  \
-		rb_funcall(a, rb_intern("split"), 1, b) : \
+	return (STRING_P(a) && STRING_P(b)) ?
+		rb_funcall(a, rb_intern("split"), 1, b) :
 		Qnil;
 }
 
 static inline VALUE
 magic_join(VALUE a, VALUE b)
 {
-	return (ARRAY_P(a) && STRING_P(b)) ?		 \
-		rb_funcall(a, rb_intern("join"), 1, b) : \
+	return (ARRAY_P(a) && STRING_P(b)) ?
+		rb_funcall(a, rb_intern("join"), 1, b) :
 		Qnil;
 }
 
 static inline VALUE
 magic_flatten(VALUE v)
 {
-	return ARRAY_P(v) ?				 \
-		rb_funcall(v, rb_intern("flatten"), 0) : \
+	return ARRAY_P(v) ?
+		rb_funcall(v, rb_intern("flatten"), 0) :
 		Qnil;
 }
 
+static inline VALUE
+magic_strip_array(VALUE value) {
+	VALUE entry;
+	VALUE array = rb_ary_new();
+
+	for (int i = 0; i < RARRAY_LEN(value); i++) {
+		entry = rb_ary_entry(value, i);
+		if (NIL_P(entry))
+			continue;
+
+		if (STRING_P(entry)) {
+			if (RSTRING_EMPTY_P(entry))
+				continue;
+
+			entry = magic_strip(entry);
+		}
+
+		rb_ary_push(array, entry);
+	}
+
+	return array;
+}
+
 static int
 magic_fileno(VALUE object)
 {
@@ -200,7 +319,9 @@ magic_fileno(VALUE object)
 		object = rb_convert_type(object, T_FILE, "IO", "to_io");
 
 	GetOpenFile(object, io);
-	if ((fd = FPTR_TO_FD(io)) < 0)
+
+	fd = FPTR_TO_FD(io);
+	if (fd < 0)
 		rb_raise(rb_eIOError, "closed stream");
 
 	return fd;
@@ -227,33 +348,66 @@ magic_path(VALUE object)
 static inline void
 magic_check_type(VALUE object, RVALUE_TYPE type)
 {
-	VALUE boolean = Qundef;
+	VALUE boolean;
 
 	boolean = rb_obj_is_kind_of(object, T_INTEGER);
 	if (type == T_FIXNUM && !RVAL2CBOOL(boolean))
 		MAGIC_ARGUMENT_TYPE_ERROR(object, rb_class2name(T_INTEGER));
 
-	Check_Type(object, type);
+	MAGIC_CHECK_RUBY_TYPE(object, type);
 }
 
 static inline void
 magic_check_type_array_of_strings(VALUE object)
 {
-	VALUE value = Qundef;
+	VALUE value;
 
 	for (int i = 0; i < RARRAY_LEN(object); i++) {
 		value = RARRAY_AREF(object, (long)i);
 		if (NIL_P(value) || !STRING_P(value))
 			rb_raise(rb_eTypeError,
-				 error(E_ARGUMENT_TYPE_ARRAY_STRINGS),
+				 MAGIC_ERRORS(E_ARGUMENT_TYPE_ARRAY_STRINGS),
 				 CLASS_NAME(value));
 	}
 }
 
+void Init_magic(void);
+
+VALUE rb_mgc_get_do_not_auto_load_global(VALUE object);
+VALUE rb_mgc_set_do_not_auto_load_global(VALUE object, VALUE value);
+VALUE rb_mgc_get_do_not_stop_on_error_global(VALUE object);
+VALUE rb_mgc_set_do_not_stop_on_error_global(VALUE object, VALUE value);
+
+VALUE rb_mgc_initialize(VALUE object, VALUE arguments);
+
+VALUE rb_mgc_get_do_not_stop_on_error(VALUE object);
+VALUE rb_mgc_set_do_not_stop_on_error(VALUE object, VALUE value);
+
+VALUE rb_mgc_open_p(VALUE object);
+VALUE rb_mgc_close(VALUE object);
 VALUE rb_mgc_close_p(VALUE object);
+
+VALUE rb_mgc_get_paths(VALUE object);
+
+VALUE rb_mgc_get_parameter(VALUE object, VALUE tag);
+VALUE rb_mgc_set_parameter(VALUE object, VALUE tag, VALUE value);
+
+VALUE rb_mgc_get_flags(VALUE object);
+VALUE rb_mgc_set_flags(VALUE object, VALUE value);
+
 VALUE rb_mgc_load(VALUE object, VALUE arguments);
+VALUE rb_mgc_load_buffers(VALUE object, VALUE arguments);
+VALUE rb_mgc_load_p(VALUE object);
+
+VALUE rb_mgc_compile(VALUE object, VALUE arguments);
+VALUE rb_mgc_check(VALUE object, VALUE arguments);
+
+VALUE rb_mgc_file(VALUE object, VALUE value);
+VALUE rb_mgc_buffer(VALUE object, VALUE value);
 VALUE rb_mgc_descriptor(VALUE object, VALUE value);
 
+VALUE rb_mgc_version(VALUE object);
+
 #if defined(__cplusplus)
 }
 #endif

data/lib/magic/version.rb

@@ -4,7 +4,7 @@ class Magic
   #
   # Current version of _Magic_.
   #
-  VERSION = '0.3.2'.freeze
+  VERSION = '0.5.3'.freeze
 
   class << self
     #

data/lib/magic.rb

@@ -1,6 +1,15 @@
 # frozen_string_literal: true
 
-require_relative 'magic/magic'
+begin
+  ::RUBY_VERSION =~ /(\d+\.\d+)/
+  require_relative "magic/#{Regexp.last_match(1)}/magic"
+rescue LoadError
+  # use "require" instead of "require_relative" because non-native gems will place C extension files
+  # in Gem::BasicSpecification#extension_dir after compilation (during normal installation), which
+  # is in $LOAD_PATH but not necessarily relative to this file (see #21 and nokogiri#2300)
+  require 'magic/magic'
+end
+
 require_relative 'magic/version'
 require_relative 'magic/core/file'
 require_relative 'magic/core/string'
@@ -95,6 +104,8 @@ class Magic
       open(Magic::MIME, &block)
     end
 
+    alias_method :mime_type, :mime
+
     #
     # call-seq:
     #    Magic.type                  -> self
@@ -175,6 +186,13 @@ class Magic
     end
 
     alias_method :fd, :descriptor
+
+    private
+
+    def default_paths
+      paths = Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), "../ext/magic/share/*.mgc")))
+      paths.empty? ? nil : paths
+    end
   end
 
   private

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-magic
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.5.3
 platform: ruby
 authors:
 - Krzysztof Wilczyński
-autorequire: 
+autorequire:
 bindir: bin
-cert_chain:
-- kwilczynski-public.pem
-date: 2021-04-03 00:00:00.000000000 Z
+cert_chain: []
+date: 2021-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mini_portile2
@@ -17,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.5.0
+        version: '2.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.5.0
+        version: '2.6'
 description: |
   File Magic in Ruby.
 
@@ -42,6 +41,7 @@ files:
 - LICENSE
 - NOTICE
 - README.md
+- dependencies.yml
 - ext/magic/common.h
 - ext/magic/extconf.rb
 - ext/magic/functions.c
@@ -64,7 +64,7 @@ metadata:
   wiki_uri: https://github.com/kwilczynski/ruby-magic/wiki
 post_install_message: 'Thank you for installing!
 
-'
+  '
 rdoc_options: []
 require_paths:
 - lib
@@ -80,8 +80,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.2.28
+signing_key:
 specification_version: 4
 summary: File Magic in Ruby
 test_files: []