mm-attach-it 0.1.2

data/Gemfile

@@ -0,0 +1 @@
+source "http://rubygems.org"

data/LICENSE

@@ -0,0 +1,4 @@
+Copyright (c) 2010 Adilson Chacon
+
+Absolutely free. You can have the code, change, build another from this, whatever you want.
+

data/README

@@ -0,0 +1,172 @@
+= Mm-attach-it
+
+Attach files (images, videos, pdfs, txts, zips and etc) to a MongoMapper record. You can choose if you to store it on file system or GridFS.
+
+== Install
+
+  sudo gem install mm-attach-it
+
+== Usage
+
+=== Model
+
+Declare the plugin and use the attachment method to make attachments.
+
+  class Foo
+    include MongoMapper::Document
+    plugin AttachIt
+
+    has_attachment :photo
+  end
+
+The default storage is the file system, if you want to change for GridFS you should do:
+
+  class Bar
+    include MongoMapper::Document
+    plugin AttachIt
+
+    has_attachment :photo, { :storage => 'gridfs' }
+  end
+
+If you want to resize the images (you can store resized images on both: file system or GridFS)
+
+  class Foo
+    include MongoMapper::Document
+    plugin AttachIt
+
+    has_attachment :photo, { :styles => { :small => '100x100>', :medium => '200x200>' } }
+  end
+
+If you want to validate the attached file (again you can validate attaches on both: file system or GridFS)
+
+  class Foo
+    include MongoMapper::Document
+    plugin AttachIt
+
+    has_attch :photo
+
+    validates_attachment_presence :photo
+    validates_attachment_content_type: photo, :content_type => ['image/jpeg', 'image/gif', 'image/png']
+    validates_attachment_size :photo, { :less_than => 1.megabyte, :greater_than => 500.kilobytes }
+  end
+
+OBS: But remember, you can attach whatever kind of file!
+
+If you are using the file system to store the files you can specify the storage directory
+
+  class Foo
+    include MongoMapper::Document
+    plugin AttachIt
+
+    has_attachment :photo, { :path => '/:rails_root/public/images/foos/:id/:style/:filename' }
+  end
+
+OBS: The default directory is '/:rails_root/public/system/:attachment/:id/:style/:filename'
+
+Where:
+* :rails_root - is the root directory of your Rails application
+* :environment - can be "production", "test" or "development"
+* :class - the name of the class ('foo' the example above)
+* :attachment - is the name of the column's collection ('photo' the example above)
+* :id - the "id" of the record on MongoDB
+* :style - if you specified the styles
+* :filename - the name of the file
+* :extension - the extension of the file
+
+=== View
+
+Check the model below
+
+  class Foo
+    include MongoMapper::Document
+    plugin AttachIt
+
+    # on file system
+    has_attachment :photo, { 
+      :style => { :thumb => '100x100>' },
+      :url => '/assets/groups/:id/:style/:filename', 
+      :path => '/:rails_root/public/image/foos/:id/:style/:filename', :storage => 'gridfs',
+    }
+
+    # on GridFS
+    has_attachment :avatar, {
+      :style => { :thumb => '100x100>' }, 
+      :storage => 'gridfs', 
+    }
+  end
+
+On form you must set the "multipart" option and the field as "file_field":
+
+  <%= form_for(@foo, :html => { :multipart => true }) do |f| %>
+
+    <p>
+      <%= f.label :photo %>
+      <%= f.file_field :photo %>
+    </p>
+
+    <p>
+      <%= f.label :avatar %>
+      <%= f.file_field :avatar %>
+    </p>
+
+    <div class="actions">
+      <%= f.submit %>
+    </div>
+  <% end %>
+
+
+The safest way to show the images is using Base64, doesn't matter if you are using the file system or GridFS.
+
+  <img src="<%= foo.photo.base64 %>">
+  <img src="<%= foo.photo.base64('thumb') %>">
+
+  <img src="<%= foo.avatar.base64 %>">
+  <img src="<%= foo.avatar.base64('thumb') %>">
+
+Also, only for file system, if you specify the 'url' option you can do:
+
+  <%= image_tag foo.photo.url %>
+  <%= image_tag foo.photo.url('thumb') %>
+
+=== Controller
+
+If you are using the GridFS to store your files and youn don't want to use Base64 data to show the images you've got to create a action on a controller.
+
+But first create a new route on the route's file:
+  
+  match '/foos/avatar/:id(/:style)', :to => 'foos#avatar'
+  
+Now the controller:
+
+  class FoosController < ApplicationController
+
+    ...
+    
+    def avatar
+      foo = Foo.where('_id' => BSON::ObjectId(params[:id])).first
+      grid_io_data = (params[:style].nil?) ? foo.avatar.get_from_gridfs : foo.avatar.get_from_gridfs(params[:style])
+      bytes = grid_io_data.read
+      send_data(bytes, :type => foo.avatar_content_type, :disposition => 'inline')
+    end
+
+    ...
+
+  end
+
+And the view do that:
+  
+  <%= image_tag  "/foos/avatar/#{foo.id.to_s}/small" %>
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Adilson Chacon. See LICENSE for details.

