durran-carrierwave 0.3.2.3

data/lib/generators/uploader_generator.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Merb
+  module Generators
+    class UploaderGenerator < NamedGenerator
+
+      def self.source_root
+        File.join(File.dirname(__FILE__), '..', '..', 'rails_generators', 'uploader', 'templates')
+      end
+
+      first_argument :name, :required => true, :desc => "The name of this uploader"
+
+      template :uploader do |t|
+        t.source = 'uploader.rb'
+        t.destination = "app/uploaders/#{file_name}_uploader.rb"
+      end
+    end
+
+    add :uploader, UploaderGenerator
+
+  end
+end

data/rails_generators/uploader/USAGE

@@ -0,0 +1,2 @@
+Description:
+    Generates a skeleton for a new uploader.

data/rails_generators/uploader/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 path as a default if there hasn't been a file uploaded
+  #     def default_path
+  #       "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"
+  #     end
+
+end

data/rails_generators/uploader/uploader_generator.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+class UploaderGenerator < Rails::Generator::NamedBase
+
+  def manifest
+    record do |m|
+      m.directory 'app/uploaders'
+      m.template  'uploader.rb', "app/uploaders/#{name.underscore}_uploader.rb"
+    end
+  end
+
+  def class_name
+    name.camelize
+  end
+
+  protected
+
+  def banner
+    "Usage: #{$0} uploader UploaderName"
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/carrierwave.rb'}"
+puts "Loading carrierwave gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/compatibility/paperclip_spec.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'carrierwave/orm/activerecord'
+
+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.config[:root] + "/public/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 == CarrierWave.config[: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/fixtures/bork.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/mount_spec.rb

@@ -0,0 +1,517 @@
+# 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_uploader.should be_an_instance_of(@uploader)
+      @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_uploader.should be_an_instance_of(@uploader)
+      @subclass_instance.image = stub_file('test.jpg')
+      @subclass_instance.image.should be_an_instance_of(@uploader)
+    end
+    
+    describe '#image_uploader' do
+      it "should return the uploader" do
+        @instance.image_uploader.should be_an_instance_of(@uploader)
+      end
+    end
+    
+    describe '#image_uploader=' do
+      it "should set the uploader" do
+        @my_uploader = @uploader.new
+        @instance.image_uploader = @my_uploader
+        @instance.image_uploader.should == @my_uploader
+      end
+
+      it "should use the set uploader" do
+        @my_uploader = @uploader.new
+        @my_uploader.store!(stub_file('test.jpg'))
+        @instance.image_uploader = @my_uploader
+        @instance.image_uploader.should == @my_uploader
+        @instance.image.should == @my_uploader
+        @instance.image.current_path.should == public_path('uploads/test.jpg')
+      end
+    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 '#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