carrierwave-rails3 0.4.5

data/lib/carrierwave/uploader/versions.rb

@@ -0,0 +1,147 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Versions
+      extend ActiveSupport::Concern
+
+      include CarrierWave::Uploader::Callbacks
+
+      included do
+        after :cache, :cache_versions!
+        after :store, :store_versions!
+        after :remove, :remove_versions!
+        after :retrieve_from_cache, :retrieve_versions_from_cache!
+        after :retrieve_from_store, :retrieve_versions_from_store!
+      end
+
+      module ClassMethods
+
+        def version_names
+          @version_names ||= []
+        end
+
+        ##
+        # Adds a new version to this uploader
+        #
+        # === Parameters
+        #
+        # [name (#to_sym)] name of the version
+        # [&block (Proc)] a block to eval on this version of the uploader
+        #
+        def version(name, &block)
+          name = name.to_sym
+          unless versions[name]
+            versions[name] = Class.new(self)
+            versions[name].version_names.push(*version_names)
+            versions[name].version_names.push(name)
+            class_eval <<-RUBY
+              def #{name}
+                versions[:#{name}]
+              end
+            RUBY
+          end
+          versions[name].class_eval(&block) if block
+          versions[name]
+        end
+
+        ##
+        # === Returns
+        #
+        # [Hash{Symbol => Class}] a list of versions available for this uploader
+        #
+        def versions
+          @versions ||= {}
+        end
+
+      end # ClassMethods
+
+      ##
+      # Returns a hash mapping the name of each version of the uploader to an instance of it
+      #
+      # === Returns
+      #
+      # [Hash{Symbol => CarrierWave::Uploader}] a list of uploader instances
+      #
+      def versions
+        return @versions if @versions
+        @versions = {}
+        self.class.versions.each do |name, klass|
+          @versions[name] = klass.new(model, mounted_as)
+        end
+        @versions
+      end
+
+      ##
+      # === Returns
+      #
+      # [String] the name of this version of the uploader
+      #
+      def version_name
+        self.class.version_names.join('_').to_sym unless self.class.version_names.blank?
+      end
+
+      ##
+      # When given a version name as a parameter, will return the url for that version
+      # This also works with nested versions.
+      #
+      # === Example
+      #
+      #     my_uploader.url                 # => /path/to/my/uploader.gif
+      #     my_uploader.url(:thumb)         # => /path/to/my/thumb_uploader.gif
+      #     my_uploader.url(:thumb, :small) # => /path/to/my/thumb_small_uploader.gif
+      #
+      # === Parameters
+      #
+      # [*args (Symbol)] any number of versions
+      #
+      # === Returns
+      #
+      # [String] the location where this file is accessible via a url
+      #
+      def url(*args)
+        if(args.first)
+          raise ArgumentError, "Version #{args.first} doesn't exist!" if versions[args.first.to_sym].nil?
+          # recursively proxy to version
+          versions[args.first.to_sym].url(*args[1..-1])
+        else
+          super()
+        end
+      end
+
+    private
+
+      def full_filename(for_file)
+        [version_name, super(for_file)].compact.join('_')
+      end
+
+      def full_original_filename
+        [version_name, super].compact.join('_')
+      end
+
+      def cache_versions!(new_file)
+        versions.each do |name, v|
+          v.send(:cache_id=, cache_id)
+          v.cache!(new_file)
+        end
+      end
+
+      def store_versions!(new_file)
+        versions.each { |name, v| v.store!(new_file) }
+      end
+
+      def remove_versions!
+        versions.each { |name, v| v.remove! }
+      end
+
+      def retrieve_versions_from_cache!(cache_name)
+        versions.each { |name, v| v.retrieve_from_cache!(cache_name) }
+      end
+
+      def retrieve_versions_from_store!(identifier)
+        versions.each { |name, v| v.retrieve_from_store!(identifier) }
+      end
+
+    end # Versions
+  end # Uploader
+end # CarrierWave

data/lib/generators/templates/uploader.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+class <%= class_name %>Uploader < CarrierWave::Uploader::Base
+
+  # Include RMagick or ImageScience support
+  #     include CarrierWave::RMagick
+  #     include CarrierWave::ImageScience
+
+  # Choose what kind of storage to use for this uploader
+  storage :file
+  #     storage :s3
+
+  # Override the directory where uploaded files will be stored
+  # This is a sensible default for uploaders that are meant to be mounted:
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+
+  # Provide a default URL as a default if there hasn't been a file uploaded
+  #     def default_url
+  #       "/images/fallback/" + [version_name, "default.png"].compact.join('_')
+  #     end
+
+  # Process files as they are uploaded.
+  #     process :scale => [200, 300]
+  #
+  #     def scale(width, height)
+  #       # do something
+  #     end
+
+  # Create different versions of your uploaded files
+  #     version :thumb do
+  #       process :scale => [50, 50]
+  #     end
+
+  # Add a white list of extensions which are allowed to be uploaded,
+  # for images you might use something like this:
+  #     def extension_white_list
+  #       %w(jpg jpeg gif png)
+  #     end
+
+  # Override the filename of the uploaded files
+  #     def filename
+  #       "something.jpg" if original_filename
+  #     end
+
+end

data/lib/generators/uploader_generator.rb

@@ -0,0 +1,13 @@
+require 'rails/generators'
+require 'rails/generators/named_base'
+
+class UploaderGenerator < Rails::Generators::NamedBase
+  def create_uploader_file
+    template 'uploader.rb', File.join('app/uploaders', class_path, "#{file_name}.rb")
+  end
+  
+  def self.source_root
+    @source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+  end
+end
+

data/spec/compatibility/paperclip_spec.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'carrierwave/orm/activerecord'
+
+module Rails
+  def self.root
+    File.expand_path(File.join('..'), File.dirname(__FILE__))
+  end
+  def self.env
+    "test"
+  end
+end unless defined?(Rails)
+
+describe CarrierWave::Compatibility::Paperclip do
+
+  before do
+    @uploader_class = Class.new(CarrierWave::Uploader::Base) do
+      include CarrierWave::Compatibility::Paperclip
+    end
+    @model = mock('a model')
+    @model.stub!(:id).and_return(23)
+    @uploader = @uploader_class.new(@model, :monkey)
+  end
+  
+  after do
+    FileUtils.rm_rf(public_path)
+  end
+
+  describe '#store_path' do
+    it "should mimics paperclip default" do
+      @uploader.store_path("monkey.png").should == CarrierWave::Uploader::Base.root + "/system/monkeys/23/original/monkey.png"
+    end
+
+    it "should interpolate the root path" do
+      @uploader.stub!(:paperclip_path).and_return(":rails_root/foo/bar")
+      @uploader.store_path("monkey.png").should == Rails.root + "/foo/bar"
+    end
+
+    it "should interpolate the attachment" do
+      @uploader.stub!(:paperclip_path).and_return("/foo/:attachment/bar")
+      @uploader.store_path("monkey.png").should == "/foo/monkeys/bar"
+    end
+
+    it "should interpolate the id" do
+      @uploader.stub!(:paperclip_path).and_return("/foo/:id/bar")
+      @uploader.store_path("monkey.png").should == "/foo/23/bar"
+    end
+  end
+
+end

data/spec/mount_spec.rb

@@ -0,0 +1,538 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe CarrierWave::Mount do
+  
+  after do
+    FileUtils.rm_rf(public_path)
+  end
+
+  describe '.mount_uploader' do
+    
+    before do
+      @class = Class.new
+      @class.send(:extend, CarrierWave::Mount)
+      
+      @uploader = Class.new(CarrierWave::Uploader::Base)
+
+      @class.mount_uploader(:image, @uploader)
+      @instance = @class.new
+    end
+
+    it "should maintain the ability to super" do
+      @class.class_eval do
+        def image_uploader
+          super
+        end
+
+        def image=(val)
+          super
+        end
+      end
+
+      @instance.image = stub_file('test.jpg')
+      @instance.image.should be_an_instance_of(@uploader)
+    end
+    
+    it "should inherit uploaders to subclasses" do
+      @subclass = Class.new(@class)
+      @subclass_instance = @subclass.new
+      @subclass_instance.image = stub_file('test.jpg')
+      @subclass_instance.image.should be_an_instance_of(@uploader)
+    end
+    
+    describe '#image' do
+      
+      it "should return a blank uploader when nothing has been assigned" do
+        @instance.should_receive(:read_uploader).with(:image).twice.and_return(nil)
+        @instance.image.should be_an_instance_of(@uploader)
+        @instance.image.should be_blank
+      end
+      
+      it "should return a blank uploader when an empty string has been assigned" do
+        @instance.should_receive(:read_uploader).with(:image).twice.and_return('')
+        @instance.image.should be_an_instance_of(@uploader)
+        @instance.image.should be_blank
+      end
+      
+      it "should retrieve a file from the storage if a value is stored in the database" do
+        @instance.should_receive(:read_uploader).with(:image).at_least(:once).and_return('test.jpg')
+        @instance.image.should be_an_instance_of(@uploader)
+      end
+      
+      it "should set the path to the store dir" do
+        @instance.should_receive(:read_uploader).with(:image).at_least(:once).and_return('test.jpg')
+        @instance.image.current_path.should == public_path('uploads/test.jpg')
+      end
+    
+    end
+    
+    describe '#image=' do
+      
+      it "should cache a file" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image.should be_an_instance_of(@uploader)
+      end
+      
+      it "should copy a file into into the cache directory" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image.current_path.should =~ /^#{public_path('uploads/tmp')}/
+      end
+      
+      it "should do nothing when nil is assigned" do
+        @instance.should_not_receive(:write_uploader)
+        @instance.image = nil
+      end
+      
+      it "should do nothing when an empty string is assigned" do
+        @instance.should_not_receive(:write_uploader)
+        @instance.image = stub_file('test.jpg')
+      end
+
+      it "should fail silently if the image fails an integrity check" do
+        @uploader.class_eval do
+          def extension_white_list
+            %(txt)
+          end
+        end
+        @instance.image = stub_file('test.jpg')
+        @instance.image.should be_blank
+      end
+      
+      it "should fail silently if the image fails to be processed" do
+        @uploader.class_eval do
+          process :monkey
+          def monkey
+            raise CarrierWave::ProcessingError, "Ohh noez!"
+          end
+        end
+        @instance.image = stub_file('test.jpg')
+      end
+      
+    end
+
+    describe '#image?' do
+      
+      it "should be false when nothing has been assigned" do
+        @instance.should_receive(:read_uploader).with(:image).and_return(nil)
+        @instance.image?.should be_false
+      end
+      
+      it "should be false when an empty string has been assigned" do
+        @instance.should_receive(:read_uploader).with(:image).and_return('')
+        @instance.image?.should be_false
+      end
+
+      it "should be true when a file has been cached" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image?.should be_true
+      end
+    
+    end
+
+    describe '#image_url' do
+      
+      it "should return nil when nothing has been assigned" do
+        @instance.should_receive(:read_uploader).with(:image).and_return(nil)
+        @instance.image_url.should be_nil
+      end
+      
+      it "should return nil when an empty string has been assigned" do
+        @instance.should_receive(:read_uploader).with(:image).and_return('')
+        @instance.image_url.should be_nil
+      end
+      
+      it "should get the url from a retrieved file" do
+        @instance.should_receive(:read_uploader).at_least(:once).with(:image).and_return('test.jpg')
+        @instance.image_url.should == '/uploads/test.jpg'
+      end
+
+      it "should get the url from a cached file" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image_url.should =~ %r{uploads/tmp/[\d\-]+/test.jpg}
+      end
+
+      it "should get the url from a cached file's version" do
+        @uploader.version(:thumb)
+        @instance.image = stub_file('test.jpg')
+        @instance.image_url(:thumb).should =~ %r{uploads/tmp/[\d\-]+/thumb_test.jpg}
+      end
+
+    end
+
+    describe '#image_cache' do
+
+      before do
+        @instance.stub!(:write_uploader)
+        @instance.stub!(:read_uploader).and_return(nil)
+      end
+
+      it "should return nil when nothing has been assigned" do
+        @instance.image_cache.should be_nil
+      end
+
+      it "should be nil when a file has been stored" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image.store!
+        @instance.image_cache.should be_nil
+      end
+
+      it "should be the cache name when a file has been cached" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image_cache.should =~ %r(^[\d]{8}\-[\d]{4}\-[\d]+\-[\d]{4}/test\.jpg$)
+      end
+
+    end
+    
+    describe '#image_cache=' do
+
+      before do
+        @instance.stub!(:write_uploader)
+        @instance.stub!(:read_uploader).and_return(nil)
+        CarrierWave::SanitizedFile.new(file_path('test.jpg')).copy_to(public_path('uploads/tmp/19990512-1202-123-1234/test.jpg'))
+      end
+
+      it "should do nothing when nil is assigned" do
+        @instance.image_cache = nil
+        @instance.image.should be_blank
+      end
+
+      it "should do nothing when an empty string is assigned" do
+        @instance.image_cache = ''
+        @instance.image.should be_blank
+      end
+
+      it "retrieve from cache when a cache name is assigned" do
+        @instance.image_cache = '19990512-1202-123-1234/test.jpg'
+        @instance.image.current_path.should == public_path('uploads/tmp/19990512-1202-123-1234/test.jpg')
+      end
+
+      it "should not write over a previously assigned file" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image_cache = '19990512-1202-123-1234/monkey.jpg'
+        @instance.image.current_path.should =~ /test.jpg$/
+      end
+    end
+
+    describe '#remote_image_url' do
+      before do
+        response = mock('HTTP Response')
+        response.stub!(:body).and_return('Response Body')
+        Net::HTTP.stub!(:get_response).and_return(response)
+      end
+
+      it "should return nil" do
+        @instance.remote_image_url.should be_nil
+      end
+
+      it "should return previously cached URL" do
+        @instance.remote_image_url = 'http://www.example.com/funky/monkey.png'
+        @instance.remote_image_url.should == 'http://www.example.com/funky/monkey.png'
+      end
+    end
+
+    describe '#remote_image_url=' do
+      before do
+        response = mock('HTTP Response')
+        response.stub!(:body).and_return('Response Body')
+        Net::HTTP.stub!(:get_response).and_return(response)
+      end
+
+      it "should do nothing when nil is assigned" do
+        @instance.remote_image_url = nil
+        @instance.image.should be_blank
+      end
+
+      it "should do nothing when an empty string is assigned" do
+        @instance.remote_image_url = ''
+        @instance.image.should be_blank
+      end
+
+      it "retrieve from cache when a cache name is assigned" do
+        @instance.remote_image_url = 'http://www.example.com/funky/monkey.png'
+        @instance.image.current_path.should =~ /monkey.png$/
+      end
+
+      it "should not write over a previously assigned file" do
+        @instance.image = stub_file('test.jpg')
+        @instance.remote_image_url = '19990512-1202-123-1234/monkey.jpg'
+        @instance.image.current_path.should =~ /test.jpg$/
+      end
+    end
+
+    describe '#store_image!' do
+
+      before do
+        @instance.stub!(:write_uploader)
+        @instance.stub!(:read_uploader).and_return(nil)
+      end
+
+      it "should do nothing when no file has been uploaded" do
+        @instance.store_image!
+        @instance.image.should be_blank
+      end
+
+      it "store an assigned file" do
+        @instance.image = stub_file('test.jpg')
+        @instance.store_image!
+        @instance.image.current_path.should == public_path('uploads/test.jpg')
+      end
+
+      it "should remove an uploaded file when remove_image? returns true" do
+        @instance.image = stub_file('test.jpg')
+        path = @instance.image.current_path
+        @instance.remove_image = true
+        @instance.store_image!
+        @instance.image.should be_blank
+        File.exist?(path).should be_false
+      end
+    end
+
+    describe '#remove_image!' do
+
+      before do
+        @instance.stub!(:write_uploader)
+        @instance.stub!(:read_uploader).and_return(nil)
+      end
+
+      it "should do nothing when no file has been uploaded" do
+        @instance.remove_image!
+        @instance.image.should be_blank
+      end
+
+      it "should remove an uploaded file" do
+        @instance.image = stub_file('test.jpg')
+        path = @instance.image.current_path
+        @instance.remove_image!
+        @instance.image.should be_blank
+        File.exist?(path).should be_false
+      end
+    end
+
+    describe '#remove_image' do
+      
+      it "should store a value" do
+        @instance.remove_image = true
+        @instance.remove_image.should be_true
+      end
+      
+    end
+
+    describe '#remove_image?' do
+      
+      it "should be true when the value is truthy" do
+        @instance.remove_image = true
+        @instance.remove_image?.should be_true
+      end
+      
+      it "should be false when the value is falsey" do
+        @instance.remove_image = false
+        @instance.remove_image?.should be_false
+      end
+      
+      it "should be false when the value is ''" do
+        @instance.remove_image = ''
+        @instance.remove_image?.should be_false
+      end
+      
+      it "should be false when the value is '0'" do
+        @instance.remove_image = '0'
+        @instance.remove_image?.should be_false
+      end
+
+      it "should be false when the value is 'false'" do
+        @instance.remove_image = 'false'
+        @instance.remove_image?.should be_false
+      end
+      
+    end
+
+    describe '#image_integrity_error' do
+
+      it "should be nil by default" do
+        @instance.image_integrity_error.should be_nil
+      end
+
+      it "should be nil after a file is cached" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image_integrity_error.should be_nil
+      end
+
+      it "should be an error instance after an integrity check has failed" do
+        @uploader.class_eval do
+          def extension_white_list
+            %(txt)
+          end
+        end
+        @instance.image = stub_file('test.jpg')
+        @instance.image_integrity_error.should be_an_instance_of(CarrierWave::IntegrityError)
+      end
+    end
+    
+    describe '#image_processing_error' do
+
+      it "should be nil by default" do
+        @instance.image_processing_error.should be_nil
+      end
+
+      it "should be nil after a file is cached" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image_processing_error.should be_nil
+      end
+
+      it "should be an error instance after an integrity check has failed" do
+        @uploader.class_eval do
+          process :monkey
+          def monkey
+            raise CarrierWave::ProcessingError, "Ohh noez!"
+          end
+        end
+        @instance.image = stub_file('test.jpg')
+        @instance.image_processing_error.should be_an_instance_of(CarrierWave::ProcessingError)
+      end
+    end
+
+    describe '#write_image_identifier' do
+      it "should write to the column" do
+        @instance.should_receive(:write_uploader).with(:image, "test.jpg")
+        @instance.image = stub_file('test.jpg')
+        @instance.write_image_identifier
+      end
+
+      it "should remove from the column when remove_image is true" do
+        @instance.image = stub_file('test.jpg')
+        @instance.store_image!
+        @instance.remove_image = true
+        @instance.should_receive(:write_uploader).with(:image, "")
+        @instance.write_image_identifier
+      end
+    end
+
+  end
+  
+  describe '#mount_uploader with a block' do
+   
+    before do
+      @class = Class.new
+      @class.send(:extend, CarrierWave::Mount)
+      @class.mount_uploader(:image) do
+        def monkey
+          'blah'
+        end
+      end
+      @instance = @class.new
+    end
+    
+    describe '#image' do
+      
+      before do
+        @instance.stub!(:read_uploader).and_return('test.jpg')
+      end
+      
+      it "should return an instance of a subclass of CarrierWave::Uploader::Base" do
+        @instance.image.should be_a(CarrierWave::Uploader::Base)
+      end
+      
+      it "should set the path to the store dir" do
+        @instance.image.current_path.should == public_path('uploads/test.jpg')
+      end
+    
+      it "should apply any custom modifications" do
+        @instance.image.monkey.should == "blah"
+      end
+    
+    end
+    
+  end
+  
+  describe '#mount_uploader with :ignore_integrity_errors => false' do
+   
+    before do
+      @class = Class.new
+      @class.send(:extend, CarrierWave::Mount)
+      
+      @uploader = Class.new(CarrierWave::Uploader::Base)
+
+      @class.mount_uploader(:image, @uploader, :ignore_integrity_errors => false)
+      @instance = @class.new
+    end
+
+    it "should raise an error if the image fails an integrity check" do
+      @uploader.class_eval do
+        def extension_white_list
+          %(txt)
+        end
+      end
+      running {
+        @instance.image = stub_file('test.jpg')
+      }.should raise_error(CarrierWave::IntegrityError)
+    end
+
+  end
+
+  describe '#mount_uploader with :ignore_processing_errors => false' do
+   
+    before do
+      @class = Class.new
+      @class.send(:extend, CarrierWave::Mount)
+      
+      @uploader = Class.new(CarrierWave::Uploader::Base)
+
+      @class.mount_uploader(:image, @uploader, :ignore_processing_errors => false)
+      @instance = @class.new
+    end
+
+    it "should raise an error if the image fails to be processed" do
+      @uploader.class_eval do
+        process :monkey
+        def monkey
+          raise CarrierWave::ProcessingError, "Ohh noez!"
+        end
+      end
+      running {
+        @instance.image = stub_file('test.jpg')
+      }.should raise_error(CarrierWave::ProcessingError)
+    end
+
+  end
+
+  describe '#mount_uploader with :mount_on => :monkey' do
+
+  
+    before do
+      @class = Class.new
+      @class.send(:extend, CarrierWave::Mount)
+
+      @uploader = Class.new(CarrierWave::Uploader::Base)
+
+      @class.mount_uploader(:image, @uploader, :mount_on => :monkey)
+      @instance = @class.new
+    end
+
+    describe '#image' do
+      it "should retrieve a file from the storage if a value is stored in the database" do
+        @instance.should_receive(:read_uploader).at_least(:once).with(:monkey).twice.and_return('test.jpg')
+        @instance.image.should be_an_instance_of(@uploader)
+        @instance.image.current_path.should == public_path('uploads/test.jpg')
+      end
+    end
+
+    describe '#write_image_identifier' do
+      it "should write to the given column" do
+        @instance.should_receive(:write_uploader).with(:monkey, "test.jpg")
+        @instance.image = stub_file('test.jpg')
+        @instance.write_image_identifier
+      end
+
+      it "should remove from the given column when remove_image is true" do
+        @instance.image = stub_file('test.jpg')
+        @instance.store_image!
+        @instance.remove_image = true
+        @instance.should_receive(:write_uploader).with(:monkey, "")
+        @instance.write_image_identifier
+      end
+    end
+  end
+
+end