glebtv-carrierwave-mongoid 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b123e28179c988419a4b691e9ef8a7a5c28561c0
+  data.tar.gz: 8a80da6aadf2c2c22515575d9198d1b76ed348e6
+SHA512:
+  metadata.gz: 1807b69bd7c9cb3eabd0f2ba04d440aafeb5aadbc5a314cf70f7e3479d22c4f092d09710e425b442b4425e214ea8e69611695ed3ee45cf49097565bb2eb52e9c
+  data.tar.gz: 990e56ff5543e2749247c1aca0783a5a8a18bd5d787d0957df91db9bfb07a937d9901d642b316bc99e1de9708df0c88b6bb4b3a99566f1ebb9db6ab329e2993e

data/.gitignore

@@ -0,0 +1,10 @@
+pkg/*
+*.gem
+*.sw*
+.bundle
+spec/public
+.rvmrc
+.ruby-version
+Gemfile.lock
+gemfiles/*.lock
+log/*

data/.ruby-gemset

@@ -0,0 +1 @@
+glebtv-carrierwave-mongoid

data/.travis.yml

@@ -0,0 +1,18 @@
+services: mongodb
+
+notifications:
+  email: false
+
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode
+  - rbx-19mode
+
+gemfile:
+  - Gemfile
+  - gemfiles/carrierwave-master.gemfile
+  - gemfiles/mongoid-3.0.gemfile
+  - gemfiles/mongoid-3.1.gemfile
+  - gemfiles/mongoid-4.0.gemfile

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2012 Jonas Nicklas
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,5 @@
+# Fork with OPTIONAL gridfs
+
+# CarrierWave for Mongoid 
+
+See upstream for details: https://github.com/carrierwaveuploader/carrierwave-mongoid

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler/setup'
+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/gemfiles/carrierwave-master.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "carrierwave", github: "carrierwaveuploader/carrierwave", branch: "master"
+
+gemspec path: "../"

data/gemfiles/mongoid-3.0.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "mongoid", github: "mongoid/mongoid", branch: "3.0.0-stable"
+
+gemspec path: "../"

data/gemfiles/mongoid-3.1.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "mongoid", github: "mongoid/mongoid", branch: "3.1.0-stable"
+
+gemspec path: "../"

data/gemfiles/mongoid-4.0.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem "mongoid-grid_fs", github: "ahoward/mongoid-grid_fs", branch: "master"
+gem "mongoid", github: "mongoid/mongoid", branch: "master"
+
+gemspec path: "../"

data/glebtv-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        = "glebtv-carrierwave-mongoid"
+  s.version     = Carrierwave::Mongoid::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["GlebTv", "Jonas Nicklas", "Trevor Turk"]
+  s.email       = ["jonas.nicklas@gmail.com"]
+  s.homepage    = "https://github.com/crowdtask/carrierwave-mongoid"
+  s.summary     = %q{This fork makes GridFS optional}
+  s.description = %q{This fork makes GridFS optional}
+  s.license     = "MIT"
+
+  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", ["~> 0.8.0"]
+  s.add_dependency "mongoid", [">= 3.0", "< 5.0"]
+  s.add_development_dependency "rspec", ["~> 2.6"]
+  s.add_development_dependency "rake", ["~> 10.0"]
+  s.add_development_dependency "mini_magick"
+  s.add_development_dependency "pry"
+end

data/lib/carrierwave/mongoid.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+require 'mongoid'
+require 'carrierwave'
+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)
+      field options[:mount_on] || column
+
+      super
+
+      alias_method :read_uploader, :read_attribute
+      alias_method :write_uploader, :write_attribute
+      public :read_uploader
+      public :write_uploader
+
+      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}!"
+      before_save :"write_#{column}_identifier"
+      after_destroy :"remove_#{column}!"
+      before_update :"store_previous_model_for_#{column}"
+      after_save :"remove_previously_stored_#{column}"
+
+      class_eval <<-RUBY, __FILE__, __LINE__+1
+        def #{column}=(new_file)
+          column = _mounter(:#{column}).serialization_column
+
+          # mongoid won't upload a new file if there was no file previously.
+          write_uploader(column, '_old_') if self.persisted? && read_uploader(column).nil?
+
+          send(:"\#{column}_will_change!")
+          super
+        end
+
+        def remove_#{column}!
+          super unless respond_to?(:paranoid?) && paranoid? && flagged_for_destroy?
+        end
+
+        # Overrides Mongoid's default dirty behavior to instead work more like
+        # ActiveRecord's. Mongoid doesn't deem an attribute as changed unless
+        # the new value is different than the original. Given that CarrierWave
+        # caches files before save, it's necessary to know that there's a
+        # pending change even though the attribute value itself might not
+        # reflect that yet.
+        def #{column}_changed?
+          changed_attributes.has_key?("#{column}")
+        end
+
+        def find_previous_model_for_#{column}
+          if self.embedded?
+            ancestors       = [[ self.metadata.key, self._parent ]].tap { |x| x.unshift([ x.first.last.metadata.key, x.first.last._parent ]) while x.first.last.embedded? }
+            first_parent = ancestors.first.last
+            reloaded_parent = first_parent.class.unscoped.find(first_parent.to_key.first)
+            association = ancestors.inject(reloaded_parent) { |parent,(key,ancestor)| (parent.is_a?(Array) ? parent.find(ancestor.to_key.first) : parent).send(key) }
+            association.is_a?(Array) ? association.find(to_key.first) : association
+          else
+            self.class.unscoped.for_ids(to_key).first
+          end
+        end
+
+        def serializable_hash(options=nil)
+          hash = {}
+
+          except = options && options[:except] && Array.wrap(options[:except]).map(&:to_s)
+          only   = options && options[:only]   && Array.wrap(options[:only]).map(&:to_s)
+
+          self.class.uploaders.each do |column, uploader|
+            if (!only && !except) || (only && only.include?(column.to_s)) || (except && !except.include?(column.to_s))
+              hash[column.to_s] = _mounter(column.to_sym).uploader.serializable_hash
+            end
+          end
+          super(options).merge(hash)
+        end
+      RUBY
+    end
+  end # Mongoid
+end # CarrierWave
+
+if defined?(Mongoid::GridFs)
+  CarrierWave::Storage.autoload :GridFS, 'carrierwave/storage/grid_fs'
+
+  class CarrierWave::Uploader::Base
+    add_config :grid_fs_access_url
+
+    configure do |config|
+      config.storage_engines[:grid_fs] = "CarrierWave::Storage::GridFS"
+    end
+  end
+end
+
+Mongoid::Document::ClassMethods.send(:include, CarrierWave::Mongoid)

data/lib/carrierwave/mongoid/version.rb

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

data/lib/carrierwave/storage/grid_fs.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Storage
+
+    ##
+    # The GridFS store uses MongoDB's GridStore file storage system to store files
+    #
+    # 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_access_url = "/system/uploads"
+    #     end
+    #
+    #   In the above example your documents url will look like:
+    #
+    #      http://your-app.com/system/uploads/:document-identifier-here
+    #
+    class GridFS < Abstract
+
+      class File
+        attr_reader :path
+        attr_reader :uploader
+        attr_reader :grid_file
+
+        def initialize(uploader, path)
+          @path = path
+          @uploader = uploader
+          @grid_file = nil
+        end
+
+        def url
+          unless @uploader.grid_fs_access_url
+            nil
+          else
+            ::File.join(@uploader.grid_fs_access_url, path)
+          end
+        end
+
+        def grid_file(&block)
+          @grid_file ||= grid[path]
+        end
+
+        def write(file)
+          grid[@uploader.store_path] = file
+        ensure
+          @grid_file = nil
+        end
+
+        def read
+          grid_file.data if grid_file
+        end
+
+        %w( delete content_type length ).each do |method|
+          class_eval <<-__, __FILE__, __LINE__
+            def #{ method }
+              grid_file.#{ method } if grid_file
+            end
+          __
+        end
+
+        alias :content_length :length
+        alias :file_length :length
+        alias :size :length
+
+      protected
+        class << File
+          attr_accessor :grid
+        end
+
+        self.grid = ::Mongoid::GridFS
+
+        def grid
+          self.class.grid
+        end
+      end # File
+
+      ##
+      # 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 # GridFS
+  end # Storage
+end # CarrierWave

data/lib/glebtv-carrierwave-mongoid.rb

@@ -0,0 +1 @@
+require 'carrierwave/mongoid'

data/spec/fixtures/new.jpeg

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

data/spec/fixtures/new.txt

@@ -0,0 +1 @@
+bork bork bork Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

data/spec/fixtures/old.jpeg

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

data/spec/fixtures/old.txt

@@ -0,0 +1 @@
+bork bork bork Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

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,834 @@
+# encoding: utf-8
+require 'spec_helper'
+
+require 'carrierwave/mongoid'
+
+def reset_mongo_class(uploader = MongoUploader)
+  define_mongo_class('MongoUser') do
+    include Mongoid::Document
+    store_in :collection => 'users'
+    field :folder, :default => ''
+    mount_uploader :image, uploader
+  end
+end
+
+def define_mongo_class(class_name, &block)
+  Object.send(:remove_const, class_name) rescue nil
+  klass = Object.const_set(class_name, Class.new)
+  klass.class_eval(&block)
+  klass
+end
+
+class MongoUploader < CarrierWave::Uploader::Base; end
+class AnotherMongoUploader < CarrierWave::Uploader::Base; end
+
+class IntegrityErrorUploader < CarrierWave::Uploader::Base
+  process :monkey
+  def monkey
+    raise CarrierWave::IntegrityError
+  end
+  def extension_white_list
+    %w(jpg)
+  end
+end
+
+class ProcessingErrorUploader < CarrierWave::Uploader::Base
+  process :monkey
+  def monkey
+    raise CarrierWave::ProcessingError
+  end
+  def extension_white_list
+    %w(jpg)
+  end
+end
+
+
+describe CarrierWave::Mongoid do
+
+  after do
+    MongoUser.collection.drop if MongoUser.count > 0
+  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 => "")
+        @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
+        # should retrieve a file from the storage if a value is stored in the database
+        @document[:image] = "test.jpg" # NOT @document.image = 'text.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
+
+      it "should return valid JSON when to_json is called when image is nil" do
+        @doc[:image] = nil
+        hash = JSON.parse(@doc.to_json)
+        hash.keys.should include("image")
+        hash["image"].keys.should include("url")
+        hash["image"]["url"].should be_nil
+      end
+
+      it "should return valid JSON when to_json is called when image is present" do
+        @doc[:image] = 'test.jpeg'
+        @doc.save!
+        @doc.reload
+
+        JSON.parse(@doc.to_json)["image"].should == {"url" => "/uploads/test.jpeg"}
+      end
+
+      it "should return valid JSON when to_json is called on a collection containing uploader from a model" do
+        @doc[:image] = 'test.jpeg'
+        @doc.save!
+        @doc.reload
+
+        JSON.parse({:data => @doc.image}.to_json).should == {"data"=>{"image"=>{"url"=>"/uploads/test.jpeg"}}}
+      end
+
+      it "should respect options[:only] when passed to to_json for the serializable hash" do
+        @doc[:image] = 'test.jpeg'
+        @doc.save!
+        @doc.reload
+        JSON.parse(@doc.to_json({:only => [:_id]})).should == {"_id" => @doc.id.as_json}
+      end
+
+      it "should respect options[:except] when passed to to_json for the serializable hash" do
+        @doc[:image] = 'test.jpeg'
+        @doc.save!
+        @doc.reload
+
+        JSON.parse(@doc.to_json({:except => [:_id, :image]})).should == {"folder" => ""}
+      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].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(IntegrityErrorUploader)
+        @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 of an allowed file type']
+
+        change_locale_and_store_translations(:pt, :mongoid => {
+          :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, :mongoid => {
+          :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
+
+    it "after it was initialized with params" do
+      doc = reset_mongo_class.new(:image => stub_file('test.jpg'))
+      doc.save.should be_true
+      doc.image.should be_an_instance_of(MongoUploader)
+      doc.image.current_path.should == public_path('uploads/test.jpg')
+    end
+
+    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.should be_true
+        @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.should be_true
+        @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.should be_true
+        @doc[:image].should == 'test.jpg'
+        @doc.image_identifier.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.should be_true
+          @doc.reload
+          @doc.image.should be_blank
+          @doc.image_identifier.should == ''
+        end
+
+      end
+
+      it "should mark image as changed when saving a new image" do
+        @doc.image_changed?.should be_false
+        @doc.image = stub_file("test.jpeg")
+        @doc.image_changed?.should be_true
+        @doc.save
+        @doc.reload
+        @doc.image_changed?.should be_false
+        @doc.image = stub_file("test.jpg")
+        @doc.image_changed?.should be_true
+      end
+
+    end
+
+  end
+
+  describe '#update' do
+
+    before do
+      mongo_user_klass = reset_mongo_class
+      @doc = mongo_user_klass.new
+      @doc.image = stub_file('test.jpeg')
+      @doc.save
+      @doc.reload
+    end
+
+    it "replaced it by a file with the same name" do
+      @doc.image = stub_file('test.jpeg')
+      @doc.save
+      @doc.reload
+      @doc[:image].should == 'test.jpeg'
+      @doc.image_identifier.should == 'test.jpeg'
+    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
+
+  describe '#mount_uploader removing old files' do
+
+    before do
+      @uploader = Class.new(MongoUploader)
+      @class = reset_mongo_class(@uploader)
+      @class.field :foo
+      @doc = @class.new
+      @doc.image = stub_file('old.jpeg')
+      @doc.save.should be_true
+      File.exists?(public_path('uploads/old.jpeg')).should be_true
+    end
+
+    after do
+      FileUtils.rm_rf(file_path("uploads"))
+    end
+
+    describe 'normally' do
+
+      it "should remove old file if old file had a different path" do
+        @doc.image = stub_file('new.jpeg')
+        @doc.save.should be_true
+        File.exists?(public_path('uploads/new.jpeg')).should be_true
+        File.exists?(public_path('uploads/old.jpeg')).should be_false
+      end
+
+      it "should not remove old file if old file had a different path but config is false" do
+        @uploader.stub!(:remove_previously_stored_files_after_update).and_return(false)
+        @doc.image = stub_file('new.jpeg')
+        @doc.save.should be_true
+        File.exists?(public_path('uploads/new.jpeg')).should be_true
+        File.exists?(public_path('uploads/old.jpeg')).should be_true
+      end
+
+      it "should not remove file if old file had the same path" do
+        @doc.image = stub_file('old.jpeg')
+        @doc.save.should be_true
+        File.exists?(public_path('uploads/old.jpeg')).should be_true
+      end
+
+      it "should not remove file if validations fail on save" do
+        @class.validate { |r| r.errors.add :textfile, "FAIL!" }
+        @doc.image = stub_file('new.jpeg')
+        @doc.save.should be_false
+        File.exists?(public_path('uploads/old.jpeg')).should be_true
+      end
+    end
+
+    describe 'with an overriden filename' do
+      before do
+        @uploader.class_eval do
+          def filename
+            model.foo + File.extname(super)
+          end
+        end
+
+        @doc.image = stub_file('old.jpeg')
+        @doc.foo = "test"
+        @doc.save.should be_true
+        File.exists?(public_path('uploads/test.jpeg')).should be_true
+        @doc.image.read.should == "this is stuff"
+      end
+
+      it "should not remove file if old file had the same dynamic path" do
+        @doc.image = stub_file('test.jpeg')
+        @doc.save.should be_true
+        File.exists?(public_path('uploads/test.jpeg')).should be_true
+      end
+
+      it "should remove old file if old file had a different dynamic path" do
+        @doc.foo = "new"
+        @doc.image = stub_file('test.jpeg')
+        @doc.save.should be_true
+        File.exists?(public_path('uploads/new.jpeg')).should be_true
+        File.exists?(public_path('uploads/test.jpeg')).should be_false
+      end
+    end
+
+    shared_examples "embedded documents" do
+      it "should remove old file if old file had a different path" do
+        @embedded_doc.image = stub_file('new.jpeg')
+        @embedded_doc.save.should be_true
+        File.exists?(public_path('uploads/new.jpeg')).should be_true
+        File.exists?(public_path('uploads/old.jpeg')).should be_false
+      end
+
+      it "should not remove old file if old file had a different path but config is false" do
+        @embedded_doc.image.stub!(:remove_previously_stored_files_after_update).and_return(false)
+        @embedded_doc.image = stub_file('new.jpeg')
+        @embedded_doc.save.should be_true
+        File.exists?(public_path('uploads/new.jpeg')).should be_true
+        File.exists?(public_path('uploads/old.jpeg')).should be_true
+      end
+
+      it "should not remove file if old file had the same path" do
+        @embedded_doc.image = stub_file('old.jpeg')
+        @embedded_doc.save.should be_true
+        File.exists?(public_path('uploads/old.jpeg')).should be_true
+      end
+
+      it "should not remove file if validations fail on save" do
+        @embedded_doc_class.validate { |r| r.errors.add :textfile, "FAIL!" }
+        @embedded_doc.image = stub_file('new.jpeg')
+        @embedded_doc.save.should be_false
+        File.exists?(public_path('uploads/old.jpeg')).should be_true
+      end
+
+      it "should not touch parent's dirty attributes" do
+        @class.field :title
+        @doc.title = "Title"
+        @embedded_doc.image = stub_file('new.jpeg')
+        @embedded_doc.save.should be_true
+        @doc.title.should == "Title"
+      end
+    end
+
+    shared_examples "double embedded documents" do
+      it "should remove old file if old file had a different path" do
+        @double_embedded_doc.image = stub_file('new.jpeg')
+        @double_embedded_doc.save.should be_true
+        File.exists?(public_path('uploads/new.jpeg')).should be_true
+        File.exists?(public_path('uploads/old.jpeg')).should be_false
+      end
+
+      it "should not remove old file if old file had a different path but config is false" do
+        @double_embedded_doc.image.stub!(:remove_previously_stored_files_after_update).and_return(false)
+        @double_embedded_doc.image = stub_file('new.jpeg')
+        @double_embedded_doc.save.should be_true
+        File.exists?(public_path('uploads/new.jpeg')).should be_true
+        File.exists?(public_path('uploads/old.jpeg')).should be_true
+      end
+
+      it "should not remove file if old file had the same path" do
+        @double_embedded_doc.image = stub_file('old.jpeg')
+        @double_embedded_doc.save.should be_true
+        File.exists?(public_path('uploads/old.jpeg')).should be_true
+      end
+
+      it "should not remove file if validations fail on save" do
+        @double_embedded_doc_class.validate { |r| r.errors.add :textfile, "FAIL!" }
+        @double_embedded_doc.image = stub_file('new.jpeg')
+        @double_embedded_doc.save.should be_false
+        File.exists?(public_path('uploads/old.jpeg')).should be_true
+      end
+
+    end
+
+    describe 'with document embedded as embeds_one' do
+      before do
+        @embedded_doc_class = define_mongo_class('MongoLocation') do
+          include Mongoid::Document
+          mount_uploader :image, @uploader
+          embedded_in :mongo_user
+        end
+
+        @class.class_eval do
+          embeds_one :mongo_location
+        end
+
+        @doc = @class.new
+        @embedded_doc = @doc.build_mongo_location
+        @embedded_doc.image = stub_file('old.jpeg')
+        @embedded_doc.save.should be_true
+      end
+
+      include_examples "embedded documents"
+    end
+
+    describe 'with document embedded as embeds_one and parent document not matched the default scope' do
+      before do
+        @embedded_doc_class = define_mongo_class('MongoLocation') do
+          include Mongoid::Document
+          mount_uploader :image, @uploader
+          embedded_in :mongo_user
+        end
+
+        @class.class_eval do
+          embeds_one :mongo_location
+          default_scope where(:always_false => false)
+        end
+
+        @doc = @class.new
+        @embedded_doc = @doc.build_mongo_location
+        @embedded_doc.image = stub_file('old.jpeg')
+        @embedded_doc.save.should be_true
+      end
+
+      include_examples "embedded documents"
+    end
+
+    describe 'with embedded documents' do
+      before do
+        @embedded_doc_class = define_mongo_class('MongoLocation') do
+          include Mongoid::Document
+          mount_uploader :image, @uploader
+          embedded_in :mongo_user
+        end
+
+        @class.class_eval do
+          embeds_many :mongo_locations, cascade_callbacks: true
+        end
+
+        @doc = @class.new
+        @embedded_doc = @doc.mongo_locations.build
+        @embedded_doc.image = stub_file('old.jpeg')
+        @embedded_doc.save.should be_true
+      end
+
+      include_examples "embedded documents"
+
+      it "attaches a new file to an existing document that had no file at first" do
+        doc = @class.new
+        doc.mongo_locations.build
+        doc.save.should be_true
+        doc.reload
+
+        doc.mongo_locations.first.image = stub_file('test.jpeg')
+        doc.save.should be_true
+        doc.reload
+
+        doc.mongo_locations.first[:image].should == 'test.jpeg'
+      end
+
+      describe 'with double embedded documents' do
+
+        before do
+          @double_embedded_doc_class = define_mongo_class('MongoItem') do
+            include Mongoid::Document
+            mount_uploader :image, @uploader
+            embedded_in :mongo_location
+          end
+
+          @embedded_doc_class.class_eval do
+            embeds_many :mongo_items
+          end
+
+          @doc = @class.new
+          @embedded_doc = @doc.mongo_locations.build
+          @embedded_doc.image = stub_file('old.jpeg')
+          @embedded_doc.save.should be_true
+
+          @double_embedded_doc = @embedded_doc.mongo_items.build
+          @double_embedded_doc.image = stub_file('old.jpeg')
+          @double_embedded_doc.save.should be_true
+        end
+
+        include_examples "double embedded documents"
+      end
+    end
+
+    describe 'with embedded documents and parent document not matched the default scope' do
+      before do
+        @embedded_doc_class = define_mongo_class('MongoLocation') do
+          include Mongoid::Document
+          mount_uploader :image, @uploader
+          embedded_in :mongo_user
+        end
+
+        @class.class_eval do
+          embeds_many :mongo_locations
+          default_scope where(:always_false => false)
+        end
+
+        @doc = @class.new
+        @embedded_doc = @doc.mongo_locations.build
+        @embedded_doc.image = stub_file('old.jpeg')
+        @embedded_doc.save.should be_true
+      end
+
+      include_examples "embedded documents"
+
+      describe 'with double embedded documents' do
+
+        before do
+          @double_embedded_doc_class = define_mongo_class('MongoItem') do
+            include Mongoid::Document
+            mount_uploader :image, @uploader
+            embedded_in :mongo_location
+          end
+
+          @embedded_doc_class.class_eval do
+            embeds_many :mongo_items
+          end
+
+          @doc = @class.new
+          @embedded_doc = @doc.mongo_locations.build
+          @embedded_doc.image = stub_file('old.jpeg')
+          @embedded_doc.save.should be_true
+
+          @double_embedded_doc = @embedded_doc.mongo_items.build
+          @double_embedded_doc.image = stub_file('old.jpeg')
+          @double_embedded_doc.save.should be_true
+        end
+
+        include_examples "double embedded documents"
+      end
+    end
+  end
+
+  describe '#mount_uploader removing old files with versions' do
+
+    before do
+      @uploader = Class.new(MongoUploader)
+      @uploader.version :thumb
+      @class = reset_mongo_class(@uploader)
+      @doc = @class.new
+      @doc.image = stub_file('old.jpeg')
+      @doc.save.should be_true
+      File.exists?(public_path('uploads/old.jpeg')).should be_true
+      File.exists?(public_path('uploads/thumb_old.jpeg')).should be_true
+    end
+
+    after do
+      FileUtils.rm_rf(file_path("uploads"))
+    end
+
+    it "should remove old file if old file had a different path" do
+      @doc.image = stub_file('new.jpeg')
+      @doc.save.should be_true
+      File.exists?(public_path('uploads/new.jpeg')).should be_true
+      File.exists?(public_path('uploads/thumb_new.jpeg')).should be_true
+      File.exists?(public_path('uploads/old.jpeg')).should be_false
+      File.exists?(public_path('uploads/thumb_old.jpeg')).should be_false
+    end
+
+    it "should not remove file if old file had the same path" do
+      @doc.image = stub_file('old.jpeg')
+      @doc.save.should be_true
+      File.exists?(public_path('uploads/old.jpeg')).should be_true
+      File.exists?(public_path('uploads/thumb_old.jpeg')).should be_true
+    end
+  end
+
+  describe '#mount_uploader removing old files with multiple uploaders' do
+
+    before do
+      @uploader = Class.new(MongoUploader)
+      @class = reset_mongo_class(@uploader)
+      @uploader1 = Class.new(CarrierWave::Uploader::Base)
+      @class.mount_uploader(:textfile, @uploader1)
+      @doc = @class.new
+      @doc.image = stub_file('old.jpeg')
+      @doc.textfile = stub_file('old.txt')
+      @doc.save.should be_true
+      File.exists?(public_path('uploads/old.jpeg')).should be_true
+      File.exists?(public_path('uploads/old.txt')).should be_true
+    end
+
+    after do
+      FileUtils.rm_rf(file_path("uploads"))
+    end
+
+    it "should remove old file1 and file2 if old file1 and file2 had a different paths" do
+      @doc.image = stub_file('new.jpeg')
+      @doc.textfile = stub_file('new.txt')
+      @doc.save.should be_true
+      File.exists?(public_path('uploads/new.jpeg')).should be_true
+      File.exists?(public_path('uploads/old.jpeg')).should be_false
+      File.exists?(public_path('uploads/new.txt')).should be_true
+      File.exists?(public_path('uploads/old.txt')).should be_false
+    end
+
+    it "should remove old file1 but not file2 if old file1 had a different path but old file2 has the same path" do
+      @doc.image = stub_file('new.jpeg')
+      @doc.textfile = stub_file('old.txt')
+      @doc.save.should be_true
+      File.exists?(public_path('uploads/new.jpeg')).should be_true
+      File.exists?(public_path('uploads/old.jpeg')).should be_false
+      File.exists?(public_path('uploads/old.txt')).should be_true
+    end
+
+    it "should not remove file1 or file2 if file1 and file2 have the same paths" do
+      @doc.image = stub_file('old.jpeg')
+      @doc.textfile = stub_file('old.txt')
+      @doc.save.should be_true
+      File.exists?(public_path('uploads/old.jpeg')).should be_true
+      File.exists?(public_path('uploads/old.txt')).should be_true
+    end
+  end
+
+  describe '#mount_uploader removing old files with with mount_on' do
+
+    before do
+      @class = reset_mongo_class
+      @uploader1 = Class.new(CarrierWave::Uploader::Base)
+      @class.mount_uploader(:avatar, @uploader1, :mount_on => :another_image)
+      @doc = @class.new
+      @doc.avatar = stub_file('old.jpeg')
+      @doc.save.should be_true
+      File.exists?(public_path('uploads/old.jpeg')).should be_true
+    end
+
+    after do
+      FileUtils.rm_rf(file_path("uploads"))
+    end
+
+    it "should remove old file if old file had a different path" do
+      @doc.avatar = stub_file('new.jpeg')
+      @doc.save.should be_true
+      File.exists?(public_path('uploads/new.jpeg')).should be_true
+      File.exists?(public_path('uploads/old.jpeg')).should be_false
+    end
+
+    it "should not remove file if old file had the same path" do
+      @doc.avatar = stub_file('old.jpeg')
+      @doc.save.should be_true
+      File.exists?(public_path('uploads/old.jpeg')).should be_true
+    end
+  end
+
+  # Mongoid::Paranoia support is only part of Mongoid 3.x. It was removed from
+  # Mongoid 4.x.
+  if defined?(Mongoid::Paranoia)
+    describe "with paranoia enabled" do
+      before do
+        @class = reset_mongo_class
+        @class.collection.drop
+        @class.class_eval do
+          include Mongoid::Paranoia
+        end
+
+        @doc = @class.new(image: stub_file("old.jpeg"))
+        @doc.save.should be_true
+      end
+
+      it "should not remove underlying image after #destroy" do
+        @doc.destroy.should be_true
+        @class.count.should eql(0)
+        @class.deleted.count.should eql(1)
+        File.exist?(public_path('uploads/old.jpeg')).should be_true
+      end
+
+      it "should remove underlying image after #destroy!" do
+        @doc.destroy!.should be_true
+        @class.count.should eql(0)
+        @class.deleted.count.should eql(0)
+        File.exist?(public_path('uploads/old.jpeg')).should be_false
+      end
+    end
+  end
+
+  context "JSON serialization with multiple uploaders" do
+    before do
+      @class = reset_mongo_class
+      @class.send(:mount_uploader, :textfile,AnotherMongoUploader)
+      @event = @class.new
+      @event.image = stub_file('old.jpeg')
+      @event.textfile = stub_file('old.txt')
+    end
+
+    it "serializes the correct values" do
+      @event.serializable_hash["image"]["url"].should match(/old\.jpeg$/)
+      @event.serializable_hash["textfile"]["url"].should match(/old\.txt$/)
+    end
+
+    it "should have JSON for each uploader" do
+      parsed = JSON.parse(@event.to_json)
+      parsed["image"]["url"].should match(/old\.jpeg$/)
+      parsed["textfile"]["url"].should match(/old\.txt$/)
+    end
+  end
+
+end