data/README.rdoc

@@ -0,0 +1,172 @@
+= Mm-attach-it
+
+Attach files (images, videos, pdfs, txts, zips and etc) to a MongoMapper record. You can choose if you to store it on file system or GridFS.
+
+== Install
+
+  sudo gem install mm-attach-it
+
+== Usage
+
+=== Model
+
+Declare the plugin and use the attachment method to make attachments.
+
+  class Foo
+    include MongoMapper::Document
+    plugin AttachIt
+
+    has_attachment :photo
+  end
+
+The default storage is the file system, if you want to change for GridFS you should do:
+
+  class Bar
+    include MongoMapper::Document
+    plugin AttachIt
+
+    has_attachment :photo, { :storage => 'gridfs' }
+  end
+
+If you want to resize the images (you can store resized images on both: file system or GridFS)
+
+  class Foo
+    include MongoMapper::Document
+    plugin AttachIt
+
+    has_attachment :photo, { :styles => { :small => '100x100>', :medium => '200x200>' } }
+  end
+
+If you want to validate the attached file (again you can validate attaches on both: file system or GridFS)
+
+  class Foo
+    include MongoMapper::Document
+    plugin AttachIt
+
+    has_attch :photo
+
+    validates_attachment_presence :photo
+    validates_attachment_content_type: photo, :content_type => ['image/jpeg', 'image/gif', 'image/png']
+    validates_attachment_size :photo, { :less_than => 1.megabyte, :greater_than => 500.kilobytes }
+  end
+
+OBS: But remember, you can attach whatever kind of file!
+
+If you are using the file system to store the files you can specify the storage directory
+
+  class Foo
+    include MongoMapper::Document
+    plugin AttachIt
+
+    has_attachment :photo, { :path => '/:rails_root/public/images/foos/:id/:style/:filename' }
+  end
+
+OBS: The default directory is '/:rails_root/public/system/:attachment/:id/:style/:filename'
+
+Where:
+* :rails_root - is the root directory of your Rails application
+* :environment - can be "production", "test" or "development"
+* :class - the name of the class ('foo' the example above)
+* :attachment - is the name of the column's collection ('photo' the example above)
+* :id - the "id" of the record on MongoDB
+* :style - if you specified the styles
+* :filename - the name of the file
+* :extension - the extension of the file
+
+=== View
+
+Check the model below
+
+  class Foo
+    include MongoMapper::Document
+    plugin AttachIt
+
+    # on file system
+    has_attachment :photo, { 
+      :style => { :thumb => '100x100>' },
+      :url => '/assets/groups/:id/:style/:filename', 
+      :path => '/:rails_root/public/image/foos/:id/:style/:filename', :storage => 'gridfs',
+    }
+
+    # on GridFS
+    has_attachment :avatar, {
+      :style => { :thumb => '100x100>' }, 
+      :storage => 'gridfs', 
+    }
+  end
+
+On form you must set the "multipart" option and the field as "file_field":
+
+  <%= form_for(@foo, :html => { :multipart => true }) do |f| %>
+
+    <p>
+      <%= f.label :photo %>
+      <%= f.file_field :photo %>
+    </p>
+
+    <p>
+      <%= f.label :avatar %>
+      <%= f.file_field :avatar %>
+    </p>
+
+    <div class="actions">
+      <%= f.submit %>
+    </div>
+  <% end %>
+
+
+The safest way to show the images is using Base64, doesn't matter if you are using the file system or GridFS.
+
+  <img src="<%= foo.photo.base64 %>">
+  <img src="<%= foo.photo.base64('thumb') %>">
+
+  <img src="<%= foo.avatar.base64 %>">
+  <img src="<%= foo.avatar.base64('thumb') %>">
+
+Also, only for file system, if you specify the 'url' option you can do:
+
+  <%= image_tag foo.photo.url %>
+  <%= image_tag foo.photo.url('thumb') %>
+
+=== Controller
+
+If you are using the GridFS to store your files and youn don't want to use Base64 data to show the images you've got to create a action on a controller.
+
+But first create a new route on the route's file:
+  
+  match '/foos/avatar/:id(/:style)', :to => 'foos#avatar'
+  
+Now the controller:
+
+  class FoosController < ApplicationController
+
+    ...
+    
+    def avatar
+      foo = Foo.where('_id' => BSON::ObjectId(params[:id])).first
+      grid_io_data = (params[:style].nil?) ? foo.avatar.get_from_gridfs : foo.avatar.get_from_gridfs(params[:style])
+      bytes = grid_io_data.read
+      send_data(bytes, :type => foo.avatar_content_type, :disposition => 'inline')
+    end
+
+    ...
+
+  end
+
+And the view do that:
+  
+  <%= image_tag  "/foos/avatar/#{foo.id.to_s}/small" %>
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Adilson Chacon. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,3 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+

