ruby-filemagic 0.6.2-x86-mswin32-60

data/ext/filemagic/filemagic.h

@@ -0,0 +1,98 @@
+#ifndef FILEMAGIC_H
+#define FILEMAGIC_H
+
+#include "ruby.h"
+#include <math.h>
+#include <errno.h>
+#include <magic.h>
+#ifdef HAVE_FILE_PATCHLEVEL_H
+#include <file/patchlevel.h>
+#endif
+
+#define GetMagicSet(obj, ms) {\
+  if (RTEST(rb_magic_closed_p(obj))) {\
+    rb_raise(rb_eRuntimeError, "closed stream");\
+  }\
+  else {\
+    Data_Get_Struct((obj), struct magic_set, (ms));\
+  }\
+}
+
+#define RB_MAGIC_TYPE_FILE   magic_file(ms, str)
+#define RB_MAGIC_TYPE_BUFFER magic_buffer(ms, str, RSTRING_LEN(arg))
+
+#define RB_MAGIC_TYPE(what, WHAT) \
+static VALUE \
+rb_magic_##what(int argc, VALUE *argv, VALUE self) {\
+  VALUE arg, simple, res;\
+  const char *str, *type;\
+  magic_t ms;\
+\
+  rb_scan_args(argc, argv, "11", &arg, &simple);\
+\
+  str = StringValuePtr(arg);\
+  GetMagicSet(self, ms);\
+\
+  if ((type = RB_MAGIC_TYPE_##WHAT) == NULL) {\
+    rb_raise(rb_FileMagicError, "failed lookup: %s", magic_error(ms));\
+  }\
+\
+  res = rb_str_new2(type);\
+\
+  if (NIL_P(simple)) {\
+    simple = rb_attr_get(self, rb_intern("@simplified"));\
+  }\
+\
+  if (RTEST(simple)) {\
+    rb_funcall(res, rb_intern("downcase!"), 0);\
+\
+    return rb_funcall(res, rb_intern("slice"), 2,\
+      rb_const_get(cFileMagic, rb_intern("SIMPLE_RE")), INT2FIX(1));\
+  }\
+  else {\
+    return res;\
+  }\
+}
+
+#define RB_MAGIC_APPRENTICE(what) \
+static VALUE \
+rb_magic_##what(int argc, VALUE *argv, VALUE self) {\
+  VALUE str;\
+  const char *file;\
+  magic_t ms;\
+\
+  file = rb_scan_args(argc, argv, "01", &str) == 1 ? StringValuePtr(str) : NULL;\
+\
+  GetMagicSet(self, ms);\
+\
+  return magic_##what(ms, file) ? Qfalse : Qtrue;\
+}
+
+#define RB_MAGIC_SET_VERSION(m, p) sprintf(version, "%d.%02d", m, p);
+
+static VALUE cFileMagic, rb_FileMagicError;
+
+static VALUE rb_magic_getpath(VALUE);
+static VALUE rb_magic_flags(VALUE, VALUE);
+
+static VALUE rb_magic_new(int, VALUE*, VALUE);
+static void rb_magic_free(magic_t);
+static VALUE rb_magic_init(int, VALUE*, VALUE);
+
+static VALUE rb_magic_close(VALUE);
+static VALUE rb_magic_closed_p(VALUE);
+
+static VALUE rb_magic_file(int, VALUE*, VALUE);
+static VALUE rb_magic_buffer(int, VALUE*, VALUE);
+
+static VALUE rb_magic_getflags(VALUE);
+static VALUE rb_magic_setflags(VALUE, VALUE);
+
+static VALUE rb_magic_list(int, VALUE*, VALUE);
+static VALUE rb_magic_load(int, VALUE*, VALUE);
+static VALUE rb_magic_check(int, VALUE*, VALUE);
+static VALUE rb_magic_compile(int, VALUE*, VALUE);
+
+void Init_ruby_filemagic(void);
+
+#endif /* FILEMAGIC_H */

data/lib/filemagic.rb

