ruby-magic 0.0.1

data/ext/magic/ruby-magic.h

@@ -0,0 +1,244 @@
+/* :enddoc: */
+
+/*
+ * ruby-magic.h
+ *
+ * Copyright 2013-2014 Krzysztof Wilczynski
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if !defined(_RUBY_MAGIC_H)
+#define _RUBY_MAGIC_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#include "common.h"
+#include "functions.h"
+
+#define DATA_P(x)   (TYPE(x) == T_DATA)
+#define STRING_P(x) (TYPE(x) == T_STRING)
+#define ARRAY_P(x)  (TYPE(x) == T_ARRAY)
+
+#if !defined(STR2CSTR)
+# define STR2CSTR(x) StringValuePtr(x)
+#endif
+
+#if !defined(RVAL2CSTR)
+# define RVAL2CSTR(x) (NIL_P(x) ? NULL : STR2CSTR(x))
+#endif
+
+#if !defined(CSTR2RVAL)
+# define CSTR2RVAL(x) ((x) == NULL ? Qnil : rb_str_new2(x))
+#endif
+
+#if !defined(RARRAY_LEN)
+# define RARRAY_LEN(a) (RARRAY(a)->len)
+#endif
+
+#if !defined(RSTRING_LEN)
+# define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+#if !defined(RSTRING_PTR)
+# define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+
+#define RSTRING_EMPTY_P(s) (RSTRING_LEN(s) == 0)
+#define RARRAY_EMPTY_P(a)  (RARRAY_LEN(a) == 0)
+#define RARRAY_FIRST(a)    (RARRAY_EMPTY_P(a) ? Qnil : RARRAY_PTR(a)[0])
+
+#define NOGVL_FUNCTION (VALUE (*)(void *))
+
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) && \
+     defined(HAVE_RUBY_THREAD_H) && HAVE_RUBY_THREAD_H
+# include <ruby/thread.h>
+# define NOGVL(f, d) \
+   rb_thread_call_without_gvl((f), (d), RUBY_UBF_IO, NULL)
+#elif defined(HAVE_RB_THREAD_BLOCKING_REGION)
+# define NOGVL(f, d) \
+   rb_thread_blocking_region(NOGVL_FUNCTION(f), (d), RUBY_UBF_IO, NULL)
+#else
+# include <rubysig.h>
+static inline VALUE
+fake_blocking_region(VALUE (*f)(ANYARGS), void *data)
+{
+  VALUE rv;
+
+  TRAP_BEG;
+  rv = f(data);
+  TRAP_END;
+
+  return rv;
+}
+# define NOGVL(f, d) fake_blocking_region(NOGVL_FUNCTION(f), (d))
+#endif
+
+#define MAGIC_SYNCHRONIZED(f, d) magic_lock(object, (f), (d))
+
+#define MAGIC_COOKIE(c) \
+    Data_Get_Struct(object, struct magic_set, (c))
+
+#define MAGIC_CLOSED_P(o) RTEST(rb_mgc_closed((o)))
+
+#define MAGIC_GENERIC_ERROR(k, e, m)                        \
+    do {                                                    \
+        VALUE __e_##k = magic_generic_error((k), (e), (m)); \
+        rb_exc_raise(__e_##k);                              \
+    } while(0)
+
+#define MAGIC_LIBRARY_ERROR(c)                                              \
+    do {                                                                    \
+        VALUE __e_library = magic_library_error(rb_mgc_eMagicError, (c));   \
+        rb_exc_raise(__e_library);                                          \
+    } while(0)
+
+#define CHECK_MAGIC_OPEN(o)                                         \
+    do {                                                            \
+        if (MAGIC_CLOSED_P(o)) {                                    \
+            MAGIC_GENERIC_ERROR(rb_mgc_eLibraryError, EFAULT,       \
+                                    error(E_MAGIC_LIBRARY_CLOSED)); \
+        }                                                           \
+    } while(0)                                                      \
+
+#define error(t) errors[(t)]
+
+enum error {
+    E_UNKNOWN = 0,
+    E_NOT_IMPLEMENTED,
+    E_MAGIC_LIBRARY_INITIALIZE,
+    E_MAGIC_LIBRARY_CLOSED,
+    E_FLAG_INVALID_VALUE,
+    E_FLAG_NOT_IMPLEMENTED
+};
+
+union file {
+    int fd;
+    const char *path;
+};
+
+struct buffer {
+    size_t size;
+    const char *buffer;
+};
+
+typedef union file file_t;
+typedef struct buffer buffer_t;
+
+struct magic_arguments {
+    int flags;
+    magic_t cookie;
+    union {
+        file_t file;
+        buffer_t buffer;
+    } data;
+};
+
+struct magic_exception {
+    int magic_errno;
+    const char *magic_error;
+    VALUE klass;
+};
+
+typedef struct magic_arguments magic_arguments_t;
+typedef struct magic_exception magic_exception_t;
+
+static const char *errors[] = {
+    "unknown error",
+    "function is not implemented",
+    "failed to initialize Magic library",
+    "Magic library is not open",
+    "unknown or invalid flag specified",
+    "flag is not implemented",
+    NULL
+};
+
+inline static VALUE
+magic_size(VALUE v)
+{
+    if (ARRAY_P(v) || STRING_P(v)) {
+        return rb_funcall(v, rb_intern("size"), 0, NULL);
+    }
+
+    return Qnil;
+}
+
+inline static VALUE
+magic_shift(VALUE v)
+{
+    if (ARRAY_P(v)) {
+        return rb_funcall(v, rb_intern("shift"), 0, NULL);
+    }
+
+    return Qnil;
+}
+
+inline static VALUE
+magic_split(VALUE a, VALUE b)
+{
+    if (STRING_P(a) && STRING_P(b)) {
+        return rb_funcall(a, rb_intern("split"), 1, b);
+    }
+
+    return Qnil;
+}
+
+inline static VALUE
+magic_join(VALUE a, VALUE b)
+{
+    if (ARRAY_P(a) && STRING_P(b)) {
+        return rb_funcall(a, rb_intern("join"), 1, b);
+    }
+
+    return Qnil;
+}
+
+RUBY_EXTERN ID id_at_flags, id_at_path, id_at_mutex;
+
+RUBY_EXTERN VALUE rb_cMagic;
+
+RUBY_EXTERN VALUE rb_mgc_eError;
+RUBY_EXTERN VALUE rb_mgc_eMagicError;
+RUBY_EXTERN VALUE rb_mgc_eLibraryError;
+RUBY_EXTERN VALUE rb_mgc_eFlagsError;
+RUBY_EXTERN VALUE rb_mgc_eNotImplementedError;
+
+RUBY_EXTERN VALUE rb_mgc_initialize(VALUE object, VALUE arguments);
+
+RUBY_EXTERN VALUE rb_mgc_close(VALUE object);
+RUBY_EXTERN VALUE rb_mgc_closed(VALUE object);
+
+RUBY_EXTERN VALUE rb_mgc_get_path(VALUE object);
+
+RUBY_EXTERN VALUE rb_mgc_get_flags(VALUE object);
+RUBY_EXTERN VALUE rb_mgc_set_flags(VALUE object, VALUE value);
+
+RUBY_EXTERN VALUE rb_mgc_load(VALUE object, VALUE arguments);
+RUBY_EXTERN VALUE rb_mgc_compile(VALUE object, VALUE arguments);
+RUBY_EXTERN VALUE rb_mgc_check(VALUE object, VALUE arguments);
+
+RUBY_EXTERN VALUE rb_mgc_file(VALUE object, VALUE value);
+RUBY_EXTERN VALUE rb_mgc_buffer(VALUE object, VALUE value);
+RUBY_EXTERN VALUE rb_mgc_descriptor(VALUE object, VALUE value);
+
+RUBY_EXTERN VALUE rb_mgc_version(VALUE object);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* _RUBY_MAGIC_H */
+
+/* vim: set ts=8 sw=4 sts=2 et : */