data/lib/attach_it/attach_it.rb

@@ -0,0 +1,83 @@
+module AttachIt
+
+  def self.configure(model)
+    model.class_eval do
+    end
+  end
+
+  module ClassMethods
+    def has_attachment(name, options = {})
+      options.symbolize_keys!
+      name = name.to_sym
+
+      after_save     :save_attachments
+      before_destroy :destroy_attachments
+
+      key :"#{name}_file_name", String
+      key :"#{name}_file_size", Integer
+      key :"#{name}_content_type", String
+      key :"#{name}_updated_at", Date
+
+      define_method("#{name}=") do |file|
+        information_for(name, options).assign(file)
+      end
+
+      define_method("#{name}") do
+        information_for(name, options)
+      end
+
+      validates_each name, :logic => lambda { information_for(name, options).send(:flush_errors) }
+    end
+
+    def validates_attachment_size(name = nil, options = {})
+      min     = options[:greater_than] || (options[:in] && options[:in].first) || 0
+      max     = options[:less_than]    || (options[:in] && options[:in].last)  || (1.0/0)
+      range   = (min..max)
+      message = options[:message] || "file size must be between :min and :max bytes"
+      message = message.gsub(/:min/, min.to_s).gsub(/:max/, max.to_s)
+
+      validates_inclusion_of :"#{name}_file_size",
+                             :within    => range,
+                             :message   => message,
+                             :allow_nil => true
+    end
+
+    def validates_attachment_presence(name = nil, options = {})
+      message = options[:message] || "must be set"
+      validates_presence_of :"#{name}_file_name",
+                            :message   => message,
+                            :if        => options[:if]
+    end
+
+    def validates_attachment_content_type(name = nil, options = {})
+      validation_options = options.dup
+      allowed_types = [validation_options[:content_type]].flatten
+      message = options[:message] || "is not one of #{allowed_types.join(", ")}"
+
+      validates_inclusion_of :"#{name}_content_type",
+                             :within    => allowed_types,
+                             :message   => message,
+                             :allow_nil => true
+    end
+  end
+
+  module InstanceMethods
+    def information_for(name = nil, options = nil)
+      @attachment_options ||= {}
+      @attachment_options[name] ||= AttachmentOptions.new(self, name, options)
+    end
+
+    def save_attachments
+      @attachment_options.keys.each do |name|
+        @attachment_options[name].save
+      end
+    end
+
+    def destroy_attachments
+      @attachment_options.keys.each do |name|
+        @attachment_options[name].delete
+      end
+    end
+
+  end
+end

data/lib/attach_it/attachment_options.rb

