carrierwave-mongoid 0.1.0

data/.gitignore

@@ -0,0 +1,6 @@
+pkg/*
+*.gem
+.bundle
+spec/public
+.rvmrc
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in carrierwave-mongoid.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,53 @@
+= CarrierWave for Mongoid
+
+This gem adds support for Mongoid and MongoDB's GridFS to CarrierWave, see the
+CarrierWave documentation for more detailed usage instructions.
+
+Install it like this:
+
+    gem install carrierwave-mongoid
+
+Use it like this:
+
+    require 'carrierwave/mongoid'
+
+Make sure to disable auto_validation on the mounted column.
+
+Using bundler:
+
+    gem 'carrierwave-mongoid', :require => 'carrierwave/mongoid'
+
+This used to be part of CarrierWave but has been extracted.
+
+== Using MongoDB's GridFS store
+
+You'll need to configure the database and host to use:
+
+    CarrierWave.configure do |config|
+      config.grid_fs_database = 'my_mongo_database'
+      config.grid_fs_host = 'mongo.example.com'
+    end
+
+The defaults are 'carrierwave' and 'localhost'.
+
+And then in your uploader, set the storage to <code>:grid_fs</code>:
+
+    class AvatarUploader < CarrierWave::Uploader::Base
+      storage :grid_fs
+    end
+
+Since GridFS doesn't make the files available via HTTP, you'll need to stream
+them yourself. In Rails for example, you could use the +send_data+ method. You
+can tell CarrierWave the URL you will serve your images from, allowing it to
+generate the correct URL, by setting eg:
+
+    CarrierWave.configure do |config|
+      config.grid_fs_access_url = "/image/show"
+    end
+
+== Known issues/ limitations
+
+If using Mongoid, note that embedded documents files aren't saved when parent documents are saved.
+You must explicitly call save on embedded documents in order to save their attached files.
+You can read more about this {here}[https://github.com/jnicklas/carrierwave/issues#issue/81]
+

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  #t.rspec_path = 'bin/rspec'
+  t.rspec_opts = %w[--color]
+end
+
+task :default => :spec

data/carrierwave-mongoid.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "carrierwave/mongoid/version"
+
+Gem::Specification.new do |s|
+  s.name        = "carrierwave-mongoid"
+  s.version     = Carrierwave::Mongoid::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jonas Nicklas", "Trevor Turk"]
+  s.email       = ["jonas.nicklas@gmail.com"]
+  s.homepage    = "https://github.com/jnicklas/carrierwave-mongoid"
+  s.summary     = %q{Mongoid support for CarrierWave}
+  s.description = %q{Mongoid support for CarrierWave}
+
+  s.rubyforge_project = "carrierwave-mongoid"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "carrierwave"
+  s.add_dependency "mongoid"
+  s.add_development_dependency "rspec", ["~> 2.0"]
+  s.add_development_dependency "bson_ext", ["> 1.3.0"]
+  s.add_development_dependency "sqlite3"
+end

data/lib/carrierwave/mongoid.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'mongoid'
+require 'carrierwave/validations/active_model'
+
+module CarrierWave
+  module Mongoid
+    include CarrierWave::Mount
+    ##
+    # See +CarrierWave::Mount#mount_uploader+ for documentation
+    #
+    def mount_uploader(column, uploader=nil, options={}, &block)
+      options[:mount_on] ||= "#{column}_filename"
+      field options[:mount_on]
+
+      super
+
+      alias_method :read_uploader, :read_attribute
+      alias_method :write_uploader, :write_attribute
+
+      include CarrierWave::Validations::ActiveModel
+
+      validates_integrity_of  column if uploader_option(column.to_sym, :validate_integrity)
+      validates_processing_of column if uploader_option(column.to_sym, :validate_processing)
+
+      after_save "store_#{column}!".to_sym
+      before_save "write_#{column}_identifier".to_sym
+      after_destroy "remove_#{column}!".to_sym
+    end
+  end # Mongoid
+end # CarrierWave
+
+Mongoid::Document::ClassMethods.send(:include, CarrierWave::Mongoid)

data/lib/carrierwave/mongoid/version.rb

@@ -0,0 +1,5 @@
+module Carrierwave
+  module Mongoid
+    VERSION = "0.1.0"
+  end
+end

data/lib/carrierwave/storage/grid_fs.rb

@@ -0,0 +1,136 @@
+# encoding: utf-8
+require 'mongo'
+
+module CarrierWave
+  module Storage
+
+    ##
+    # The GridFS store uses MongoDB's GridStore file storage system to store files
+    #
+    # There are two ways of configuring the GridFS connection. Either you create a
+    # connection or you reuse an existing connection.
+    #
+    # Creating a connection looks something like this:
+    #
+    #     CarrierWave.configure do |config|
+    #       config.storage = :grid_fs
+    #       config.grid_fs_host = "your-host.com"
+    #       config.grid_fs_port = "27017"
+    #       config.grid_fs_database = "your_dbs_app_name"
+    #       config.grid_fs_username = "user"
+    #       config.grid_fs_password = "verysecret"
+    #       config.grid_fs_access_url = "/images"
+    #     end
+    #
+    #   In the above example your documents url will look like:
+    #
+    #      http://your-app.com/images/:document-identifier-here
+    #
+    # When you already have a Mongo connection object (for example through Mongoid)
+    # you can also reuse this connection:
+    #
+    #     CarrierWave.configure do |config|
+    #       config.storage = :grid_fs
+    #       config.grid_fs_connection = Mongoid.database
+    #       config.grid_fs_access_url = "/images"
+    #     end
+    #
+    class GridFS < Abstract
+
+      class File
+
+        def initialize(uploader, path)
+          @path = path
+          @uploader = uploader
+        end
+
+        def path
+          @path
+        end
+
+        def url
+          unless @uploader.grid_fs_access_url
+            nil
+          else
+            [@uploader.grid_fs_access_url, @path].join("/")
+          end
+        end
+
+        def read
+          grid.open(@path, 'r').data
+        end
+
+        def write(file)
+          grid.open(@uploader.store_path, 'w', :content_type => file.content_type) do |f|
+            f.write(file.read)
+          end
+        end
+
+        def delete
+          grid.delete(@path)
+        end
+
+        def content_type
+          grid.open(@path, 'r').content_type
+        end
+
+        def file_length
+          grid.open(@path, 'r').file_length
+        end
+
+      protected
+
+        def database
+          @connection ||= @uploader.grid_fs_connection || begin
+            host = @uploader.grid_fs_host
+            port = @uploader.grid_fs_port
+            database = @uploader.grid_fs_database
+            username = @uploader.grid_fs_username
+            password = @uploader.grid_fs_password
+            db = Mongo::Connection.new(host, port).db(database)
+            db.authenticate(username, password) if username && password
+            db
+          end
+        end
+
+        def grid
+          @grid ||= Mongo::GridFileSystem.new(database)
+        end
+
+      end
+
+      ##
+      # Store the file in MongoDB's GridFS GridStore
+      #
+      # === Parameters
+      #
+      # [file (CarrierWave::SanitizedFile)] the file to store
+      #
+      # === Returns
+      #
+      # [CarrierWave::SanitizedFile] a sanitized file
+      #
+      def store!(file)
+        stored = CarrierWave::Storage::GridFS::File.new(uploader, uploader.store_path)
+        stored.write(file)
+        stored
+      end
+
+      ##
+      # Retrieve the file from MongoDB's GridFS GridStore
+      #
+      # === Parameters
+      #
+      # [identifier (String)] the filename of the file
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::GridFS::File] a sanitized file
+      #
+      def retrieve!(identifier)
+        CarrierWave::Storage::GridFS::File.new(uploader, uploader.store_path(identifier))
+      end
+
+    end # File
+  end # Storage
+end # CarrierWave

data/spec/fixtures/test.jpeg

@@ -0,0 +1 @@
+this is stuff

data/spec/fixtures/test.jpg

@@ -0,0 +1 @@
+this is stuff

data/spec/mongoid_spec.rb

@@ -0,0 +1,287 @@
+# encoding: utf-8
+require 'spec_helper'
+
+connection = Mongo::Connection.new
+Mongoid.database = connection.db("carrierwave_test")
+
+
+def reset_mongo_class(uploader = MongoUploader)
+  class_name = 'MongoUser'
+  Object.send(:remove_const, class_name) rescue nil
+  klass = Object.const_set(class_name, Class.new)
+  klass.class_eval do
+    include Mongoid::Document
+    store_in :users
+    mount_uploader :image, uploader
+  end
+  klass
+end
+
+class MongoUploader < CarrierWave::Uploader::Base; end
+
+class WhiteListUploader < CarrierWave::Uploader::Base
+  def extension_white_list
+    %w(txt)
+  end
+end
+
+class ProcessingErrorUploader < CarrierWave::Uploader::Base
+  process :monkey
+  def monkey
+    raise CarrierWave::ProcessingError, "Ohh noez!"
+  end
+  def extension_white_list
+    %w(jpg)
+  end
+end
+
+
+describe CarrierWave::Mongoid do
+
+  after do
+    MongoUser.collection.drop
+  end
+
+  describe '#image' do
+
+    context "when nothing is assigned" do
+
+      before do
+        mongo_user_klass = reset_mongo_class
+        @document = mongo_user_klass.new
+      end
+
+      it "returns a blank uploader" do
+        @document.image.should be_blank
+      end
+
+    end
+
+    context "when an empty string is assigned" do
+
+      before do
+        mongo_user_klass = reset_mongo_class
+        @document = mongo_user_klass.new(:image_filename => "")
+        @document.save
+      end
+
+      it "returns a blank uploader" do
+        @saved_doc = MongoUser.first
+        @saved_doc.image.should be_blank
+      end
+
+    end
+
+    context "when a filename is saved in the database" do
+
+      before do
+        mongo_user_klass = reset_mongo_class
+        @document = mongo_user_klass.new(:image_filename => "test.jpg")
+        @document.save
+        @doc = MongoUser.first
+      end
+
+      it "returns an uploader" do
+        @doc.image.should be_an_instance_of(MongoUploader)
+      end
+
+      it "sets the path to the store directory" do
+        @doc.image.current_path.should == public_path('uploads/test.jpg')
+      end
+
+    end
+
+  end
+
+  describe '#image=' do
+
+    before do
+      mongo_user_klass = reset_mongo_class
+      @doc = mongo_user_klass.new
+    end
+
+    context "when nil is assigned" do
+
+      it "does not set the value" do
+        @doc.image = nil
+        @doc.image.should be_blank
+      end
+
+    end
+
+    context "when an empty string is assigned" do
+
+      it "does not set the value" do
+        @doc.image = ''
+        @doc.image.should be_blank
+      end
+
+    end
+
+    context "when a file is assigned" do
+
+      it "should cache a file" do
+        @doc.image = stub_file('test.jpeg')
+        @doc.image.should be_an_instance_of(MongoUploader)
+      end
+
+      it "should write nothing to the database, to prevent overriden filenames to fail because of unassigned attributes" do
+        @doc.image_filename.should be_nil
+      end
+
+      it "should copy a file into into the cache directory" do
+        @doc.image = stub_file('test.jpeg')
+        @doc.image.current_path.should =~ /^#{public_path('uploads\/tmp')}/
+      end
+
+    end
+
+    context 'when validating integrity' do
+      before do
+        mongo_user_klass = reset_mongo_class(WhiteListUploader)
+        @doc = mongo_user_klass.new
+        @doc.image = stub_file('test.jpg')
+      end
+
+      it "should make the document invalid when an integrity error occurs" do
+        @doc.should_not be_valid
+      end
+
+      it "should use I18n for integrity error messages" do
+        @doc.valid?
+        @doc.errors[:image].should == ['is not an allowed file type']
+
+        change_locale_and_store_translations(:pt,
+          :errors => {
+            :messages => {
+              :carrierwave_integrity_error => 'tipo de imagem não permitido.'
+            }
+          }
+        ) do
+          @doc.should_not be_valid
+          @doc.errors[:image].should == ['tipo de imagem não permitido.']
+        end
+      end
+    end
+
+    context 'when validating processing' do
+      before do
+        mongo_user_klass = reset_mongo_class(ProcessingErrorUploader)
+        @doc = mongo_user_klass.new
+        @doc.image = stub_file('test.jpg')
+      end
+
+      it "should make the document invalid when a processing error occurs" do
+        @doc.should_not be_valid
+      end
+
+      it "should use I18n for processing error messages" do
+        @doc.valid?
+        @doc.errors[:image].should == ['failed to be processed']
+
+        change_locale_and_store_translations(:pt,
+          :errors => {
+            :messages => {
+              :carrierwave_processing_error => 'falha ao processar imagem.'
+            }
+          }
+        ) do
+          @doc.should_not be_valid
+          @doc.errors[:image].should == ['falha ao processar imagem.']
+        end
+      end
+    end
+
+  end
+
+  describe "#save" do
+
+    before do
+      mongo_user_klass = reset_mongo_class
+      @doc = mongo_user_klass.new
+    end
+
+    context "when no file is assigned" do
+
+      it "image is blank" do
+        @doc.save
+        @doc.image.should be_blank
+      end
+
+    end
+
+    context "when a file is assigned" do
+
+      it "copies the file to the upload directory" do
+        @doc.image = stub_file('test.jpg')
+        @doc.save
+        @doc.image.should be_an_instance_of(MongoUploader)
+        @doc.image.current_path.should == public_path('uploads/test.jpg')
+      end
+
+      it "saves the filename in the database" do
+        @doc.image = stub_file('test.jpg')
+        @doc.save
+        @doc.image_filename.should == 'test.jpg'
+      end
+
+      context "when remove_image? is true" do
+
+        it "removes the image" do
+          @doc.image = stub_file('test.jpeg')
+          @doc.save
+          @doc.remove_image = true
+          @doc.save
+          @doc.reload
+          @doc.image.should be_blank
+          @doc.image_filename.should == ''
+        end
+
+      end
+
+    end
+
+  end
+
+  describe '#destroy' do
+
+    before do
+      mongo_user_klass = reset_mongo_class
+      @doc = mongo_user_klass.new
+    end
+
+    describe "when file assigned" do
+
+      it "removes the file from the filesystem" do
+        @doc.image = stub_file('test.jpeg')
+        @doc.save.should be_true
+        File.exist?(public_path('uploads/test.jpeg')).should be_true
+        @doc.image.should be_an_instance_of(MongoUploader)
+        @doc.image.current_path.should == public_path('uploads/test.jpeg')
+        @doc.destroy
+        File.exist?(public_path('uploads/test.jpeg')).should be_false
+      end
+
+    end
+
+    describe "when file is not assigned" do
+
+      it "deletes the instance of MongoUser after save" do
+        @doc.save
+        MongoUser.count.should eql(1)
+        @doc.destroy
+      end
+
+      it "deletes the instance of MongoUser after save and then re-looking up the instance" do
+        @doc.save
+        MongoUser.count.should eql(1)
+        @doc = MongoUser.first
+        @doc.destroy
+      end
+
+    end
+
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec'
+require 'tempfile'
+
+require 'carrierwave'
+require 'carrierwave/mongoid'
+
+def file_path( *paths )
+  File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', *paths))
+end
+
+def public_path( *paths )
+  File.expand_path(File.join(File.dirname(__FILE__), 'public', *paths))
+end
+
+CarrierWave.root = public_path
+
+module CarrierWave
+  module Test
+    module MockFiles
+      def stub_file(filename, mime_type=nil, fake_name=nil)
+        f = File.open(file_path(filename))
+        return f
+      end
+
+      def stub_tempfile(filename, mime_type=nil, fake_name=nil)
+        raise "#{path} file does not exist" unless File.exist?(file_path(filename))
+
+        t = Tempfile.new(filename)
+        FileUtils.copy_file(file_path(filename), t.path)
+
+        # This is stupid, but for some reason rspec won't play nice...
+        eval <<-EOF
+        def t.original_filename; '#{fake_name || filename}'; end
+        def t.content_type; '#{mime_type}'; end
+        def t.local_path; path; end
+        EOF
+
+        return t
+      end
+    end
+
+    module I18nHelpers
+      def change_locale_and_store_translations(locale, translations, &block)
+        current_locale = I18n.locale
+        begin
+          I18n.backend.store_translations locale, translations
+          I18n.locale = locale
+          yield
+        ensure
+          I18n.reload!
+          I18n.locale = current_locale
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include CarrierWave::Test::MockFiles
+  config.include CarrierWave::Test::I18nHelpers
+end

data/spec/storage/grid_fs_spec.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'mongo'
+
+shared_examples_for "a GridFS connection" do
+  describe '#store!' do
+    before do
+      @uploader.stub!(:store_path).and_return('uploads/bar.txt')
+      @grid_fs_file = @storage.store!(@file)
+    end
+
+    it "should upload the file to gridfs" do
+      @grid.open('uploads/bar.txt', 'r').data.should == 'this is stuff'
+    end
+
+    it "should have the same path that it was stored as" do
+      @grid_fs_file.path.should == 'uploads/bar.txt'
+    end
+
+    it "should read the contents of the file" do
+      @grid_fs_file.read.should == "this is stuff"
+    end
+
+    it "should not have a URL" do
+      @grid_fs_file.url.should be_nil
+    end
+
+    it "should be deletable" do
+      @grid_fs_file.delete
+      lambda {@grid.open('uploads/bar.txt', 'r')}.should raise_error(Mongo::GridFileNotFound)
+    end
+
+    it "should store the content type on GridFS" do
+      @grid_fs_file.content_type.should == 'application/xml'
+    end
+
+    it "should have a file length" do
+      @grid_fs_file.file_length.should == 13
+    end
+
+  end
+
+  describe '#retrieve!' do
+    before do
+      @grid.open('uploads/bar.txt', 'w') { |f| f.write "A test, 1234" }
+      @uploader.stub!(:store_path).with('bar.txt').and_return('uploads/bar.txt')
+      @grid_fs_file = @storage.retrieve!('bar.txt')
+    end
+
+    it "should retrieve the file contents from gridfs" do
+      @grid_fs_file.read.chomp.should == "A test, 1234"
+    end
+
+    it "should have the same path that it was stored as" do
+      @grid_fs_file.path.should == 'uploads/bar.txt'
+    end
+
+    it "should not have a URL unless set" do
+      @grid_fs_file.url.should be_nil
+    end
+
+    it "should return a URL if configured" do
+      @uploader.stub!(:grid_fs_access_url).and_return("/image/show")
+      @grid_fs_file.url.should == "/image/show/uploads/bar.txt"
+    end
+
+    it "should be deletable" do
+      @grid_fs_file.delete
+      lambda {@grid.open('uploads/bar.txt', 'r')}.should raise_error(Mongo::GridFileNotFound)
+    end
+  end
+
+end
+
+describe CarrierWave::Storage::GridFS do
+
+  before do
+    @database = Mongo::Connection.new('localhost', 27017).db('carrierwave_test')
+
+    @uploader = mock('an uploader')
+    @uploader.stub!(:grid_fs_access_url).and_return(nil)
+  end
+
+  context "when reusing an existing connection manually" do
+    before do
+      @uploader.stub!(:grid_fs_connection).and_return(@database)
+
+      @grid = Mongo::GridFileSystem.new(@database)
+
+      @storage = CarrierWave::Storage::GridFS.new(@uploader)
+      @file = stub_tempfile('test.jpg', 'application/xml')
+    end
+
+    it_should_behave_like "a GridFS connection"
+
+    # Calling #recreate_versions! on uploaders has been known to fail on
+    # remotely hosted files. This is due to a variety of issues, but this test
+    # makes sure that there's no unnecessary errors during the process
+    describe "#recreate_versions!" do
+      before do
+        @uploader_class = Class.new(CarrierWave::Uploader::Base)
+        @uploader_class.class_eval do
+          storage :grid_fs
+        end
+
+        @versioned = @uploader_class.new
+        @versioned.stub!(:grid_fs_connection).and_return(@database)
+
+        @versioned.store! File.open(file_path('portrait.jpg'))
+      end
+
+      after do
+        FileUtils.rm_rf(public_path)
+      end
+
+      it "recreates versions stored remotely without error" do
+        lambda {
+          @versioned.recreate_versions!
+        }.should_not raise_error
+
+        @versioned.should be_present
+      end
+    end
+  end
+
+  context "when setting a connection manually" do
+    before do
+      @uploader.stub!(:grid_fs_database).and_return("carrierwave_test")
+      @uploader.stub!(:grid_fs_host).and_return("localhost")
+      @uploader.stub!(:grid_fs_port).and_return(27017)
+      @uploader.stub!(:grid_fs_username).and_return(nil)
+      @uploader.stub!(:grid_fs_password).and_return(nil)
+      @uploader.stub!(:grid_fs_connection).and_return(nil)
+
+      @grid = Mongo::GridFileSystem.new(@database)
+
+      @storage = CarrierWave::Storage::GridFS.new(@uploader)
+      @file = stub_tempfile('test.jpg', 'application/xml')
+    end
+
+    it_should_behave_like "a GridFS connection"
+  end
+
+  after do
+    @grid.delete('uploads/bar.txt')
+  end
+
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification 
+name: carrierwave-mongoid
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jonas Nicklas
+- Trevor Turk
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-12 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: carrierwave
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    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 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: bson_ext
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Mongoid support for CarrierWave
+email: 
+- jonas.nicklas@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- carrierwave-mongoid.gemspec
+- lib/carrierwave/mongoid.rb
+- lib/carrierwave/mongoid/version.rb
+- lib/carrierwave/storage/grid_fs.rb
+- spec/fixtures/portrait.jpg
+- spec/fixtures/test.jpeg
+- spec/fixtures/test.jpg
+- spec/mongoid_spec.rb
+- spec/spec_helper.rb
+- spec/storage/grid_fs_spec.rb
+has_rdoc: true
+homepage: https://github.com/jnicklas/carrierwave-mongoid
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: carrierwave-mongoid
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Mongoid support for CarrierWave
+test_files: 
+- spec/fixtures/portrait.jpg
+- spec/fixtures/test.jpeg
+- spec/fixtures/test.jpg
+- spec/mongoid_spec.rb
+- spec/spec_helper.rb
+- spec/storage/grid_fs_spec.rb