jnicklas-carrierwave 0.1.1 → 0.2.0

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008 YOUR NAME
+Copyright (c) 2008 Jonas Nicklas
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/{README.md → README.rdoc}

@@ -1,8 +1,8 @@
-# CarrierWave
+= CarrierWave
 
 This plugin for Merb and Rails provides a simple and extremely flexible way to upload files.
 
-## Getting Started
+== Getting Started
 
 Install the latest stable release:
 
@@ -20,7 +20,7 @@ In Rails, add it to your environment.rb:
 
     config.gem "carrierwave"
 
-## Quick Start
+== Quick Start
 
 Start off by generating an uploader:
 
@@ -36,7 +36,9 @@ this should give you a file in:
 
 Check out this file for some hints on how you can customize your uploader. It should look something like this:
 
-    class AvatarUploader < CarrierWave::Uploader
+    class AvatarUploader
+      include CarrierWave::Uploader
+
       storage :file
     end
 
@@ -48,42 +50,27 @@ You can use your uploader class to store and retrieve files like this:
     
     uploader.retrieve_from_store!('my_file.png')
 
-CarrierWave gives you a `store` for permanent storage, and a `cache` for temporary storage. You can use different stores, at the moment a filesystem store and an Amazon S3 store are bundled.
+CarrierWave gives you a +store+ for permanent storage, and a +cache+ for temporary storage. You can use different stores, at the moment a filesystem store and an Amazon S3 store are bundled.
 
 Most of the time you are going to want to use CarrierWave together with an ORM. It is quite simple to mount uploaders on columns in your model, so you can simply assign files and get going:
 
-### ActiveRecord
+=== ActiveRecord, DataMapper, Sequel
 
-First require the activerecord extension:
+First require the relevant extension:
 
-    require 'carrierwave/orm/activerecord
+    require 'carrierwave/orm/activerecord'
+    require 'carrierwave/orm/datamapper'
+    require 'carrierwave/orm/sequel'
 
 You don't need to do this if you are using Merb or Rails.
 
-Open your model file, and do something like:
+Open your model file, for ActiveRecord do something like:
 
     class User < ActiveRecord::Base
       mount_uploader :avatar, AvatarUploader
     end
 
-Now you can upload files!
-
-    u = User.new
-    u.avatar = params[:file]
-    u.avatar = File.open('somewhere')
-    u.save!
-    u.avatar.url # => '/url/to/file.png'
-    u.avatar.current_path # => 'path/to/file.png'
-
-### DataMapper
-
-First require the activerecord extension:
-
-    require 'carrierwave/orm/datamapper
-
-You don't need to do this if you are using Merb or Rails.
-
-Open your model file, and do something like:
+Or for DataMapper:
 
     class User
       include DataMapper::Resource
@@ -91,7 +78,13 @@ Open your model file, and do something like:
       mount_uploader :avatar, AvatarUploader
     end
 
-Now you can upload files!
+Or for Sequel
+
+    class User < Sequel::Model
+      mount_uploader :avatar, AvatarUploader
+    end
+
+Now you can cache files by assigning them to the attribute, they will automatically be stored when the record is saved.
 
     u = User.new
     u.avatar = params[:file]
@@ -100,11 +93,13 @@ Now you can upload files!
     u.avatar.url # => '/url/to/file.png'
     u.avatar.current_path # => 'path/to/file.png'
 
-## Changing the storage directory
+== Changing the storage directory
 
-In order to change where uploaded files are put, just override the `store_dir` method:
+In order to change where uploaded files are put, just override the +store_dir+ method:
+
+    class MyUploader
+      include CarrierWave::Uploader
 
-    class MyUploader < CarrierWave::Uploader
       def store_dir
         'public/my/upload/directory'
       end
@@ -112,11 +107,12 @@ In order to change where uploaded files are put, just override the `store_dir` m
 
 This works for the file storage as well as Amazon S3.
 
-## Adding versions
+== Adding versions
 
 Often you'll want to add different versions of the same file. The classic example is image thumbnails. There is built in support for this:
 