data/lib/magic/core/file.rb

@@ -0,0 +1,124 @@
+# -*- encoding: utf-8 -*-
+
+# :stopdoc:
+
+#
+# core/file.rb
+#
+# Copyright 2013-2014 Krzysztof Wilczynski
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# :startdoc:
+
+#
+#
+#
+class File
+  class << self
+    #
+    # call-seq:
+    #    File.magic( path ) -> string, array or nil
+    #
+    # Returns
+    #
+    # Example:
+    #
+    # See also: File::mime and File::type
+    #
+    def magic(path, flags = Magic::NONE)
+      path   = path.path    if path.respond_to?(:path)
+      path ||= path.to_path if path.respond_to?(:to_path)
+      path ||= path.to_s
+
+      Magic.open(flags) {|mgc| mgc.file(path) }
+    rescue Magic::Error
+    end
+
+    #
+    # call-seq:
+    #    File.mime( path ) -> string, array or nil
+    #
+    # Returns
+    #
+    # Example:
+    #
+    # See also: File::magic and File::type
+    #
+    def mime(path)
+      magic(path, Magic::MIME)
+    end
+
+    #
+    # call-seq:
+    #    File.type( path ) -> string, array or nil
+    #
+    # Returns
+    #
+    # Example:
+    #
+    # See also: File::magic and File::mime
+    #
+    def type(path)
+      magic(path, Magic::MIME_TYPE)
+    end
+  end
+
+  #
+  # call-seq:
+  #    File.magic( path ) -> string, array or nil
+  #
+  # Returns
+  #
+  # Example:
+  #
+  # See also: File#mime and File#type
+  #
+  def magic
+    self.class.magic(self)
+  end
+
+  #
+  # call-seq:
+  #    File.mime( path ) -> string, array or nil
+  #
+  # Returns
+  #
+  # Example:
+  #
+  # See also: File#magic and File#type
+  #
+  def mime
+    self.class.mime(self)
+  end
+
+  #
+  # call-seq:
+  #    File.type( path ) -> string, array or nil
+  #
+  # Returns
+  #
+  # Example:
+  #
+  # See also: File#magic and File#mime
+  #
+  def type
+    self.class.type(self)
+  end
+end
+
+# :enddoc:
+
+# vim: set ts=2 sw=2 sts=2 et :
+# encoding: utf-8

