halfbyte-mongoid_grid 0.0.2

data/README.txt

@@ -0,0 +1,59 @@
+Mongoid::Grid / Rack::Grid
+
+  Mongoid::Grid is a plugin for mongoid that uses GridFS.  Heavily inspired
+  by grip (http://github.com/jnunemaker/grip)
+
+  Rack::Grid is used to serve a GridFS file from rack.  Mostly copied
+  from http://github.com/skinandbones/rack-gridfs
+  
+  Download the source at
+  http://github.com/dusty/mongoid_grid
+
+
+Installation
+
+  Put the libraries in your project however you want. 
+  
+  You could make a gem to install or use with bundler.
+  
+  # git clone http://github.com/dusty/mongoid_grid
+  # cd mongoid_grid
+  # gem build mongoid_grid.gemspec
+  
+  Then require the libraries you want to use.
+
+  require 'mongoid/grid'
+  require 'rack/grid'
+
+
+Usage
+
+  class Monkey
+    include Mongoid::Document
+    include Mongoid::Grid
+    field :name
+    attachment :image
+  end
+  
+  m = Monkey.create(:name => 'name')
+  
+  # To add an attachment
+  m.image = File.open('/tmp/me.jpg')
+  m.save
+  
+  # To remove an attachment
+  m.image = nil
+  m.save
+  
+  # To get the attachment
+  m.image.read
+  
+  # To use Rack::Grid with Sinatra
+  
+  configure do
+    use Rack::Grid, :database => 'my_db'
+  end
+  
+  <img src="<%= m.image_url %>" alt="<%= m.image_name %>" />
+  
+  

data/lib/mongoid/grid.rb

@@ -0,0 +1,182 @@
+require 'mime/types'
+require 'mongoid'
+require 'active_support/all'
+module Mongoid
+  module Grid
+    
+    def self.included(base)
+      base.send(:extend,  ClassMethods)
+      base.send(:include, InstanceMethods)
+      base.class_inheritable_accessor :attachment_types
+      base.attachment_types = []
+      
+    end
+  
+    module ClassMethods
+      
+      ##
+      # Declare an attachment for the object
+      #
+      # eg: attachment :image
+      def attachment(name,prefix='grid')
+        ##
+        # Callbacks to handle the attachment saving and deleting
+        after_save     :create_attachments
+        after_save     :delete_attachments
+        after_destroy  :destroy_attachments
+
+        ##
+        # Fields for the attachment.
+        #
+        # Only the _id is really needed, the others are helpful cached
+        # so you don't need to hit GridFS
+        field "#{name}_id".to_sym,   :type => BSON::ObjectID
+        field "#{name}_name".to_sym, :type => String
+        field "#{name}_size".to_sym, :type => Integer
+        field "#{name}_type".to_sym, :type => String
+
+        ##
+        # Add this name to the attachment_types
+        attachment_types.push(name).uniq!
+
+        ##
+        # Return the GridFS object.
+        # eg: image.filename, image.read
+        define_method(name) do
+          grid.get(attributes["#{name}_id"]) if attributes["#{name}_id"]
+        end
+        
+        ##
+        # Returns true if attachment exists.
+        # eg: image?
+        define_method("#{name}?") do
+          !!attributes["#{name}_id"]
+        end
+        
+        ##
+        # Create a method to set the attachment
+        # eg: object.image = File.open('/tmp/somefile.jpg')
+        define_method("#{name}=") do |file|
+          if file.respond_to?(:read)
+            send(:create_attachment, name, file)
+          else
+            send(:delete_attachment, name, send("#{name}_id"))
+          end
+        end
+        
+        ##
+        # Return the relative URL to the file for use with Rack::Grid
+        # eg: /grid/4ba69fde8c8f369a6e000003/somefile.png
+        define_method("#{name}_url") do
+          _id   = send("#{name}_id")
+          _name = send("#{name}_name")
+          ["/#{prefix}", _id, _name].join('/') if _id && _name
+        end
+
+      end
+      
+      ##
+      # Accessor to GridFS 
+      def grid
+        @grid ||= Mongo::Grid.new(Mongoid.database)
+      end
+      
+      ##
+      # # All the attachments types for this class
+      # def attachment_types
+      #   super + (@attachment_types ||= [])
+      # end
+      
+    end
+
+    module InstanceMethods
+      
+      private
+      ##
+      # Accessor to GridFS
+      def grid
+        @grid ||= self.class.grid
+      end
+      
+      ##
+      # Holds queue of attachments to create
+      def create_attachment_queue
+        @create_attachment_queue ||= {}
+      end
+      
+      ##
+      # Holds queue of attachments to delete
+      def delete_attachment_queue
+        @delete_attachment_queue ||= {}
+      end
+      
+      ##
+      # Attachments we need to add after save.
+      def create_attachment(name,file)
+        if file.respond_to?(:read)
+          filename = file.respond_to?(:original_filename) ? 
+                     file.original_filename : File.basename(file.path)
+          type = MIME::Types.type_for(filename).first
+          mime = type ? type.content_type : "application/octet-stream" 
+          send("#{name}_id=",   BSON::ObjectID.new) if attributes["#{name}_id"].nil?
+          send("#{name}_name=", filename)
+          send("#{name}_size=", File.size(file))
+          send("#{name}_type=", mime)
+          create_attachment_queue[name] = file
+        end
+      end
+      
+      ##
+      # Save an attachment to GridFS
+      def create_grid_attachment(name,file)
+        file.rewind if file.respond_to?(:rewind)
+        grid.delete(attributes["#{name}_id"])
+        grid.put(
+          file.read, 
+          :filename => attributes["#{name}_name"],
+          :content_type => attributes["#{name}_type"],
+          :_id => attributes["#{name}_id"]
+        )
+        create_attachment_queue.delete(name)
+      end
+      
+      ##
+      # Attachments we need to remove after save
+      def delete_attachment(name,id)
+        delete_attachment_queue[name] = id if id.is_a?(BSON::ObjectID)
+        send("#{name}_id=", nil)
+        send("#{name}_name=", nil)
+        send("#{name}_size=", nil)
+        send("#{name}_type=", nil)
+      end
+      
+      ##
+      # Delete an attachment from GridFS
+      def delete_grid_attachment(name,id)
+        grid.delete(id) if id.is_a?(BSON::ObjectID)
+        delete_attachment_queue.delete(name)
+      end
+      
+      ##
+      # Create attachments marked for creation
+      def create_attachments
+        create_attachment_queue.each {|k,v| create_grid_attachment(k,v)}
+      end
+      
+      ##
+      # Delete attachments marked for deletion
+      def delete_attachments
+        delete_attachment_queue.each {|k,v| delete_grid_attachment(k,v)}
+      end
+
+      ##
+      # Deletes all attachments from document
+      def destroy_attachments
+        self.class.attachment_types.each do |name| 
+          delete_grid_attachment(name, send("#{name}_id"))
+        end
+      end
+      
+    end
+  end
+end

data/lib/rack/grid.rb

@@ -0,0 +1,59 @@
+require 'timeout'
+require 'mongo'
+
+module Rack
+  class Grid
+    class ConnectionError < StandardError ; end
+    
+    attr_reader :hostname, :port, :database, :prefix, :db
+
+    def initialize(app, options = {})
+      options = {
+        :hostname => 'localhost',
+        :prefix   => 'grid',
+        :port     => Mongo::Connection::DEFAULT_PORT,
+      }.merge(options)
+
+      @app        = app
+      @hostname   = options[:hostname]
+      @port       = options[:port]
+      @database   = options[:database]
+      @prefix     = options[:prefix]
+      @db         = nil
+
+      connect!
+    end
+
+    ##
+    # Strip the _id out of the path.  This allows the user to send something
+    # like /grid/4ba69fde8c8f369a6e000003/filename.jpg to find the file
+    # with an id of 4ba69fde8c8f369a6e000003.
+    def call(env)
+      request = Rack::Request.new(env)
+      if request.path_info =~ /^\/#{prefix}\/(\w+).*$/
+        grid_request($1)
+      else
+        @app.call(env)
+      end
+    end
+
+    ##
+    # Get file from GridFS or return a 404
+    def grid_request(id)
+      file = Mongo::Grid.new(db).get(BSON::ObjectID.from_string(id))
+      [200, {'Content-Type' => file.content_type}, [file.read]]
+    rescue Mongo::GridError, BSON::InvalidObjectID
+      [404, {'Content-Type' => 'text/plain'}, ['File not found.']]
+    end
+
+    private
+    def connect!
+      Timeout::timeout(5) do
+        @db = Mongo::Connection.new(hostname).db(database)
+      end
+    rescue StandardError => e
+      raise ConnectionError, "Timeout connecting to GridFS (#{e.to_s})"
+    end
+    
+  end
+end

data/test/fixtures/test1.txt

@@ -0,0 +1 @@
+test1

data/test/fixtures/test2.txt

@@ -0,0 +1 @@
+test2

data/test/test_helper.rb

@@ -0,0 +1,45 @@
+require 'tempfile'
+require 'pp'
+require 'shoulda'
+#require 'matchy'
+require 'mocha'
+require 'mongoid'
+
+require File.expand_path(File.dirname(__FILE__) + '/../lib/mongoid/grid')
+
+Mongoid.configure do |config|
+  name = "mongoid_grid_test"
+  host = "localhost"
+  config.allow_dynamic_fields = false
+  config.master = Mongo::Connection.new.db(name)
+end
+
+class Test::Unit::TestCase
+  def setup
+    Mongoid.database.collections.each(&:remove)
+  end
+
+  def assert_difference(expression, difference = 1, message = nil, &block)
+    b      = block.send(:binding)
+    exps   = Array.wrap(expression)
+    before = exps.map { |e| eval(e, b) }
+    yield
+    exps.each_with_index do |e, i|
+      error = "#{e.inspect} didn't change by #{difference}"
+      error = "#{message}.\n#{error}" if message
+      assert_equal(before[i] + difference, eval(e, b), error)
+    end
+  end
+
+  def assert_no_difference(expression, message = nil, &block)
+    assert_difference(expression, 0, message, &block)
+  end
+
+  def assert_grid_difference(difference=1, &block)
+    assert_difference("Mongoid.database['fs.files'].find().count", difference, &block)
+  end
+
+  def assert_no_grid_difference(&block)
+    assert_grid_difference(0, &block)
+  end
+end

data/test/test_mongoid_grid.rb

@@ -0,0 +1,284 @@
+require 'test_helper'
+
+class Asset
+  include Mongoid::Document
+  include Mongoid::Grid
+
+  field :title, :type => String
+  attachment :image
+  attachment :file
+end
+
+class BaseModel
+  include Mongoid::Document
+  include Mongoid::Grid
+  attachment :file
+end
+
+class Image < BaseModel; attachment :image end
+class Video < BaseModel; attachment :video end
+
+module Mongoid::GridTestHelpers
+  def all_files
+    [@file, @image, @image2, @test1, @test2]
+  end
+
+  def rewind_files
+    all_files.each { |file| file.rewind }
+  end
+
+  def open_file(name)
+    File.open(File.join(File.dirname(__FILE__), 'fixtures', name), 'r')
+  end
+
+  def grid
+    @grid ||= Mongo::Grid.new(Mongoid.database)
+  end
+  
+  def key_names
+    [:id, :name, :type, :size]
+  end
+end
+
+class Mongoid::GridTest < Test::Unit::TestCase
+  include Mongoid::GridTestHelpers
+
+  def setup
+    super
+    @file   = open_file('unixref.pdf')
+    @image  = open_file('mr_t.jpg')
+    @image2 = open_file('harmony.png')
+    @test1  = open_file('test1.txt')
+    @test2  = open_file('test2.txt')
+  end
+
+  def teardown
+    all_files.each { |file| file.close }
+  end
+
+  context "Using Grid plugin" do
+    should "add each attachment to attachment_types" do
+      assert_equal [:image, :file], Asset.attachment_types
+    end
+
+    should "add keys for each attachment" do
+      key_names.each do |key|
+        assert Asset.fields.keys.include?("image_#{key}")
+        assert Asset.fields.keys.include?("file_#{key}")
+      end
+    end
+
+    context "with inheritance" do
+      should "add attachment to attachment_types" do
+        assert_equal [:file], BaseModel.attachment_types
+      end
+
+      should "inherit attachments from superclass, but not share other inherited class attachments" do
+        assert_equal [:file, :image], Image.attachment_types
+        assert_equal [:file, :video], Video.attachment_types
+      end
+
+      should "add inherit keys from superclass" do
+        key_names.each do |key|
+          assert BaseModel.fields.keys.include?("file_#{key}")
+          assert Image.fields.keys.include?("file_#{key}") 
+          assert Video.fields.keys.include?("file_#{key}")
+          assert Video.fields.keys.include?("video_#{key}")
+        end
+      end
+    end
+  end
+
+  context "Assigning new attachments to document" do
+    setup do
+      @doc = Asset.create(:image => @image, :file => @file)
+      rewind_files
+    end
+    subject { @doc }
+
+    should "assign GridFS content_type" do
+      assert_equal 'image/jpeg', grid.get(subject.image_id).content_type
+      assert_equal 'application/pdf', grid.get(subject.file_id).content_type
+    end
+
+    should "assign joint keys" do
+      assert_equal 13661, subject.image_size
+      assert_equal 68926, subject.file_size
+
+      assert_equal "image/jpeg", subject.image_type
+      assert_equal "application/pdf", subject.file_type
+
+      assert_not_nil subject.image_id
+      assert_not_nil subject.file_id
+
+      assert subject.image_id.instance_of?(BSON::ObjectID)
+      assert subject.file_id.instance_of?(BSON::ObjectID)
+    end
+
+    should "allow accessing keys through attachment proxy" do
+      assert_equal 13661, subject.image_size 
+      assert_equal 68926, subject.file_size
+
+      assert_equal "image/jpeg", subject.image_type
+      assert_equal "application/pdf", subject.file_type
+
+      assert_not_nil subject.image_id
+      assert_not_nil subject.file_id
+
+      # assert subject.image.id.instance_of?(BSON::ObjectID),
+      # assert subject.file.id.instance_of?(BSON::ObjectID)
+    end
+
+    should "proxy unknown methods to GridIO object" do
+      assert_equal subject.image_id, subject.image.files_id
+      assert_equal 'image/jpeg', subject.image.content_type
+      assert_equal 'mr_t.jpg', subject.image.filename
+      assert_equal 13661, subject.image.file_length
+    end
+
+    should "assign file name from path if original file name not available" do
+      assert_equal 'mr_t.jpg', subject.image_name
+      assert_equal 'unixref.pdf', subject.file_name
+    end
+
+    should "save attachment contents correctly" do
+      assert_equal @file.read, subject.file.read
+      assert_equal @image.read, subject.image.read
+    end
+
+    should "know that attachment exists" do
+      assert subject.image?
+      assert subject.file?
+    end
+
+    should "clear assigned attachments so they don't get uploaded twice" do
+      Mongo::Grid.any_instance.expects(:put).never
+      subject.save
+    end
+  end
+
+  context "Updating existing attachment" do
+    setup do
+      @doc = Asset.create(:file => @test1)
+      assert_no_grid_difference do
+        @doc.file = @test2
+        @doc.save!
+      end
+      rewind_files
+    end
+    subject { @doc }
+
+    should "not change attachment id" do
+      assert !subject.file_id_changed?
+    end
+
+    should "update keys" do
+      assert_equal 'test2.txt', subject.file_name
+      assert_equal "text/plain", subject.file_type
+      assert_equal 5, subject.file_size 
+    end
+
+    should "update GridFS" do
+      grid_obj = grid.get(subject.file_id)
+      assert_equal 'test2.txt', grid_obj.filename
+      assert_equal 'text/plain', grid_obj.content_type
+      assert_equal 5, grid_obj.file_length
+      assert_equal @test2.read, grid_obj.read
+    end
+  end
+
+  context "Updating document but not attachments" do
+    setup do
+      @doc = Asset.create(:image => @image)
+      @doc.update_attributes(:title => 'Updated')
+      @doc.reload
+      rewind_files
+    end
+    subject { @doc }
+
+    should "not affect attachment" do
+      assert_equal @image.read, subject.image.read
+    end
+
+    should "update document attributes" do
+      assert_equal('Updated', subject.title)
+    end
+  end
+
+  context "Assigning file where file pointer is not at beginning" do
+    setup do
+      @image.read
+      @doc = Asset.create(:image => @image)
+      @doc.reload
+      rewind_files
+    end
+    subject { @doc }
+
+    should "rewind and correctly store contents" do
+      assert_equal @image.read, subject.image.read
+    end
+  end
+
+  context "Setting attachment to nil" do
+    setup do
+      @doc = Asset.create(:image => @image)
+      rewind_files
+    end
+    subject { @doc }
+
+    should "delete attachment after save" do
+      assert_no_grid_difference   { subject.image = nil }
+      assert_grid_difference(-1)  { subject.save }
+    end
+
+    should "clear nil attachments after save and not attempt to delete again" do
+      Mongo::Grid.any_instance.expects(:delete).once
+      subject.image = nil
+      subject.save
+      Mongo::Grid.any_instance.expects(:delete).never
+      subject.save
+    end
+  end
+
+  context "Retrieving attachment that does not exist" do
+    setup do
+      @doc = Asset.create
+      rewind_files
+    end
+    subject { @doc }
+
+    should "know that the attachment is not present" do
+      assert !subject.image?
+    end
+
+    # should "raise Mongo::GridFileNotFound" do
+    #   assert_raises(Mongo::GridFileNotFound) { subject.image.read }
+    # end
+  end
+
+  context "Destroying a document" do
+    setup do
+      @doc = Asset.create(:image => @image)
+      rewind_files
+    end
+    subject { @doc }
+
+    should "remove files from grid fs as well" do
+      assert_grid_difference(-1) { subject.destroy }
+    end
+  end
+
+  context "Assigning file name" do
+    should "default to path" do
+      assert_equal 'mr_t.jpg', Asset.create(:image => @image).image_name
+    end
+
+    should "use original_filename if available" do
+      def @image.original_filename
+        'testing.txt'
+      end
+      doc = Asset.create(:image => @image)
+      assert_equal 'testing.txt', doc.image_name
+    end
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: halfbyte-mongoid_grid
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Jan Krutisch
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-24 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mime-types
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mongoid
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 9
+        version: "1.9"
+  type: :runtime
+  version_requirements: *id002
+description: Plugin for Mongoid to use GridFS and a Rack helper
+email: jan+mongoid-grid@krutisch.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- README.txt
+- lib/mongoid/grid.rb
+- lib/rack/grid.rb
+- test/test_helper.rb
+- test/test_mongoid_grid.rb
+- test/test_rack_grid.rb
+- test/fixtures/harmony.png
+- test/fixtures/mr_t.jpg
+- test/fixtures/test1.txt
+- test/fixtures/test2.txt
+- test/fixtures/unixref.pdf
+has_rdoc: true
+homepage: http://github.com/halfbyte/mongoid_grid
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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: none
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Plugin for Mongoid to use GridFS and a Rack helper
+test_files: []
+