@@ -0,0 +1,169 @@
+require 'wand'
+
+class AttachmentOptions
+
+  attr_accessor :styles, :assigned_file, :object_id, :name
+
+  def initialize(model = nil, name = nil, options = {})
+    @model = model
+    @class_name = model.class.name.downcase
+    @object_id = model.id.to_s
+
+    @name = name
+    @attachment = name.to_s.downcase.pluralize
+
+    @url = set_url(options[:url], options[:default_url])
+    @path = set_path(options[:path])
+    @styles = set_styles(options[:styles])
+    @storage = set_storage(options[:storage])
+
+    if !@model.send("#{@name.to_s}_file_name").nil?
+      @filename = @model.send("#{@name.to_s}_file_name")
+      @extension = set_extension(@model.send("#{@name.to_s}_file_name"))
+    end
+
+    @queued_for_delete = set_queued_for_delete
+
+    @errors = Hash.new
+  end
+
+  def assign(file = nil)
+    @errors = {}
+
+    @filename = file_name(file)
+    @extension = set_extension(@filename)
+    file = file.tempfile if file.respond_to?(:tempfile)
+
+    @model.send("#{@name.to_s}_file_name=", @filename)
+    @model.send("#{@name.to_s}_file_size=", File.size(file))
+    @model.send("#{@name.to_s}_content_type=", Wand.wave(file.path))
+    @model.send("#{@name.to_s}_updated_at=", Time.now)
+
+    add_error('Could not resize file') unless file_is_resizale?
+  end
+
+  def url(style_name = 'original')
+    return nil unless @storage.is_a?(Filesystem)
+    interpolate(@url, style_name)
+  end
+
+  def path(style_name = 'original')
+    return nil unless @storage.is_a?(Filesystem)
+    interpolate(@path, style_name)
+  end
+
+  def save
+    unless @assigned_file.nil?
+      @storage.flush_delete(@queued_for_delete)
+      @storage.flush_write(self)
+      @queued_for_delete = set_queued_for_delete
+    end
+  end
+
+  def delete
+    @storage.flush_delete(@queued_for_delete)
+  end
+
+  def add_error(description = nil)
+    (@errors[:processing] ||= []) << description
+  end
+
+  def flush_errors
+    @errors.each do |error, message|
+      [message].flatten.each { |m| @model.errors.add(@name, m) }
+    end
+  end
+
+  def file_name(file = nil)
+    @assigned_file ||= file
+    @assigned_file.respond_to?(:original_filename) ? @assigned_file.original_filename : File.basename(@assigned_file.path)
+  end
+
+  def get_from_gridfs(style = 'original')
+    if @storage.is_a?(Gridfs)
+      @storage.read("#{@object_id}_#{@name}_#{style}")
+    else
+      nil
+    end
+  end
+
+  def base64(style = 'original')
+    begin
+      bytes = nil
+
+      if @storage.is_a?(Gridfs)
+        bytes = get_from_gridfs(style).read
+      elsif @storage.is_a?(Filesystem)
+        bytes = File.open(path(style), 'rb').read
+      end
+
+      'data:' + @model.send("#{@name.to_s}_content_type") + ';base64,' + Base64.encode64(bytes)
+    rescue Exception => exception
+      nil
+    end
+  end
+
+  private
+  def interpolate(source = nil, style_name = nil)
+    result = source.gsub(/\:rails_root/, Rails.root)
+    result.gsub!(/\:environment/, Rails.env)
+    result.gsub!(/\:filename/, @filename.nil? ? '' : @filename)
+    result.gsub!(/\:extension/, @extension.nil? ? '' : @extension)
+    result.gsub!(/\:style/, style_name.to_s)
+    result.gsub!(/\:id/, @object_id)
+    result.gsub!(/\:class/, @class_name)
+    result.gsub!(/\:attachment/, @attachment)
+    result.gsub!(/(\/){2,}/, '/')
+    result
+  end
+
+  def set_storage(storage_option = nil)
+    storage_option = 'filesystem' if storage_option.nil?
+    (storage_option == 'filesystem') ? Filesystem.new : Gridfs.new
+  end
+
+  def set_styles(style_option = nil)
+    style_option.nil? ? {} : style_option
+  end
+
+  def set_url(url_option = nil, default_url = nil)
+    @default_url = default_url
+    if url_option.nil?
+      (@default_url.nil? ? '/system/:attachment/:id/:style/:filename' : @default_url)
+    else
+      url_option
+    end
+  end
+
+  def set_path(path_option = nil)
+    path_option.nil? ? ':rails_root/public/system/:attachment/:id/:style/:filename' : path_option
+  end
+
+  def set_extension(source_path_option = nil)
+    source_path_option.nil? ? nil : File.extname(source_path_option)
+  end
+
+  def set_queued_for_delete
+    if @storage.is_a?(Filesystem)
+      [@styles.keys, :original].flatten.map do |style_name|
+        path(style_name) if File.exists?(path(style_name))
+      end.compact
+    else
+      [@styles.keys, :original].flatten.map do |style_name|
+        "#{@object_id}_#{@name}_#{style_name}"
+      end.compact
+    end
+  end
+
+  def file_is_resizale?
+    if @styles.keys.size > 0
+      begin
+        system("identify -format %wx%h #{@assigned_file.path}")
+      rescue Exception => exception
+        false
+      end
+    else
+      true
+    end
+  end
+end

data/lib/attach_it/storage/filesystem.rb

@@ -0,0 +1,30 @@
+class Filesystem < Storage
+
+  def flush_write(image_options = nil)
+    image_options.styles.each do |style_name, style_value|
+      begin        
+        FileUtils.mkdir_p(File.dirname(image_options.path(style_name)))
+        resize(style_value, image_options.assigned_file.path).write(image_options.path(style_name)) 
+        FileUtils.chmod(0644, image_options.path(style_name))
+      rescue Exception => exception
+        image_options.add_error(exception.to_s)
+      end
+    end
+
+    unless image_options.styles.has_key?(:original)
+      begin
+        FileUtils.mkdir_p(File.dirname(image_options.path(:original)))
+        FileUtils.cp(image_options.assigned_file.path, image_options.path(:original)) 
+      rescue Exception => exception
+        image_options.add_error(exception.to_s)
+      end
+    end
+  end
+
+  def flush_delete(queued_for_delete = nil)
+    queued_for_delete.each do |file|
+      FileUtils.rm(file) if File.exist?(file)
+    end
+  end
+
+end

