mongoid_grid 0.0.4

data/README.txt

@@ -0,0 +1,61 @@
+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. 
+  
+  # gem install mongoid_grid
+  
+  Or, make your own gem.
+  
+  # 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,169 @@
+require 'mime/types'
+require 'mongoid'
+module Mongoid
+  module Grid
+    
+    def self.included(base)
+      base.send(:extend,  ClassMethods)
+      base.send(:include, InstanceMethods)
+    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
+
+        ##
+        # 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
+        @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)
+          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)
+        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_attachment(name, send("#{name}_id"))
+        end
+      end
+      
+    end
+  end
+end

data/lib/rack/grid.rb

@@ -0,0 +1,68 @@
+require 'timeout'
+require 'mongo'
+
+module Rack
+  class Grid
+    class ConnectionError < StandardError ; end
+    
+    attr_reader :host, :port, :database, :prefix, :db, :username, :password
+
+    def initialize(app, options = {})
+      options = options.each do |k,v| 
+        if k.is_a?(Symbol)
+          options[k.to_s] = v
+          options.delete(k)
+        end
+      end
+      options = {
+        'host'    => 'localhost',
+        'prefix'  => 'grid',
+        'port'    => Mongo::Connection::DEFAULT_PORT
+      }.merge(options)
+      
+      @app        = app
+      @host       = options['host']
+      @port       = options['port']
+      @database   = options['database']
+      @prefix     = options['prefix']
+      @username   = options['username']
+      @password   = options['password']
+      @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(host,port).db(database)
+        db.authenticate(username, password) if (username || password)
+      end
+    rescue StandardError => e
+      raise ConnectionError, "Timeout connecting to GridFS (#{e.to_s})"
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: mongoid_grid
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 4
+  version: 0.0.4
+platform: ruby
+authors: 
+- Dusty Doris
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-11 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mime-types
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mongoid
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 4067859275
+        segments: 
+        - 2
+        - 0
+        - 0
+        - beta
+        - 16
+        version: 2.0.0.beta.16
+  type: :runtime
+  version_requirements: *id002
+description: Plugin for Mongoid to use GridFS and a Rack helper
+email: github@dusty.name
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- README.txt
+- lib/mongoid/grid.rb
+- lib/rack/grid.rb
+- test/test_mongoid_grid.rb
+- test/test_rack_grid.rb
+has_rdoc: true
+homepage: http://github.com/dusty/mongoid_grid
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: none
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Plugin for Mongoid to use GridFS and a Rack helper
+test_files: []
+