data/lib/magic/core/string.rb

@@ -0,0 +1,76 @@
+# -*- encoding: utf-8 -*-
+
+# :stopdoc:
+
+#
+# core/string.rb
+#
+# Copyright 2013-2014 Krzysztof Wilczynski
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# :startdoc:
+
+#
+#
+#
+class String
+  #
+  # call-seq:
+  #    string.magic -> string, array or nil
+  #
+  # Returns
+  #
+  # Example:
+  #
+  # See also: String#mime and String#type
+  #
+  def magic(flags = Magic::NONE)
+    Magic.open(flags) {|mgc| mgc.buffer(self) }
+  rescue Magic::Error
+  end
+
+  #
+  # call-seq:
+  #    string.mime -> string, array or nil
+  #
+  # Returns
+  #
+  # Example:
+  #
+  # See also: String#magic and String#type
+  #
+  def mime
+    magic(Magic::MIME)
+  end
+
+  #
+  # call-seq:
+  #    string.type -> string, array or nil
+  #
+  # Returns
+  #
+  # Example:
+  #
+  # See also: String#magic and String#mime
+  #
+  def type
+    magic(Magic::MIME_TYPE)
+  end
+end
+
+# :enddoc:
+
+# vim: set ts=2 sw=2 sts=2 et :
+# encoding: utf-8

data/lib/magic/version.rb

@@ -0,0 +1,76 @@
+# -*- encoding: utf-8 -*-
+
+# :stopdoc:
+
+#
+# version.rb
+#
+# Copyright 2013-2014 Krzysztof Wilczynski
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# :startdoc:
+
+class Magic
+  #
+  # Current version of _Magic_.
+  #
+  VERSION = '0.0.1'
+
+  class << self
+    #
+    # call-seq:
+    #    Magic.version_to_a -> array
+    #
+    # Returns
+    #
+    # Example:
+    #
+    #    Magic.version_to_a   #=> [5, 17]
+    #
+    # Will raise <i>Magic::NotImplementedError</i> exception if, or
+    #
+    # See also: Magic::version_to_s
+    #
+    def version_to_a
+      [self.version / 100, self.version % 100]
+    end
+
+    #
+    # call-seq:
+    #    Magic.version_to_s -> string
+    #
+    # Returns
+    #
+    # Example:
+    #
+    #    Magic.version_to_s   #=> "5.17"
+    #
+    # Will raise <i>Magic::NotImplementedError</i> exception if, or
+    #
+    # See also: Magic::version_to_a
+    #
+    def version_to_s
+      '%d.%02d' % self.version_to_a
+    end
+
+    alias_method :version_array,  :version_to_a
+    alias_method :version_string, :version_to_s
+  end
+end
+
+# :enddoc:
+
+# vim: set ts=2 sw=2 sts=2 et :
+# encoding: utf-8

data/lib/magic.rb