@@ -0,0 +1,142 @@
+begin
+  require "filemagic/#{RUBY_VERSION[/\d+.\d+/]}/ruby_filemagic"
+rescue LoadError => err
+  raise if err.respond_to?(:path) && !err.path
+  require 'filemagic/ruby_filemagic'
+end
+
+require 'filemagic/version'
+
+class FileMagic
+
+  DEFAULT_MAGIC = __FILE__.sub(/\.rb\z/, '/magic.mgc')
+
+  ENV['MAGIC'] ||= DEFAULT_MAGIC unless path
+
+  # Map flag names to their values (:name => Integer).
+  FLAGS_BY_SYM = [
+    :none,               # No flags
+    :debug,              # Turn on debugging
+    :symlink,            # Follow symlinks
+    :compress,           # Check inside compressed files
+    :devices,            # Look at the contents of devices
+    :mime_type,          # Return only the MIME type
+    :continue,           # Return all matches
+    :check,              # Print warnings to stderr
+    :preserve_atime,     # Restore access time on exit
+    :raw,                # Don't translate unprint chars
+    :error,              # Handle ENOENT etc as real errors
+    :mime_encoding,      # Return only the MIME encoding
+    :mime,               # MAGIC_MIME_TYPE | MAGIC_MIME_ENCODING
+    :apple,              # Return the Apple creator and type
+    :no_check_compress,  # Don't check for compressed files
+    :no_check_tar,       # Don't check for tar files
+    :no_check_soft,      # Don't check magic entries
+    :no_check_apptype,   # Don't check application type
+    :no_check_elf,       # Don't check for elf details
+    :no_check_text,      # Don't check for text files
+    :no_check_cdf,       # Don't check for cdf files
+    :no_check_tokens,    # Don't check ascii/tokens
+    :no_check_encoding,  # Don't check text encodings
+    :no_check_builtin,   # No built-in tests; only consult the magic file
+
+    # Defined for backwards compatibility (renamed)
+    :no_check_ascii,     # MAGIC_NO_CHECK_TEXT
+
+    # Defined for backwards compatibility; do nothing
+    :no_check_fortran,   # Don't check ascii/fortran
+    :no_check_troff      # Don't check ascii/troff
+  ].inject({}) { |flags, flag|
+    const = "MAGIC_#{flag.to_s.upcase}"
+    flags.update(flag => const_defined?(const) && const_get(const))
+  }
+
+  # Map flag values to their names (Integer => :name).
+  FLAGS_BY_INT = FLAGS_BY_SYM.invert.update(0 => :none)
+
+  # Extract "simple" MIME type.
+  SIMPLE_RE = %r{([.\w\/-]+)}
+
+  @fm = {}
+
+  class << self
+
+    # Provide a "magic singleton".
+    def fm(*flags)
+      options = flags.last.is_a?(Hash) ? flags.pop : {}
+
+      if fm = @fm[key = [flags = flags(flags), options]]
+        return fm unless fm.closed?
+      end
+
+      @fm[key] = new(flags, options)
+    end
+
+    # Clear our instance cache.
+    def clear!
+      @fm.each_value(&:close).clear
+    end
+
+    # Just like #new, but takes an optional block, in which case #close
+    # is called at the end and the value of the block is returned.
+    def open(*flags)
+      fm = new(*flags)
+
+      if block_given?
+        begin
+          yield fm
+        ensure
+          fm.close
+        end
+      else
+        fm
+      end
+    end
+
+    # Just a short-cut to #open with the +mime+ flag set.
+    def mime(*flags, &block)
+      open(:mime, *flags, &block)
+    end
+
+    def magic_version(default = MAGIC_VERSION)
+      default != '0' ? default :
+        user_magic_version ||
+        auto_magic_version ||
+        [default, 'unknown']
+    end
+
+    private
+
+    def user_magic_version(key = 'MAGIC_VERSION')
+      [ENV[key], 'user-specified'] if ENV[key]
+    end
+
+    def auto_magic_version
+      require 'nuggets/file/which'
+
+      if cmd = File.which_command([
+        'dpkg-query -f \'${Version}\' -W libmagic-dev',
+        'file -v'
+      ])
+        [%x{#{cmd}}[/\d+\.\d+/], 'auto-detected']
+      end
+    rescue LoadError
+    end
+
+  end
+
+  attr_writer :simplified
+
+  def simplified?
+    @simplified
+  end
+
+  def io(io, length = 8)
+    buffer(io.read(length))
+  end
+
+  def inspect
+    super.insert(-2, closed? ? ' (closed)' : '')
+  end
+
+end

data/lib/filemagic/ext.rb

@@ -0,0 +1,99 @@
+require 'filemagic'
+
+module FileMagic::Ext
+
+  def self.included(base)
+    base.class_eval {
+      extend ClassMethods
+      include InstanceMethods
+    }
+  end
+
+  module ClassMethods
+
+    def file_type(file, *flags)
+      raise NotImplementedError, 'must be implemented by including class'
+    end
+
+    def file(file, *flags)
+      file_type(file, *flags)
+    end
+
+    def mime_type(file, *flags)
+      file_type(file, *flags.unshift(:mime))
+    end
+
+    alias_method :mime, :mime_type
+
+    def content_type(file, *flags)
+      mime_type(file, *flags << { simplified: true })
+    end
+
+  end
+
+  module InstanceMethods
+
+    def file_type(*flags)
+      self.class.file_type(self, *flags)
+    end
+
+    alias_method :file, :file_type
+
+    def mime_type(*flags)
+      self.class.mime_type(self, *flags)
+    end
+
+    alias_method :mime, :mime_type
+
+    def content_type(*flags)
+      self.class.content_type(self, *flags)
+    end
+
+  end
+
+end
+
+class File
+
+  include FileMagic::Ext
+
+  def self.file_type(file, *flags)
+    FileMagic.fm(*flags).file(file.respond_to?(:path) ? file.path : file)
+  rescue FileMagic::FileMagicError
+  end
+
+end
+
+class String
+
+  include FileMagic::Ext
+
+  def self.file_type(string, *flags)
+    FileMagic.fm(*flags).buffer(string)
+  rescue FileMagic::FileMagicError
+  end
+
+end
+
+if $0 == __FILE__
+  f = __FILE__
+  p f
+
+  p File.file_type(f)
+  p File.mime_type(f)
+  p File.content_type(f)
+
+  f = File.new(f)
+  p f
+
+  p f.file_type
+  p f.mime_type
+  p f.content_type
+
+  s = '#! /usr/bin/ruby'
+  p s
+
+  p s.file_type
+  p s.mime_type
+  p s.content_type
+end

data/lib/filemagic/version.rb

@@ -0,0 +1,27 @@
+class FileMagic
+
+  module Version
+
+    MAJOR = 0
+    MINOR = 6
+    TINY  = 2
+
+    class << self
+
+      # Returns array representation.
+      def to_a
+        [MAJOR, MINOR, TINY]
+      end
+
+      # Short-cut for version string.
+      def to_s
+        to_a.join('.')
+      end
+
+    end
+
+  end
+
+  VERSION = Version.to_s
+
+end

data/lib/ruby-filemagic.rb

@@ -0,0 +1 @@
+require 'filemagic'

data/test/filemagic_test.rb

@@ -0,0 +1,227 @@
+require 'test/unit'
+require 'filemagic'
+
+class TestFileMagic < Test::Unit::TestCase
+
+  magic_version, origin = FileMagic.magic_version
+  MAGIC_VERSION = magic_version.to_f
+
+  warn <<-EOT
+
+libmagic version: #{MAGIC_VERSION}#{" (#{origin})" if origin}
+magic file from #{FileMagic.path}
+
+  EOT
+
+  def test_file
+    fm = FileMagic.new(FileMagic::MAGIC_NONE)
+
+    python_script = match_version(
+      0    => 'a python script, ASCII text executable',
+      5.11 => 'Python script, ASCII text executable'
+    )
+
+    res = fm.file(path_to('pyfile'))
+    assert_equal(python_script, res)
+
+    if File.symlink?(path_to('pylink'))
+      res = fm.file(path_to('pylink'))
+      assert_equal("symbolic link to `pyfile'", res.strip)
+    end
+
+    fm.close
+    fm = FileMagic.new(FileMagic::MAGIC_SYMLINK)
+
+    res = fm.file(path_to('pylink'))
+    assert_equal(python_script, res)
+
+    fm.close
+    fm = FileMagic.new(FileMagic::MAGIC_SYMLINK | FileMagic::MAGIC_MIME)
+
+    res = fm.file(path_to('pylink'))
+    assert_equal('text/plain; charset=us-ascii', res)
+
+    fm.close
+    fm = FileMagic.new(FileMagic::MAGIC_COMPRESS)
+
+    res = fm.file(path_to('pyfile-compressed.gz'))
+    gzip_compressed = 'gzip compressed data, was "pyfile-compressed"'
+    assert_match(Gem.win_platform? ? /^#{gzip_compressed}/ :
+                 /^#{python_script} \(#{gzip_compressed}/, res)
+
+    fm.close
+  end
+
+  def test_buffer
+    fm = FileMagic.new(FileMagic::MAGIC_NONE)
+    res = fm.buffer("#!/bin/sh\n")
+    fm.close
+    assert_equal('POSIX shell script, ASCII text executable', res)
+  end
+
+  def test_check
+    return if Gem.win_platform?
+    fm = FileMagic.new(FileMagic::MAGIC_NONE)
+    res = silence_stderr { fm.check(path_to('perl')) }
+    fm.close
+    assert(res)
+  end
+
+  def test_check_compiled
+    return if MAGIC_VERSION <= 5.09
+    fm = FileMagic.new(FileMagic::MAGIC_NONE)
+    res = silence_stderr { fm.check(path_to('perl.mgc')) }
+    fm.close
+    assert(res)
+  end
+
+  def test_compile
+    assert(File.writable?('.'), "can't write to current directory")
+    fm = FileMagic.new(FileMagic::MAGIC_NONE)
+    res = fm.compile(path_to('perl'))
+    fm.close
+    assert(res)
+    File.unlink(path_to('perl.mgc', '.'))
+  end
+
+  def test_block
+    block_fm = nil
+    res = FileMagic.open(FileMagic::MAGIC_NONE) { |fm|
+      block_fm = fm
+      fm.file(path_to('pyfile'))
+    }
+    assert_equal(match_version(
+      0    => 'a python script, ASCII text executable',
+      5.11 => 'Python script, ASCII text executable'
+    ), res)
+    assert block_fm.closed?
+  end
+
+  def test_flags_to_int
+    assert_raise(TypeError) { FileMagic.flags(0) }
+    assert_equal(0, FileMagic.flags([FileMagic::MAGIC_NONE]))
+    assert_equal(0, FileMagic.flags([:none]))
+    assert_equal(0, FileMagic.flags([]))
+    assert_equal(1072, FileMagic.flags([:mime, :continue]))
+  end
+
+  def test_setflags
+    fm = FileMagic.new(FileMagic::MAGIC_NONE)
+    assert_equal([], fm.flags)
+    fm.flags = FileMagic::MAGIC_SYMLINK
+    assert_equal([:symlink], fm.flags)
+    fm.close
+  end
+
+  def test_abbr
+    fm = FileMagic.new(:mime, :continue)
+    assert_equal([:mime_type, :continue, :mime_encoding], fm.flags)
+    fm.flags = :symlink
+    assert_equal([:symlink], fm.flags)
+    fm.close
+  end
+
+  def test_close
+    fm = FileMagic.new
+    fm.close
+    assert fm.closed?
+    fm.close
+    assert fm.closed?
+  end
+
+  # tests adapted from mahoro:
+
+  def test_mahoro_file
+    fm = FileMagic.new
+    fm.flags = FileMagic::MAGIC_NONE
+    assert_equal(match_version(
+      0    => 'ASCII C program text',
+      5.11 => 'C source, ASCII text'
+    ), fm.file(path_to('mahoro.c')))
+  end
+
+  def test_mahoro_mime_file
+    fm = FileMagic.new
+    fm.flags = FileMagic::MAGIC_MIME
+    assert_equal('text/x-c; charset=us-ascii', fm.file(path_to('mahoro.c')))
+  end
+
+  def test_mahoro_buffer
+    fm = FileMagic.new
+    fm.flags = FileMagic::MAGIC_NONE
+    assert_equal(match_version(
+      0    => 'ASCII C program text',
+      5.11 => 'C source, ASCII text'
+    ), fm.buffer(File.read(path_to('mahoro.c'))))
+  end
+
+  def test_mahoro_mime_buffer
+    fm = FileMagic.new
+    fm.flags = FileMagic::MAGIC_MIME
+    assert_equal('text/x-c; charset=us-ascii', fm.buffer(File.read(path_to('mahoro.c'))))
+  end
+
+  def test_mahoro_valid
+    fm = FileMagic.new
+    assert(silence_stderr { fm.valid? }, 'Default database was not valid.')
+  end
+
+  # test abbreviating mime types
+
+  def test_abbrev_mime_type
+    fm = FileMagic.mime
+
+    refute fm.simplified?
+    assert_equal('text/plain; charset=us-ascii', fm.file(path_to('perl')))
+
+    fm.simplified = true
+    assert fm.simplified?
+    assert_equal('text/plain', fm.file(path_to('perl')))
+    assert_equal(match_version(
+      0    => 'application/vnd.ms-office',
+      5.11 => 'application/msword',
+      5.14 => 'application/vnd.ms-office'
+    ), fm.file(path_to('excel-example.xls')))
+  end
+
+  def test_singleton
+    fm1 = FileMagic.fm
+    assert_equal(fm1, FileMagic.fm)
+
+    refute fm1.simplified?
+    assert_equal('ASCII text', fm1.file(path_to('perl')))
+
+    fm2 = FileMagic.fm(:mime)
+    assert_equal(fm2, FileMagic.fm(:mime))
+    refute_equal(fm2, fm1)
+
+    refute fm2.simplified?
+    assert_equal('text/plain; charset=us-ascii', fm2.file(path_to('perl')))
+
+    fm3 = FileMagic.fm(:mime, simplified: true)
+    assert_equal(fm3, FileMagic.fm(:mime, simplified: true))
+    refute_equal(fm3, fm2)
+    refute_equal(fm3, fm1)
+
+    assert fm3.simplified?
+    assert_equal('text/plain', fm3.file(path_to('perl')))
+  end
+
+  # utility methods:
+
+  def path_to(file, dir = File.dirname(__FILE__))
+    File.join(dir, file)
+  end
+
+  def silence_stderr
+    require 'nuggets/io/redirect'
+    $stderr.redirect { yield }
+  rescue LoadError
+    yield
+  end
+
+  def match_version(versions)
+    versions.sort_by { |k,| -k }.find { |k,| k <= MAGIC_VERSION }.last
+  end
+
+end