-    class MyUploader < CarrierWave::Uploader
+    class MyUploader
+      include CarrierWave::Uploader
       include CarrierWave::RMagick
       
       process :resize => [800, 800]
@@ -137,11 +133,23 @@ When this uploader is used, an uploaded image would be scaled to be no larger th
 
 One important thing to remember is that process is called *before* versions are created. This can cut down on processing cost.
 
-## Making uploads work across form redisplays
+It is possible to nest versions within versions:
+
+    class MyUploader
+      include CarrierWave::Uploader
+
+      version :animal do
+        version :human
+        version :monkey
+        version :llama
+      end
+    end
+
+== Making uploads work across form redisplays
 
 Often you'll notice that uploaded files disappear when a validation
 fails. CarrierWave has a feature that makes it easy to remember the
-uploaded file even in that case. Suppose your `user` model has an uploader mounted on `avatar` file, just add a hidden field called `avatar_cache`.
+uploaded file even in that case. Suppose your +user+ model has an uploader mounted on +avatar+ file, just add a hidden field called +avatar_cache+.
 In Rails, this would look like this:
 
     <% form_for @user do |f| %>
@@ -164,27 +172,7 @@ in the case of images, a small thumbnail would be a good indicator:
       </p>
     <% end %>
 
-## What's in that uploader file?
-
-The fact that uploaders are separate classes in CarrierWave is a big advantage. What this means for you is:
-
-#### Less magic
-
-In order to customize your uploader, all you need to do is override methods and use normal, clear and simple Ruby code. That means no `alias_method_chain`'ing to hook into the upload process, no messing around with weird extensions. The code in CarrierWave is very simple and easy because of this.
-
-#### Easier to test
-
-How do you test file uploads? I always found this ridiculously hard. A separate class means you can test is separately, which is nicer, easier and more maintainable.
-
-#### More Flexible
-
-Many of the things you can do in CarrierWave are hard, or impossible to do in other file upload plugins, and have previously required you to roll your own. Now you can get all the flexibility without having to write low level stuff.
-
-#### Easy to extend
-
-CarrierWave has support for a few different image manipulation libraries. These need *no* code to hook into CarrierWave, because they are simple modules. If you want to write your own manipulation library (doesn't need to be for images), you can do the same.
-
-## Using Amazon S3
+== Using Amazon S3
 
 You'll need to configure a bucket, access id and secret key like this:
 
@@ -192,31 +180,31 @@ You'll need to configure a bucket, access id and secret key like this:
     CarrierWave.config[:s3][:secret_access_key] = 'xxxxxx'
     CarrierWave.config[:s3][:bucket] = 'name_of_bucket'
 
-Do this in an initializer in Rails, and in a `before_app_loads` block in Merb.
+Do this in an initializer in Rails, and in a +before_app_loads+ block in Merb.
 
 And then in your uploader, set the storage to :s3
 
-    class AvatarUploader < CarrierWave::Uploader
+    class AvatarUploader
+      include CarrierWave::Uploader
+
       storage :s3
     end
 
-That's it! You can still use the `CarrierWave::Uploader#url` method to return the url to the file on Amazon S3
+That's it! You can still use the +CarrierWave::Uploader#url+ method to return the url to the file on Amazon S3
 
-## Using RMagick
+== Using RMagick
 
-If you're uploading images, you'll probably want to manipulate them in some way, you might want to create thumbnail images for example. CarrierWave comes with a small library to make manipulating images with RMagick easier. It's not loaded by default so you'll need to require it:
+If you're uploading images, you'll probably want to manipulate them in some way, you might want to create thumbnail images for example. CarrierWave comes with a small library to make manipulating images with RMagick easier, you'll need to include it in your Uploader:
 
-    require 'carrierwave/processing/rmagick'
-
-You'll also need to include it in your Uploader:
-
-    class AvatarUploader < CarrierWave::Uploader
+    class AvatarUploader
+      include CarrierWave::Uploader
       include CarrierWave::RMagick
     end
 
-The RMagick module gives you a few methods, like `CarrierWave::RMagick#crop_resized` which manipulate the image file in some way. You can set a `process` callback, which will call that method any time a file is uploaded.
+The RMagick module gives you a few methods, like +CarrierWave::RMagick#crop_resized+ which manipulate the image file in some way. You can set a +process+ callback, which will call that method any time a file is uploaded.
 
-    class AvatarUploader < CarrierWave::Uploader
+    class AvatarUploader
+      include CarrierWave::Uploader
       include CarrierWave::RMagick
       
       process :crop_resized => [200, 200]
@@ -229,24 +217,21 @@ The RMagick module gives you a few methods, like `CarrierWave::RMagick#crop_resi
 
 Check out the manipulate! method, which makes it easy for you to write your own manipulation methods.
 
-## Using ImageScience
-
-ImageScience works the same way as RMagick. As with RMagick you'll need to require it:
-
-    require 'carrierwave/processing/image_science'
+== Using ImageScience
 
-And then include it in your model:
+ImageScience works the same way as RMagick.
 
-    class AvatarUploader < CarrierWave::Uploader
+    class AvatarUploader
+      include CarrierWave::Uploader
       include CarrierWave::ImageScience
       
       process :crop_resized => [200, 200]
     end
 
-## Documentation
+== Documentation
 
-Full YARD documentation is [available at Rubyforge](http://carrierwave.rubyforge.org/).
+Full rdoc documentation is {available at Rubyforge}[http://carrierwave.rubyforge.org/].
 
-## Read the source
+== Read the source
 
 CarrierWave is still young, but most of it is pretty well documented. It is also extensively specced, and there are cucumber features for some common use cases. Just dig in and look at the source for more in-depth explanation of what things are doing.

data/Rakefile

@@ -1,12 +1,14 @@
 require 'rubygems'
 require 'rake/gempackagetask'
+require 'rake/rdoctask'
+gem 'rdoc', '>=2.4.0'
+require 'rdoc'
 
-require 'yard'
 require 'spec/rake/spectask'
 require 'cucumber/rake/task'
 
 NAME = "carrierwave"
-GEM_VERSION = "0.1.1"
+GEM_VERSION = "0.2.0"
 AUTHOR = "Jonas Nicklas"
 EMAIL = "jonas.nicklas@gmail.com"
 HOMEPAGE = "http://www.example.com"
@@ -18,14 +20,14 @@ spec = Gem::Specification.new do |s|
   s.version = GEM_VERSION
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
-  s.extra_rdoc_files = ["README.md", "LICENSE", 'TODO']
+  s.extra_rdoc_files = ["README.rdoc", "LICENSE", 'TODO']
   s.summary = SUMMARY
   s.description = s.summary
   s.author = AUTHOR
   s.email = EMAIL
   s.homepage = HOMEPAGE
   s.require_path = 'lib'
-  s.files = %w(LICENSE Generators README.md Rakefile TODO) + Dir.glob("{lib,spec,rails_generators}/**/*")
+  s.files = %w(LICENSE Generators README.rdoc Rakefile TODO) + Dir.glob("{lib,spec,rails_generators}/**/*")
   
 end
 
@@ -38,8 +40,12 @@ Cucumber::Rake::Task.new do |t|
   t.cucumber_opts = "--profile #{profile}"
 end
 
-YARD::Rake::YardocTask.new do |t|
-  t.files   = ["README.md", "LICENSE", "TODO", 'lib/carrierwave/**/*.rb']
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.title = "CarrierWave"
+  rd.options << "--diagram" if ENV["DIAGRAM"]
+  rd.rdoc_dir = File.join(File.dirname(__FILE__), 'doc')
+  rd.rdoc_files.include("README.rdoc", "LICENSE", "TODO", 'lib/carrierwave/**/*.rb')
 end
 
 Rake::GemPackageTask.new(spec) do |pkg|

data/lib/carrierwave/mount.rb

@@ -1,5 +1,5 @@
 module CarrierWave
-  
+
   ##
   # If a Class is extended with this module, it gains the mount_uploader
   # method, which is used for mapping attributes to uploaders and allowing
@@ -13,12 +13,23 @@ module CarrierWave
   module Mount
 
     ##
-    # @return [Hash{Symbol => CarrierWave}] what uploaders are mounted on which columns
+    # === Returns
+    #
+    # [Hash{Symbol => CarrierWave}] what uploaders are mounted on which columns
     #
     def uploaders
       @uploaders ||= {}
     end
 
+    ##
+    # === Returns
+    #
+    # [Hash{Symbol => Hash}] options for mounted uploaders
+    #
+    def uploader_options
+      @uploader_options ||= {}
+    end
+
     ##
     # Mounts the given uploader on the given column. This means that assigning
     # and reading from the column will upload and retrieve files. Supposing
@@ -38,24 +49,50 @@ module CarrierWave
     # but if there is any significatnt logic in the uploader, you should do
     # the right thing and have it in its own file.
     #
-    # @param [Symbol] column the attribute to mount this uploader on
-    # @param [CarrierWave::Uploader] uploader the uploader class to mount
-    # @param [Proc] &block customize anonymous uploaders
-    # @example
+    # === Added instance methods
+    #
+    # Supposing a class has used +mount_uploader+ to mount an uploader on a column
+    # named +image+, in that case the following methods will be added to the class:
+    #
+    # [image]                   Returns an instance of the uploader only if anything has been uploaded
+    # [image=]                  Caches the given file
+    # [image_cache]             Returns a string that identifies the cache location of the file 
+    # [image_cache=]            Retrieves the file from the cache based on the given cache name
+    # [image_uploader]          Returns an instance of the uploader
+    # [image_uploader=]         Sets the uploader (be careful!)
+    # [store_image!]            Stores a file that has been assigned with +image=+
+    # [image_integrity_error]   Returns an error object if the last file to be assigned caused an integrty error
+    #
+    # === Parameters
+    #
+    # [column (Symbol)] the attribute to mount this uploader on
+    # [uploader (CarrierWave::Uploader)] the uploader class to mount
+    # [options (Hash{Symbol => Object})] a set of options
+    # [&block (Proc)] customize anonymous uploaders
+    #
+    # === Options
+    # 
+    # [:ignore_integrity_errors (Boolean)] if set to true, integrity errors will result in caching failing silently
+    #
+    # === Examples
+    #
+    # Mounting uploaders on different columns.
+    #
     #     class Song
     #       mount_uploader :lyrics, LyricsUploader
+    #       mount_uploader :alternative_lyrics, LyricsUploader
     #       mount_uploader :file, SongUploader
     #     end
-    # @example
+    #
+    # This will add an anonymous uploader with only the default settings:
+    #
     #     class Data
-    #       # this will add an anonymous uploader with only
-    #       # the default settings
     #       mount_uploader :csv
     #     end
-    # @example
+    #
+    # this will add an anonymous uploader overriding the store_dir:
+    #
     #     class Product
-    #       # this will add an anonymous uploader overriding
-    #       # the store_dir
     #       mount_uploader :blueprint do
     #         def store_dir
     #           'blueprints'
@@ -63,89 +100,133 @@ module CarrierWave
     #       end
     #     end
     #
-    def mount_uploader(column, uploader=nil, &block)
+    def mount_uploader(column, uploader=nil, options={}, &block)
       unless uploader
-        uploader = Class.new(CarrierWave::Uploader)
+        uploader = Class.new do
+          include CarrierWave::Uploader
+        end
         uploader.class_eval(&block)
       end
 
       uploaders[column.to_sym] = uploader
+      uploader_options[column.to_sym] = CarrierWave.config[:mount].merge(options)
 
       include CarrierWave::Mount::Extension
 
-      class_eval <<-EOF, __FILE__, __LINE__+1
+      class_eval <<-RUBY, __FILE__, __LINE__+1
+        def #{column}_uploader                            # def image_uploader
+          _uploader_get(:#{column})                       #   _uploader_get(:image)
+        end                                               # end
+                                                          #
+        def #{column}_uploader=(uploader)                 # def image_uploader=(uploader)
+          _uploader_set(:#{column}, uploader)             #   _uploader_set(:image, uploader)
+        end                                               # end
+                                                          #
         def #{column}                                     # def image
-          get_uploader(:#{column})                        #   get_uploader(:image)
+          _uploader_get_column(:#{column})                #   _uploader_get_column(:image)
         end                                               # end
                                                           #
         def #{column}=(new_file)                          # def image=(new_file)
-          set_uploader(:#{column}, new_file)              #   set_uploader(:image, new_file)
+          _uploader_set_column(:#{column}, new_file)      #   _uploader_set_column(:image, new_file)
         end                                               # end
                                                           #
         def #{column}_cache                               # def image_cache
-          get_uploader_cache(:#{column})                  #   get_uploader_cache(:image)
+          _uploader_get_cache(:#{column})                 #   _uploader_get_cache(:image)
         end                                               # end
                                                           #
         def #{column}_cache=(cache_name)                  # def image_cache=(cache_name)
-          set_uploader_cache(:#{column}, cache_name)      #   set_uploader_cache(:image, cache_name)
+          _uploader_set_cache(:#{column}, cache_name)     #   _uploader_set_cache(:image, cache_name)
         end                                               # end
                                                           #
         def store_#{column}!                              # def store_image!
-          store_uploader!(:#{column})                     #   store_uploader!(:image)
+          _uploader_store!(:#{column})                    #   _uploader_store!(:image)
         end                                               # end
-      EOF
+                                                          #
+        def #{column}_integrity_error                     # def image_integrity_error
+          _uploader_integrity_errors[:#{column}]          #   _uploader_integrity_errors[:image]
+        end                                               # end
+                                                          #
+        def #{column}_processing_error                    # def image_processing_error
+          _uploader_processing_errors[:#{column}]         #   _uploader_processing_errors[:image]
+        end                                               # end
+      RUBY
     end
 
     module Extension
-    
-    private
-    
+
+      ##
       # overwrite this to read from a serialized attribute
+      #
       def read_uploader(column); end
 
+      ##
       # overwrite this to write to a serialized attribute
+      #
       def write_uploader(column, identifier); end
 
-      def uploaders
-        @uploaders ||= {}
+    private
+
+      def _uploader_get(column)
+        @_uploaders ||= {}
+        @_uploaders[column] ||= self.class.uploaders[column].new(self, column)
       end
-    
-      def store_uploader!(column)
-        unless uploaders[column].blank?
-          uploaders[column].store!
-          write_uploader(column, uploaders[column].identifier)
-        end
+
+      def _uploader_set(column, uploader)
+        @_uploaders ||= {}
+        @_uploaders[column] = uploader
+      end
+
+      def _uploader_options(column)
+        self.class.uploader_options[column]
       end
-    
-      def get_uploader(column)
-        return uploaders[column] unless uploaders[column].blank?
+
+      def _uploader_get_column(column)
+        return _uploader_get(column) unless _uploader_get(column).blank?
 
         identifier = read_uploader(column)
-      
+
         unless identifier.blank?
-          uploaders[column] ||= self.class.uploaders[column].new(self, column)
-          uploaders[column].retrieve_from_store!(identifier)
-          uploaders[column]
+          _uploader_get(column).retrieve_from_store!(identifier)
+          _uploader_get(column)
         end
       end
-    
-      def set_uploader(column, new_file)
-        uploaders[column] ||= self.class.uploaders[column].new(self, column)
-        uploaders[column].cache!(new_file)
+
+      def _uploader_set_column(column, new_file)
+        _uploader_get(column).cache!(new_file)
+        _uploader_integrity_errors[column] = nil
+        _uploader_processing_errors[column] = nil
+      rescue CarrierWave::IntegrityError => e
+        _uploader_integrity_errors[column] = e
+        raise e unless _uploader_options(column)[:ignore_integrity_errors]
+      rescue CarrierWave::ProcessingError => e
+        _uploader_processing_errors[column] = e
+        raise e unless _uploader_options(column)[:ignore_processing_errors]
+      end
+
+      def _uploader_get_cache(column)
+        _uploader_get(column).cache_name
       end
-    
-      def get_uploader_cache(column)
-        uploaders[column].cache_name unless uploaders[column].blank?
+
+      def _uploader_set_cache(column, cache_name)
+        _uploader_get(column).retrieve_from_cache(cache_name) unless cache_name.blank?
       end
 
-      def set_uploader_cache(column, cache_name)
-        unless cache_name.blank?
-          uploaders[column] ||= self.class.uploaders[column].new(self, column)
-          uploaders[column].retrieve_from_cache(cache_name)
+      def _uploader_store!(column)
+        unless _uploader_get(column).blank?
+          _uploader_get(column).store!
+          write_uploader(column, _uploader_get(column).identifier)
         end
       end
 
+      def _uploader_integrity_errors
+        @_uploader_integrity_errors ||= {}
+      end
+
+      def _uploader_processing_errors
+        @_uploader_processing_errors ||= {}
+      end
+
     end # Extension
-  
+
   end # Mount
-end # CarrierWave
+end # CarrierWave

data/lib/carrierwave/orm/activerecord.rb

@@ -4,19 +4,68 @@ module CarrierWave
   module ActiveRecord
 
     include CarrierWave::Mount
-
-    def mount_uploader(column, uploader)
+    
+    ##
+    # See +CarrierWave::Mount#mount_uploader+ for documentation
+    #
+    def mount_uploader(column, uploader, options={}, &block)
       super
 
       alias_method :read_uploader, :read_attribute
       alias_method :write_uploader, :write_attribute
 
+      validates_integrity_of column if uploader_options[column.to_sym][:validate_integrity]
+      validates_processing_of column if uploader_options[column.to_sym][:validate_processing]
+
       before_save do |record|
         record.send("store_#{column}!")
       end
     end
 
+    ##
+    # Makes the record invalid if the file couldn't be uploaded due to an integrity error
+    #
+    # Accepts the usual parameters for validations in Rails (:if, :unless, etc...)
+    #
+    # === Note
+    #
+    # Set this key in your translations file for I18n:
+    #
+    #     carrierwave:
+    #       errors:
+    #         integrity: 'Here be an error message'
+    #
+    def validates_integrity_of(*attrs)
+      options = attrs.last.is_a?(Hash) ? attrs.last : {}
+      options[:message] ||= I18n.t('carrierwave.errors.integrity', :default => 'is not an allowed type of file.')
+      validates_each(*attrs) do |record, attr, value|
+        record.errors.add attr, options[:message] if record.send("#{attr}_integrity_error")
+      end
+    end
+
+    ##
+    # Makes the record invalid if the file couldn't be processed (assuming the process failed
+    # with a CarrierWave::ProcessingError)
+    #
+    # Accepts the usual parameters for validations in Rails (:if, :unless, etc...)
+    #
+    # === Note
+    #
+    # Set this key in your translations file for I18n:
+    #
+    #     carrierwave:
+    #       errors:
+    #         processing: 'Here be an error message'
+    #
+    def validates_processing_of(*attrs)
+      options = attrs.last.is_a?(Hash) ? attrs.last : {}
+      options[:message] ||= I18n.t('carrierwave.errors.processing', :default => 'failed to be processed.')
+      validates_each(*attrs) do |record, attr, value|
+        record.errors.add attr, options[:message] if record.send("#{attr}_processing_error")
+      end
+    end
+
   end # ActiveRecord
 end # CarrierWave
 
-ActiveRecord::Base.send(:extend, CarrierWave::ActiveRecord)
+ActiveRecord::Base.send(:extend, CarrierWave::ActiveRecord)

data/lib/carrierwave/orm/datamapper.rb

@@ -5,7 +5,10 @@ module CarrierWave
 
     include CarrierWave::Mount
 
-    def mount_uploader(column, uploader)
+    ##
+    # See +CarrierWave::Mount#mount_uploader+ for documentation
+    #
+    def mount_uploader(column, uploader, options={}, &block)
       super
 
       alias_method :read_uploader, :attribute_get
@@ -19,4 +22,4 @@ module CarrierWave
   end # DataMapper
 end # CarrierWave
 
-DataMapper::Model.send(:include, CarrierWave::DataMapper)
+DataMapper::Model.send(:include, CarrierWave::DataMapper)