data/lib/attach_it/storage/gridfs.rb

@@ -0,0 +1,34 @@
+class Gridfs < Storage
+
+  def initialize
+    @grid ||= Mongo::Grid.new(MongoMapper.database)
+  end
+
+  def flush_write(image_options = nil)
+    image_options.styles.each do |style_name, style_value|
+      begin
+        gridfs_id = @grid.put(resize(style_value, image_options.assigned_file.path).to_blob, :filename => style_name.to_s + '_' + image_options.file_name, :_id => "#{image_options.object_id}_#{image_options.name}_#{style_name}")
+      rescue Exception => exception
+        image_options.add_error(exception.to_s)
+      end
+    end
+
+    begin
+      gridfs_id = @grid.put(image_options.assigned_file, :filename => 'original_' + image_options.file_name, :_id => "#{image_options.object_id}_#{image_options.name}_original")
+    rescue Exception => exception
+      image_options.add_error(exception.to_s)
+    end
+
+  end
+
+  def flush_delete(queued_for_delete = nil)
+    queued_for_delete.each do |id|
+      @grid.delete(id)
+    end
+  end
+
+  def read(id = nil)    
+    @grid.get(id) unless id.nil?
+  end
+
+end

data/lib/attach_it/storage/storage.rb

@@ -0,0 +1,10 @@
+require 'RMagick'
+
+class Storage
+
+  def resize(style_value = nil, filename = nil)
+    new_image = Magick::Image.read(filename).first
+    new_image.change_geometry!(style_value) { |cols, rows, img| img.resize!(cols, rows) }
+  end
+
+end

data/lib/attach_it/storage.rb

@@ -0,0 +1,3 @@
+require File.join(File.dirname(__FILE__), 'storage/storage')
+require File.join(File.dirname(__FILE__), 'storage/filesystem')
+require File.join(File.dirname(__FILE__), 'storage/gridfs')

data/lib/attach_it/version.rb

@@ -0,0 +1,3 @@
+module AttachIt
+  Version = '0.1.2'
+end

data/lib/mm-attach-it.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), 'attach_it', 'version')
+require File.join(File.dirname(__FILE__), 'attach_it', 'attach_it')
+require File.join(File.dirname(__FILE__), 'attach_it', 'attachment_options')
+require File.join(File.dirname(__FILE__), 'attach_it', 'storage')
+

data/test/test_helper.rb

@@ -0,0 +1,134 @@
+require 'rubygems'
+require 'tempfile'
+require 'mongo_mapper'
+require 'shoulda'
+require 'mocha'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/mm_attach_it')
+
+MongoMapper.database = "testing_mm_attach_it"
+
+FakeRailsRoot = File.join(File.dirname(__FILE__) + '/tmp/')
+
+class Test::Unit::TestCase
+  def setup
+    public_dir = FakeRailsRoot + 'public/'
+    FileUtils.rm_rf(public_dir) if File.exist?(public_dir) 
+    FileUtils.mkdir_p(public_dir)
+    MongoMapper.database.collections.each(&:remove)
+  end
+end
+
+class UserOne
+  include MongoMapper::Document
+  plugin AttachIt
+  key :name, String
+  has_attachment :avatar
+end
+
+class UserTwo
+  include MongoMapper::Document
+  plugin AttachIt
+  key :name, String 
+  has_attachment :avatar, { :url => '/assets/users/:id/:filename', :path => ':rails_root/public/assets/users/:id/:filename' }
+end
+
+class UserThree
+  include MongoMapper::Document
+  plugin AttachIt
+  key :name, String 
+  has_attachment :avatar, { :styles => { :small => '150x150>', :medium => '300x300>' } }
+end
+
+class UserFour
+  include MongoMapper::Document
+  plugin AttachIt
+  key :name, String 
+  has_attachment :avatar, { :default_url => '/images/default/avatar.jpg' }
+end
+
+class UserFive
+  include MongoMapper::Document
+  plugin AttachIt
+  key :name, String 
+  has_attachment :avatar
+
+  validates_attachment_size :avatar, :less_than => 1.megabyte
+end
+
+class UserSix
+  include MongoMapper::Document
+  plugin AttachIt
+  key :name, String 
+  has_attachment :avatar
+
+  validates_attachment_size :avatar, :less_than => 90.kilobytes
+end
+
+class UserSeven
+  include MongoMapper::Document
+  plugin AttachIt
+  key :name, String 
+  has_attachment :avatar
+
+  validates_attachment_size :avatar, :greater_than => 90.kilobytes
+end
+
+class UserEight
+  include MongoMapper::Document
+  plugin AttachIt
+  key :name, String 
+  has_attachment :avatar
+
+  validates_attachment_size :avatar, :greater_than => 1.megabyte
+end
+
+class UserNine
+  include MongoMapper::Document
+  plugin AttachIt
+  key :name, String 
+  has_attachment :avatar
+
+  validates_attachment_presence :avatar
+end
+
+class UserTen
+  include MongoMapper::Document
+  plugin AttachIt
+  key :name, String 
+  has_attachment :avatar
+
+  validates_attachment_content_type :avatar, :content_type => ['image/gif', 'image/png']
+end
+
+class UserEleven
+  include MongoMapper::Document
+  plugin AttachIt
+  key :name, String 
+  has_attachment :avatar
+
+  validates_attachment_content_type :avatar, :content_type => ['image/jpg', 'image/jpeg']
+end
+
+class UserTwelve
+  include MongoMapper::Document
+  plugin AttachIt
+  key :name, String 
+  has_attachment :avatar, { :styles => { :small => '150x150>', :medium => '300x300>' }, :storage => 'gridfs' }
+end
+
+class DocumentOne
+  include MongoMapper::Document
+  plugin AttachIt
+  key :name, String
+  has_attachment :document
+end
+
+class Rails
+  def self.env
+    'test'
+  end
+
+  def self.root
+    File.join(File.dirname(__FILE__) + '/tmp/')
+  end
+end

