simpleweb/carrierwave-mongoid

Name: carrierwave-mongoid

Owner: Simpleweb

Description: Mongoid support for CarrierWave

Created: 2013-07-02 09:03:00.0

Updated: 2013-07-02 09:15:16.0

Pushed: 2013-07-02 09:15:16.0

Homepage:

Size: 210

Language: Ruby

GitHub Committers

User	Most Recent Commit	# Commits

Other Committers

User	Email	Most Recent Commit	# Commits

README

CarrierWave for Mongoid

This gem adds support for Mongoid and MongoDB's GridFS to CarrierWave

This functionality used to be part of CarrierWave but has since been extracted into this gem.

Installation

Install the latest release:

gem install carrierwave-mongoid

Require it in your code:

ire 'carrierwave/mongoid'

Or, in Rails you can add it to your Gemfile:

'carrierwave-mongoid', :require => 'carrierwave/mongoid'

Getting Started

Follow the “Getting Started” directions in the main Carrierwave repository.

[Suggested] Add the field to your attr_accessor list for mass assignment protection:

_accessible :avatar, :avatar_cache

Now you can cache files by assigning them to the attribute; they will automatically be stored when the record is saved. Ex:

User.new
atar = File.open('somewhere')
ve!

Using MongoDB's GridFS store

In your uploader, set the storage to :grid_fs:

s AvatarUploader < CarrierWave::Uploader::Base
orage :grid_fs

Bringing it all together, you can also configure Carrierwave to use Mongoid's database connection and default all storage to GridFS. That might look something like this:

ierWave.configure do |config|
nfig.storage = :grid_fs
nfig.root = Rails.root.join('tmp')
nfig.cache_dir = "uploads"

Serving uploading files

Since GridFS doesn't make the files available via HTTP, you'll need to stream them yourself. For example, in Rails, you could use the send_data method:

s UsersController < ApplicationController
f avatar
content = @user.avatar.read
if stale?(etag: content, last_modified: @user.updated_at.utc, public: true)
  send_data content, type: @user.avatar.file.content_type, disposition: "inline"
  expires_in 0, public: true
end
d


d in routes.rb
urces :users do
t :avatar, on: :member

You can optionally tell CarrierWave the URL you will serve your images from, allowing it to generate the correct URL, by setting grid_fs_access_url:

ierWave.configure do |config|
nfig.grid_fs_access_url = "/systems/uploads"

Route configuration

If you follow the instruction to this point, the uploaded images will be stored to GridFS, and you are responsible for serving the images a public endpoint. If you would like to use the #url method on the uploaded file, you will need to take some additional steps.

The grid_fs_access_url configuration option is the prefix for the path of the stored file in carrierwave.

Let's assume that we have a mounted avatar uploader on a User model and a GridfsController. Let's also assume that your uploader definition (i.e. app/uploaders/avatar_uploader.rb) defines store_dir like this:

store_dir
{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"

If grid_fs_access_url (in config/initializers/carrierwave.rb) were:

ig.grid_fs_access_url = '/uploads/grid'

You would need to define a route in your config/routes.rb like so:

h '/uploads/grid/user/avatar/:id/:filename' => 'gridfs#avatar'

Now, user.avatar.url should return an appropriate url path to use in your views.

Different uploaded versions

If you need to include different versions (e.g. thumbnails), additional routes will help:

h '/uploads/grid/user/avatar/:id/:filename' => 'gridfs#thumb_avatar', constraints: { filename: /thumb.*/ }

Version differences

| Version | Notes | |———-|———————————————————————————| | ~> 0.6.0 | (compare, dependencies) Mongoid 3 & 4, bug fixes | | ~> 0.5.0 | (compare, dependencies) Mongoid::Paranoia support | | ~> 0.4.0 | (compare, dependencies) Carrierwave bump | | ~> 0.3.0 | (compare, dependencies) Mongoid >= 3.0 | | ~> 0.2.0 | (compare, dependencies) Rails >= 3.2, Mongoid ~> 2.0 | | ~> 0.1.0 | (compare, dependencies) Rails <= 3.1 |

Changes from earlier versions of CarrierWave <= 0.5.6

CarrierWave used to have built-in Mongoid support. This gem replaces that support and only supports Mongoid ~> 2.1

You can use upload_identifier to retrieve the original name of the uploaded file.

In the earlier version, the mount_uploader-method for mongoid had been defined in lib/carrierwave/orm/mongoid. This code has been moved to carrierwave/mongoid. If you update from earlier versions, don't forget to adjust your require accordingly in your carrierwave-initializer.

The default mount column used to be the name of the upload column plus _filename. Now it is simply the name of the column. Most of the time, the column was called upload, so it would have been mounted to upload_filename. If you'd like to avoid a database migration, simply use the :mount_on option to specify the field name explicitly. Therefore, you only have to add a _filename to your column name. For example, if your column is called :upload:

s Dokument
unt_uploader :upload, DokumentUploader, mount_on: :upload_filename

Known issues and limitations

Note that files mounted in embedded documents aren't saved when parent documents are saved. By default, mongoid does not cascade callbacks on embedded documents. In order to save the attached files on embedded documents, you must either explicitly call save on the embedded documents or you must configure the embedded association to cascade the callbacks automatically. For example:

s User
beds_many :pictures, cascade_callbacks: true

You can read more about this here