@@ -0,0 +1,204 @@
+# -*- encoding: utf-8 -*-
+
+# :stopdoc:
+
+#
+# magic.rb
+#
+# Copyright 2013-2014 Krzysztof Wilczynski
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'magic/magic'
+require 'magic/version'
+require 'magic/core/file'
+require 'magic/core/string'
+
+# :startdoc:
+
+#
+# File _Magic_ in Ruby.
+#
+# Simple interface to _libmagic_ for Ruby Programming Language.
+#
+class Magic
+  #
+  # call-seq:
+  #    magic.inspect -> string
+  #
+  # Returns
+  #
+  # Example:
+  #
+  #    magic = Magic.new   #=> #<Magic:0x007fd5258a1108>
+  #    magic.inspect       #=> "#<Magic:0x007fd5258a1108 @flags=0, @path=[\"/etc/magic\", \"/usr/share/misc/magic\"]>"
+  #
+  def inspect
+    super.insert(-2, self.closed? ? ' (closed)' : '')
+  end
+
+  #
+  # call-seq:
+  #    magic.flags_to_a( names ) -> array
+  #
+  # Returns an +array+
+  #
+  # Example:
+  #
+  # Will raise <i>Magic::LibraryError</i> exception if, or
+  #
+  # See also: Magic#flags
+  #
+  def flags_to_a(names = false)
+    raise LibraryError, "Magic library is not open" if closed?
+
+    n, i = 0, @flags
+
+    flags = []
+
+    return [names ? 'NONE' : 0] if @flags.zero?
+
+    @@flags_map ||= flags_as_map if names
+
+    while i > 0
+      n = 2 ** (Math.log(i) / Math.log(2)).to_i
+      i = i - n
+      flags.insert(0, names ? @@flags_map[n] : n)
+    end
+
+    flags
+  end
+
+  class << self
+    #
+    # call-seq:
+    #    Magic.open( flags )                  -> self
+    #    Magic.open( flags ) {|magic| block } -> string or array
+    #
+    # Returns
+    #
+    # Example:
+    #
+    # See also: Magic::mime, Magic::type, Magic::encoding, Magic::compile and Magic::check
+    #
+    def open(flags = Magic::NONE)
+      magic = Magic.new
+      magic.flags = flags
+
+      if block_given?
+        begin
+          yield magic
+        ensure
+          magic.close
+        end
+      else
+        magic
+      end
+    end
+
+    #
+    # call-seq:
+    #    Magic.mime                  -> self
+    #    Magic.mime {|magic| block } -> string or array
+    #
+    # Returns
+    #
+    # Example:
+    #
+    # See also: Magic::open, Magic::type, Magic::encoding, Magic::compile and Magic::check
+    #
+    def mime(&block)
+      open(Magic::MIME, &block)
+    end
+
+    #
+    # call-seq:
+    #    Magic.type                  -> self
+    #    Magic.type {|magic| block } -> string or array
+    #
+    # Returns
+    #
+    # Example:
+    #
+    # See also: Magic::open, Magic::mime, Magic::encoding, Magic::compile and Magic::check
+    #
+    def type(&block)
+      open(Magic::MIME_TYPE, &block)
+    end
+
+    #
+    # call-seq:
+    #    Magic.encoding                  -> self
+    #    Magic.encoding {|magic| block } -> string or array
+    #
+    # Returns
+    #
+    # Example:
+    #
+    # See also: Magic::open, Magic::mime, Magic::type, Magic::compile and Magic::check
+    #
+    def encoding(&block)
+      open(Magic::MIME_ENCODING, &block)
+    end
+
+    #
+    # call-seq:
+    #    Magic.compile( path, ... ) -> true
+    #    Magic.compile( array )     -> true
+    #
+    # Returns
+    #
+    # Example:
+    #
+    # See also: Magic::open, Magic::mime, Magic::type, Magic::encoding, and Magic::check
+    #
+    def compile(path)
+      open {|m| m.compile(path) }
+    end
+
+    #
+    # call-seq:
+    #    Magic.check( path, ... ) -> true or false
+    #    Magic.check( array )     -> true or false
+    #
+    # Returns
+    #
+    # Example:
+    #
+    # See also: Magic::open, Magic::mime, Magic::type, Magic::encoding and Magic::compile
+    #
+    def check(path)
+      open {|m| m.check(path) }
+    end
+  end
+
+  alias_method :flags_array, :flags_to_a
+
+  private
+
+  def flags_as_map
+    self.class.constants.inject({}) do |flags,constant|
+      value        = self.class.const_get(constant)
+      flags[value] = constant.to_s if value.is_a?(Fixnum)
+      flags
+    end
+  end
+end
+
+# :enddoc:
+
+FileMagic = Magic
+
+# vim: set ts=2 sw=2 sts=2 et :
+# encoding: utf-8