data/test/unit/test_attach_it.rb

@@ -0,0 +1,289 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+JpgImageFile = File.join(File.dirname(__FILE__) + '/../fixtures/lake_moraine.jpg')
+PdfFile = File.join(File.dirname(__FILE__) + '/../fixtures/example.pdf')
+FakeImageFile = File.join(File.dirname(__FILE__) + '/../fixtures/fakeimage.jpg')
+
+class TestAttachIt < Test::Unit::TestCase
+  context "#initialize" do
+    setup do
+      @user = UserOne.new
+      @user.name = 'Myname'
+    end
+
+    should "set instance of image_options" do
+      assert_instance_of AttachmentOptions, @user.avatar
+    end
+  end
+
+  context "Attaching an image on file system" do
+    setup do
+      @user = UserOne.new
+      @user.name = 'Myname'
+      @user.avatar = File.open(JpgImageFile, 'rb')
+    end
+
+    should "respond with path and url methods with default value" do
+      destiny_file = Rails.root + 'public/system/avatars/' + @user.id.to_s + '/original/lake_moraine.jpg'
+      assert_equal(destiny_file, @user.avatar.path)
+
+      destiny_url = '/system/avatars/' + @user.id.to_s + '/original/lake_moraine.jpg'
+      assert_equal(destiny_url, @user.avatar.url)
+    end
+
+    should "create file and informations columns after save" do
+      destiny_file = Rails.root + 'public/system/avatars/' + @user.id.to_s + '/original/lake_moraine.jpg'
+      @user.save
+      assert(File.exist?(destiny_file))
+      assert_equal('lake_moraine.jpg', @user.avatar_file_name)
+      assert_equal('image/jpeg', @user.avatar_content_type)
+      assert_equal(102520, @user.avatar_file_size)
+      assert_instance_of(Date, @user.avatar_updated_at)
+    end
+
+    should "retreive correct informations" do
+      destiny_file = Rails.root + 'public/system/avatars/' + @user.id.to_s + '/original/lake_moraine.jpg'
+      destiny_url = '/system/avatars/' + @user.id.to_s + '/original/lake_moraine.jpg'
+
+      @user.save
+
+      saved_user = UserOne.find(@user.id.to_s)
+      assert_equal(destiny_file, saved_user.avatar.path)
+      assert_equal(destiny_url, saved_user.avatar.url)
+      assert_equal('lake_moraine.jpg', saved_user.avatar_file_name)
+      assert_equal(102520, saved_user.avatar_file_size)
+      assert_equal('image/jpeg', saved_user.avatar_content_type)
+      assert_instance_of(Date, saved_user.avatar_updated_at)
+      assert_equal(@user.avatar_updated_at, saved_user.avatar_updated_at)
+    end
+
+  end
+
+
+  context "Attaching not an image on file system" do
+    
+  end
+    setup do
+      @doc = DocumentOne.new
+      @doc.name = 'Mydocument'
+      @doc.document = File.open(PdfFile, 'rb')
+    end
+
+    should "respond with path and url methods with default value" do
+      destiny_file = Rails.root + 'public/system/documents/' + @doc.id.to_s + '/original/example.pdf'
+      assert_equal(destiny_file, @doc.document.path)
+
+      destiny_url = '/system/documents/' + @doc.id.to_s + '/original/example.pdf'
+      assert_equal(destiny_url, @doc.document.url)
+    end
+
+    should "create file and informations columns after save" do
+      destiny_file = Rails.root + 'public/system/documents/' + @doc.id.to_s + '/original/example.pdf'
+      @doc.save
+      assert(File.exist?(destiny_file))
+      assert_equal('example.pdf', @doc.document_file_name)
+      assert_equal('application/pdf', @doc.document_content_type)
+      assert_equal(9785, @doc.document_file_size)
+      assert_instance_of(Date, @doc.document_updated_at)
+    end
+
+    should "retreive correct informations from db" do
+      destiny_file = Rails.root + 'public/system/documents/' + @doc.id.to_s + '/original/example.pdf'
+      destiny_url = '/system/documents/' + @doc.id.to_s + '/original/example.pdf'
+
+      @doc.save
+
+      saved_doc = DocumentOne.find(@doc.id.to_s)
+      assert_equal(destiny_file, saved_doc.document.path)
+      assert_equal(destiny_url, saved_doc.document.url)
+      assert_equal('example.pdf', saved_doc.document_file_name)
+      assert_equal('application/pdf', saved_doc.document_content_type)
+      assert_equal(9785, saved_doc.document_file_size)
+      assert_instance_of(Date, saved_doc.document_updated_at)
+      assert_equal(@doc.document_updated_at, saved_doc.document_updated_at)
+    end
+  end
+  
+  context "Creating differents sizes from an image" do
+    setup do
+      @user = UserThree.new
+      @user.name = 'Myname'
+      @user.avatar = File.open(JpgImageFile, 'rb')
+    end
+
+    should "respond with path and url methods by styles" do
+      [:small, :medium, :original].each do |style|
+        destiny_file = Rails.root + 'public/system/avatars/' + @user.id.to_s + '/' + style.to_s + '/lake_moraine.jpg'
+        assert_equal(destiny_file, @user.avatar.path(style))
+
+        destiny_url = '/system/avatars/' + @user.id.to_s + '/' + style.to_s + '/lake_moraine.jpg'
+        assert_equal(destiny_url, @user.avatar.url(style))
+      end
+    end
+
+    should "create file after save by styles" do
+      @user.save
+      [:small, :medium, :original].each do |style|
+        destiny_file = Rails.root + 'public/system/avatars/' + @user.id.to_s + '/' + style.to_s + '/lake_moraine.jpg'
+        assert(File.exist?(destiny_file))
+      end
+    end
+
+    should "return the base64 from file" do
+      @user.save
+      assert_match(/^data:image\/jpeg;base64,/, @user.avatar.base64)
+      assert_match(/^data:image\/jpeg;base64,/, @user.avatar.base64('small'))
+      assert_match(/^data:image\/jpeg;base64,/, @user.avatar.base64('medium'))
+      assert_match(/^data:image\/jpeg;base64,/, @user.avatar.base64('original'))
+    end
+  end
+
+  context "Set the url and path" do
+    setup do
+      @user = UserTwo.new
+      @user.name = 'Myname'
+      @user.avatar = File.open(JpgImageFile, 'rb')
+    end
+
+    should "respond with path and url" do
+      destiny_file = Rails.root + 'public/assets/users/' + @user.id.to_s + '/lake_moraine.jpg'
+      assert_equal(destiny_file, @user.avatar.path)
+
+      destiny_url = '/assets/users/' + @user.id.to_s + '/lake_moraine.jpg'
+      assert_equal(destiny_url, @user.avatar.url)
+    end
+
+    should "retreive correct informations from db" do
+      destiny_file = Rails.root + 'public/assets/users/' + @user.id.to_s + '/lake_moraine.jpg'
+      destiny_url = '/assets/users/' + @user.id.to_s + '/lake_moraine.jpg'
+
+      @user.save
+
+      saved_user = UserTwo.find(@user.id.to_s)
+      assert_equal(destiny_file, saved_user.avatar.path)
+      assert_equal(destiny_url, saved_user.avatar.url)
+    end
+  end
+
+  context "Use default URL" do
+    setup do
+      @user = UserFour.new
+      @user.name = 'Myname'
+    end
+
+    should "retreive correct informations from db" do
+      destiny_url = '/images/default/avatar.jpg'
+
+      @user.save
+
+      saved_user = UserFour.find(@user.id.to_s)
+      assert_equal(destiny_url, saved_user.avatar.url)
+    end
+  end
+
+  context "Handle errors" do
+    setup do
+    end
+
+    should "have an error if file can't be resized" do
+      user = UserThree.new
+      user.name = 'Myname'
+      user.avatar = File.open(FakeImageFile)
+      user.save
+
+      assert_equal(user.errors.size, 1)
+      assert_equal(user.errors[:avatar].first, 'Could not resize file')
+    end
+
+    should "haven't an error if file size is less than a specific value" do
+      user = UserFive.new
+      user.name = 'Myname'
+      user.avatar = File.open(JpgImageFile, 'rb')
+      user.save
+
+      assert_equal(user.errors.size, 0)
+    end
+
+    should "have an error if file size is not less than a specific value" do
+      user = UserSix.new
+      user.name = 'Myname'
+      user.avatar = File.open(JpgImageFile, 'rb')
+      user.save
+
+      assert_equal(user.errors.size, 1)
+      assert_equal(user.errors[:avatar_file_size].first, 'file size must be between 0 and 92160 bytes')
+    end
+
+    should "haven't error if file size is greater than a specific value" do
+      user = UserSeven.new
+      user.name = 'Myname'
+      user.avatar = File.open(JpgImageFile, 'rb')
+      user.save
+
+      assert_equal(user.errors.size, 0)
+    end
+
+    should "have an error if file size is not greater than a specific value" do
+      user = UserEight.new
+      user.name = 'Myname'
+      user.avatar = File.open(JpgImageFile, 'rb')
+      user.save
+
+      assert_equal(user.errors.size, 1)
+      assert_equal(user.errors[:avatar_file_size].first, 'file size must be between 1048576 and Infinity bytes')
+    end
+
+    should "have an error if file size is not greater than a specific value" do
+      user = UserNine.new
+      user.name = 'Myname'
+      user.save
+
+      assert_equal(user.errors.size, 1)
+      assert_equal(user.errors[:avatar_file_name].first, 'must be set')
+    end
+
+    should "have an error if file content type is not one of the specifieds" do
+      user = UserTen.new
+      user.name = 'Myname'
+      user.avatar = File.open(JpgImageFile, 'rb')
+      user.save
+
+      assert_equal(user.errors.size, 1)
+      assert_equal(user.errors[:avatar_content_type].first, 'is not one of image/gif, image/png')
+    end
+
+    should "haven't error if file content type is one of the specifieds" do
+      user = UserEleven.new
+      user.name = 'Myname'
+      user.avatar = File.open(JpgImageFile, 'rb')
+      user.save
+
+      assert_equal(user.errors.size, 0)
+    end
+  end
+
+  context "Gridfs behavior" do
+    setup do
+      @user = UserTwelve.new
+      @user.name = 'Myname'
+      @user.avatar = File.open(JpgImageFile, 'rb')
+      @user.save
+    end
+
+    should "save the images resizeds and the original" do
+      assert_equal(@user.avatar.get_from_gridfs.class, Mongo::GridIO)
+      assert_equal(@user.avatar.get_from_gridfs('small').class, Mongo::GridIO)
+      assert_equal(@user.avatar.get_from_gridfs('medium').class, Mongo::GridIO)
+      assert_equal(@user.avatar.get_from_gridfs('original').class, Mongo::GridIO)
+    end
+
+    should "return the base64 from file" do
+      assert_match(/^data:image\/jpeg;base64,/, @user.avatar.base64)
+      assert_match(/^data:image\/jpeg;base64,/, @user.avatar.base64('small'))
+      assert_match(/^data:image\/jpeg;base64,/, @user.avatar.base64('medium'))
+      assert_match(/^data:image\/jpeg;base64,/, @user.avatar.base64('original'))
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification 
+name: mm-attach-it
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 2
+  version: 0.1.2
+platform: ruby
+authors: 
+- Adilson Chacon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-30 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: wand
+  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: mongo_mapper
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rmagick
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mime-types
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: Attach files (images, videos, pdfs, txts, zips and etc) to a MongoMapper record. You can choose if you to store it on file system or GridFS.
+email: adilsonchacon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- README.rdoc
+files: 
+- README
+- README.rdoc
+- LICENSE
+- Rakefile
+- Gemfile
+- lib/mm-attach-it.rb
+- lib/attach_it/version.rb
+- lib/attach_it/storage/gridfs.rb
+- lib/attach_it/storage/filesystem.rb
+- lib/attach_it/storage/storage.rb
+- lib/attach_it/attachment_options.rb
+- lib/attach_it/attach_it.rb
+- lib/attach_it/storage.rb
+- test/test_helper.rb
+- test/unit/test_attach_it.rb
+homepage: https://github.com/adilsonchacon/mm-attach-it
+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: 
+- ImageMagick
+rubyforge_project: mm-attach_it
+rubygems_version: 1.8.4
+signing_key: 
+specification_version: 3
+summary: MongoMapper Plugin File Attacher.
+test_files: 
+- test/unit/test_attach_it.rb
+- test/test_helper.rb