content_type 1.1.0

data/Rakefile

@@ -0,0 +1,38 @@
+require 'rake'
+require 'spec'
+require 'spec/rake/spectask'
+
+require 'vendor/gems/environment'
+
+task :default => [:clean, :make, :spec]
+
+task :make do
+  Dir.chdir 'ext' do
+    puts `ruby extconf.rb`
+    puts `make`
+  end
+end
+
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = %w(-fs -c)
+  t.spec_files = FileList['spec/*_spec.rb']
+end
+
+task :clean do
+  `rm -r *.o *.so *.bundle conftest.dSYM 2>/dev/null`
+end
+
+require 'jeweler'
+Jeweler::Tasks.new do |s|
+  s.name = 'content_type'
+  s.summary = 'libmagic bindings to quickly determine content type of files'
+  s.email = 'dsturnbull@me.com'
+  s.homepage = 'http://github.com/dsturnbull/content_type'
+  s.description =<<-eod
+      Provides ContentType#content_type, File#content_type and
+      File::content_type methods to determine mime type
+  eod
+  s.executables = []
+  s.authors = ['David Turnbull']
+  s.files = ['Rakefile', 'ext/content_type.c', 'ext/extconf.rb']
+end

data/ext/content_type.c

@@ -0,0 +1,117 @@
+#include "ruby.h"
+#include <magic.h>
+#include <stdio.h>
+#include <sys/stat.h>
+
+#define MAGIC_OPTIONS MAGIC_SYMLINK | MAGIC_MIME_TYPE | MAGIC_PRESERVE_ATIME
+
+VALUE content_type = Qnil;
+VALUE content_type_initialize(VALUE self, VALUE path);
+VALUE content_type_content_type(VALUE self);
+
+VALUE file_content_type_wrap(VALUE self, VALUE path);
+VALUE file_content_type(VALUE self);
+VALUE file_singleton_content_type(VALUE self, VALUE path);
+
+void magic_fail(const char *error);
+
+void
+Init_content_type()
+{
+    // class definition
+    content_type = rb_define_class("ContentType", rb_cObject);
+
+    // instance methods
+    rb_define_method(content_type, "initialize",   content_type_initialize, 1);
+    rb_define_method(content_type, "content_type", content_type_content_type, 0);
+
+    // instance attributes
+    rb_define_attr(content_type, "filepath",    1, 0);
+    rb_define_attr(content_type, "processed",   1, 0);
+
+    // hax on File
+    rb_define_method(rb_cFile,
+            "content_type", file_content_type, 0);
+    rb_define_singleton_method(rb_cFile,
+            "content_type", file_singleton_content_type, 1);
+}
+
+VALUE
+content_type_initialize(VALUE self, VALUE path)
+{
+    struct stat st;
+
+    SafeStringValue(path);
+
+    if ((stat(RSTRING_PTR(path), &st)) != 0)
+        rb_raise(rb_const_get(rb_cObject, rb_intern("ArgumentError")),
+                "invalid file");
+
+    rb_iv_set(self, "@content_type", rb_str_new("", 0));
+    rb_iv_set(self, "@filepath",     path);
+    rb_iv_set(self, "@processed",    Qfalse);
+
+    return self;
+}
+
+VALUE
+content_type_content_type(VALUE self)
+{
+    VALUE            ct;
+    struct magic_set *mh;
+    const char       *mime;
+
+    if (rb_iv_get(self, "@processed"))
+        return rb_iv_get(self, "@content_type");
+
+    if (!(mh = magic_open(MAGIC_OPTIONS)))
+        magic_fail("open");
+
+    if ((magic_load(mh, NULL)) != 0)
+        magic_fail("load");
+
+    if (!(mime = magic_file(mh, RSTRING_PTR(rb_iv_get(self, "@filepath")))))
+        magic_fail("file");
+
+    ct = rb_str_new(mime, strlen(mime));
+    rb_iv_set(self, "@content_type", ct);
+    rb_iv_set(self, "@processed", Qtrue);
+    magic_close(mh);
+
+    return ct;
+}
+
+VALUE
+file_content_type_wrap(VALUE self, VALUE path)
+{
+    VALUE ct, mime, args[1];
+
+    SafeStringValue(path);
+    args[0] = path;
+    ct = rb_class_new_instance(1, args, content_type);
+
+    return rb_funcall(ct, rb_intern("content_type"), 0);
+}
+
+VALUE
+file_content_type(VALUE self)
+{
+    return file_content_type_wrap(self, rb_funcall(self, rb_intern("path"), 0));
+}
+
+VALUE
+file_singleton_content_type(VALUE self, VALUE path)
+{
+    return file_content_type_wrap(self, path);
+}
+
+void
+magic_fail(const char *error)
+{
+    const char  *format = "magic_%s() error";
+    char        *error_message;
+
+    error_message = malloc(sizeof(char *) * (strlen(format) + strlen(error)));
+    sprintf((char *)error_message, format, error);
+    rb_raise(rb_const_get(rb_cObject, rb_intern("RuntimeError")), error_message);
+}

data/ext/extconf.rb

@@ -0,0 +1,8 @@
+require 'mkmf'
+extension_name = 'content_type'
+dir_config(extension_name)
+
+find_header('magic.h', '/opt/local/include')
+find_library('magic', 'magic_open', '/opt/local/lib')
+
+create_makefile(extension_name)

data/spec/content_type_spec.rb

@@ -0,0 +1,83 @@
+require 'rubygems'
+require 'should_be_faster'
+require 'tempfile'
+require 'ext/content_type'
+
+describe ContentType do
+  before do
+    @img = 'spec/fixtures/grindewald.jpg'
+    @pdf = 'spec/fixtures/pdftest.pdf'
+    @lzm = 'spec/fixtures/compressed.jpg.lz'
+  end
+
+  context 'initialising' do
+    it 'should take a file path' do
+      path = @img
+      ct = ContentType.new(path)
+      ct.filepath.should == path
+    end
+
+    it 'should check that the file exists' do
+      lambda {
+        ct = ContentType.new('poopstain')
+      }.should raise_error ArgumentError
+    end
+
+    it 'should memoize the content type' do
+      ct = ContentType.new(@img)
+      lambda {
+        ct.content_type.should == 'image/jpeg'
+      }.should change(ct, :processed).to(true)
+    end
+  end
+
+  context 'detecting mime type' do
+    it 'should detect images' do
+      ct = ContentType.new(@img)
+      ct.content_type.should == 'image/jpeg'
+    end
+
+    it 'should detect pdfs' do
+      ct = ContentType.new(@pdf)
+      ct.content_type.should == 'application/pdf'
+    end
+
+    it 'should detect lzma files' do
+      ct = ContentType.new(@lzm)
+      ct.content_type.should == 'application/x-lzip'
+    end
+  end
+
+  context 'comparing with shelling out' do
+    it 'should be much faster' do
+      shell = lambda { `file -i #{@img}` }
+      ext   = lambda { ContentType.new(@img).content_type }
+      ext.should be_at_least(5).times.faster_than(shell)
+    end
+
+    it 'should slower to reinstantiate' do
+      @ct = ContentType.new(@img)
+      memo = lambda { @ct.content_type }
+      kgo  = lambda { ContentType.new(@img).content_type }
+      kgo.should be_at_least(5).times.slower_than(memo, :iterations => 1000)
+    end
+  end
+
+  context 'when using the file class methods' do
+    it 'should have File.content_type(path)' do
+      File.content_type(@img).should == 'image/jpeg'
+    end
+
+    it 'should have File#content_type' do
+      File.open(@img).content_type.should == 'image/jpeg'
+    end
+
+    it 'should make it into tempfile' do
+      t = Tempfile.new('hi')
+      t.content_type.should == 'application/x-empty'
+      t << File.read(@img)
+      t.content_type.should == 'image/jpeg'
+      File.unlink(t.path)
+    end
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: content_type
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 1
+  - 0
+  version: 1.1.0
+platform: ruby
+authors: 
+- David Turnbull
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-16 00:00:00 +11:00
+default_executable: 
+dependencies: []
+
+description: "      Provides ContentType#content_type, File#content_type and\n      File::content_type methods to determine mime type\n"
+email: dsturnbull@me.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- ext/content_type.c
+- ext/extconf.rb
+has_rdoc: true
+homepage: http://github.com/dsturnbull/content_type
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: libmagic bindings to quickly determine content type of files
+test_files: 
+- spec/content_type_spec.rb