jnicklas-carrierwave 0.1 → 0.1.1

data/README.md

@@ -4,7 +4,13 @@ This plugin for Merb and Rails provides a simple and extremely flexible way to u
 
 ## Getting Started
 
-At the moment you are going to have to grab it here from github and install it yourself.
+Install the latest stable release:
+
+    [sudo] gem install carrierwave
+
+Or the cutting edge development version:
+
+    [sudo] gem install jnicklas-carrierwave --source http://gems.github.com
 
 In Merb, add it as a dependency to your config/dependencies.rb:
     
@@ -20,6 +26,10 @@ Start off by generating an uploader:
 
     merb-gen uploader Avatar
 
+or in Rails:
+
+    script/generate uploader Avatar
+
 this should give you a file in:
 
     app/uploaders/avatar_uploader.rb
@@ -127,6 +137,33 @@ 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
+
+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`.
+In Rails, this would look like this:
+
+    <% form_for @user do |f| %>
+      <p>
+        <label>My Avatar</label>
+        <%= f.file_field :avatar %>
+        <%= f.hidden_field :avatar_cache %>
+      </p>
+    <% end %>
+
+It might be a good idea to show th user that a file has been uploaded,
+in the case of images, a small thumbnail would be a good indicator:
+
+    <% form_for @user do |f| %>
+      <p>
+        <label>My Avatar</label>
+        <%= image_tag(@user.avatar.url) if @user.avatar %>
+        <%= f.file_field :avatar %>
+        <%= f.hidden_field :avatar_cache %>
+      </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:
@@ -206,6 +243,10 @@ And then include it in your model:
       process :crop_resized => [200, 200]
     end
 
+## Documentation
+
+Full YARD documentation is [available at Rubyforge](http://carrierwave.rubyforge.org/).
+
 ## Read the source
 
-CarrierWave is still young, but most of it is pretty well documented. Just dig in and look at the source for more in-depth explanation of what things are doing.
+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

@@ -6,7 +6,7 @@ require 'spec/rake/spectask'
 require 'cucumber/rake/task'
 
 NAME = "carrierwave"
-GEM_VERSION = "0.1"
+GEM_VERSION = "0.1.1"
 AUTHOR = "Jonas Nicklas"
 EMAIL = "jonas.nicklas@gmail.com"
 HOMEPAGE = "http://www.example.com"
@@ -25,7 +25,7 @@ spec = Gem::Specification.new do |s|
   s.email = EMAIL
   s.homepage = HOMEPAGE
   s.require_path = 'lib'
-  s.files = %w(LICENSE Generators README.md Rakefile TODO) + Dir.glob("{lib,spec}/**/*")
+  s.files = %w(LICENSE Generators README.md Rakefile TODO) + Dir.glob("{lib,spec,rails_generators}/**/*")
   
 end
 

data/lib/carrierwave.rb

@@ -7,7 +7,12 @@ module CarrierWave
   
   class UploadError < StandardError; end
   class NoFileError < UploadError; end
-  class FormNotMultipart < UploadError; end
+  class FormNotMultipart < UploadError
+    def message
+      "You tried to assign a String or a Pathname to an uploader, for security reasons, this is not allowed.\n\n If this is a file upload, please check that your upload form is multipart encoded."
+    end
+  end
+  class IntegrityError < UploadError; end
   class InvalidParameter < UploadError; end
   # Should be used by methods used as process callbacks.
   class ProcessingError < UploadError; end
@@ -32,8 +37,8 @@ CarrierWave.config = {
   :s3 => {
     :access => :public_read
   },
-  :store_dir => 'public/uploads',
-  :cache_dir => 'public/uploads/tmp'
+  :store_dir => 'uploads',
+  :cache_dir => 'uploads/tmp'
 }
 
 if defined?(Merb)
@@ -43,7 +48,7 @@ if defined?(Merb)
   orm_path = File.dirname(__FILE__) / 'carrierwave' / 'orm' / Merb.orm
   require orm_path if File.exist?(orm_path + '.rb')
   
-  Merb.push_path(:model, Merb.root / "app" / "uploaders")
+  Merb.push_path(:uploader, Merb.root / "app" / "uploaders")
   
   Merb.add_generators File.dirname(__FILE__) / 'generators' / 'uploader_generator'
 end

data/lib/carrierwave/mount.rb

@@ -1,23 +1,124 @@
 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
+  # easy assignment.
+  #
+  # You can use mount_uploader with pretty much any class, however it is
+  # intended to be used with some kind of persistent storage, like an ORM.
+  # If you want to persist the uploaded files in a particular Class, it
+  # needs to implement a `read_uploader` and a `write_uploader` method.
+  #
   module Mount
+
+    ##
+    # @return [Hash{Symbol => CarrierWave}] what uploaders are mounted on which columns
+    #
+    def uploaders
+      @uploaders ||= {}
+    end
+
+    ##
+    # Mounts the given uploader on the given column. This means that assigning
+    # and reading from the column will upload and retrieve files. Supposing
+    # that a User class has an uploader mounted on image, you can assign and
+    # retrieve files like this:
+    #
+    #     @user.image # => <Uploader>
+    #     @user.image = some_file_object
+    #
+    #     @user.store_image!
+    #
+    #     @user.image.url # => '/some_url.png'
+    #
+    # It is also possible (but not recommended) to ommit the uploader, which
+    # will create an anonymous uploader class. Passing a block to this method
+    # makes it possible to customize it. This can be convenient for brevity,
+    # 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
+    #     class Song
+    #       mount_uploader :lyrics, LyricsUploader
+    #       mount_uploader :file, SongUploader
+    #     end
+    # @example
+    #     class Data
+    #       # this will add an anonymous uploader with only
+    #       # the default settings
+    #       mount_uploader :csv
+    #     end
+    # @example
+    #     class Product
+    #       # this will add an anonymous uploader overriding
+    #       # the store_dir
+    #       mount_uploader :blueprint do
+    #         def store_dir
+    #           'blueprints'
+    #         end
+    #       end
+    #     end
+    #
+    def mount_uploader(column, uploader=nil, &block)
+      unless uploader
+        uploader = Class.new(CarrierWave::Uploader)
+        uploader.class_eval(&block)
+      end
+
+      uploaders[column.to_sym] = uploader
+
+      include CarrierWave::Mount::Extension
+
+      class_eval <<-EOF, __FILE__, __LINE__+1
+        def #{column}                                     # def image
+          get_uploader(:#{column})                        #   get_uploader(:image)
+        end                                               # end
+                                                          #
+        def #{column}=(new_file)                          # def image=(new_file)
+          set_uploader(:#{column}, new_file)              #   set_uploader(:image, new_file)
+        end                                               # end
+                                                          #
+        def #{column}_cache                               # def image_cache
+          get_uploader_cache(:#{column})                  #   get_uploader_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)
+        end                                               # end
+                                                          #
+        def store_#{column}!                              # def store_image!
+          store_uploader!(:#{column})                     #   store_uploader!(:image)
+        end                                               # end
+      EOF
+    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 ||= {}
       end
     
       def store_uploader!(column)
-        if uploaders[column]
+        unless uploaders[column].blank?
           uploaders[column].store!
           write_uploader(column, uploaders[column].identifier)
         end
       end
     
       def get_uploader(column)
-        return uploaders[column] if uploaders[column]
+        return uploaders[column] unless uploaders[column].blank?
 
         identifier = read_uploader(column)
       
@@ -29,16 +130,12 @@ module CarrierWave
       end
     
       def set_uploader(column, new_file)
-        new_file = CarrierWave::SanitizedFile.new(new_file)
-      
-        unless new_file.empty?
-          uploaders[column] ||= self.class.uploaders[column].new(self, column)
-          uploaders[column].cache!(new_file) 
-        end
+        uploaders[column] ||= self.class.uploaders[column].new(self, column)
+        uploaders[column].cache!(new_file)
       end
     
       def get_uploader_cache(column)
-        uploaders[column].cache_name if uploaders[column]
+        uploaders[column].cache_name unless uploaders[column].blank?
       end
 
       def set_uploader_cache(column, cache_name)
@@ -50,44 +147,5 @@ module CarrierWave
 
     end # Extension
   
-    def uploaders
-      @uploaders ||= {}
-    end
-  
-    def mount_uploader(column, uploader=nil, &block)
-      unless uploader
-        uploader = Class.new(CarrierWave::Uploader)
-        uploader.class_eval(&block)
-      end
-    
-      uploaders[column.to_sym] = uploader
-    
-      include CarrierWave::Mount::Extension
-    
-      class_eval <<-EOF, __FILE__, __LINE__+1
-        def #{column}                                     # def image
-          get_uploader(:#{column})                        #   get_uploader(:image)
-        end                                               # end
-                                                          #
-        def #{column}=(new_file)                          # def image=(new_file)
-          set_uploader(:#{column}, new_file)              #   set_uploader(:image, new_file)
-        end                                               # end
-                                                          #
-        def #{column}_cache                               # def image_cache
-          get_uploader_cache(:#{column})                  #   get_uploader_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)
-        end                                               # end
-                                                          #
-        def store_#{column}!                              # def store_image!
-          store_uploader!(:#{column})                     #   store_uploader!(:image)
-        end                                               # end
-      EOF
-    
-      after_mount(column, uploader) if respond_to?(:after_mount)
-    end
-  
   end # Mount
 end # CarrierWave

data/lib/carrierwave/orm/activerecord.rb

@@ -5,7 +5,9 @@ module CarrierWave
 
     include CarrierWave::Mount
 
-    def after_mount(column, uploader)
+    def mount_uploader(column, uploader)
+      super
+
       alias_method :read_uploader, :read_attribute
       alias_method :write_uploader, :write_attribute
 

data/lib/carrierwave/orm/datamapper.rb

@@ -5,7 +5,9 @@ module CarrierWave
 
     include CarrierWave::Mount
 
-    def after_mount(column, uploader)
+    def mount_uploader(column, uploader)
+      super
+
       alias_method :read_uploader, :attribute_get
       alias_method :write_uploader, :attribute_set
 

data/lib/carrierwave/sanitized_file.rb

@@ -1,5 +1,14 @@
 module CarrierWave
-    class SanitizedFile
+
+  ##
+  # SanitizedFile is a base class which provides a common API around all
+  # the different quirky Ruby File libraries. It has support for Tempfile,
+  # File, StringIO, Merb-style upload Hashes, as well as paths given as
+  # Strings and Pathnames.
+  #
+  # It's probably needlessly comprehensive and complex. Help is appreciated.
+  #
+  class SanitizedFile
 
     attr_accessor :file, :options
 
@@ -58,10 +67,12 @@ module CarrierWave
     # @return [Integer] the file's size in bytes.
     #
     def size
-      if @file.respond_to?(:size)
+      if string?
+        exists? ? File.size(path) : 0
+      elsif @file.respond_to?(:size)
         @file.size 
       elsif path
-        File.size(path)
+        exists? ? File.size(path) : 0
       else 
         0
       end
@@ -97,7 +108,7 @@ module CarrierWave
     # @return [Boolean]
     #
     def empty?
-      (@file.nil? && @path.nil?) || self.size.nil? || self.size.zero?
+      @file.nil? || self.size.nil? || self.size.zero?
     end
 
     ##
@@ -208,7 +219,7 @@ module CarrierWave
       name = name.gsub("\\", "/") # work-around for IE
       name = File.basename(name)
       name = name.gsub(/[^a-zA-Z0-9\.\-\+_]/,"_")
-      name = "_#{name}" if name =~ /^\.+$/
+      name = "_#{name}" if name =~ /\A\.+\z/
       name = "unnamed" if name.size == 0
       return name.downcase
     end
@@ -216,8 +227,8 @@ module CarrierWave
     def split_extension(fn)
       # regular expressions to try for identifying extensions
       ext_regexps = [ 
-        /^(.+)\.([^\.]{1,3}\.[^\.]{1,4})$/, # matches "something.tar.gz"
-        /^(.+)\.([^\.]+)$/ # matches "something.jpg"
+        /\A(.+)\.([^\.]{1,3}\.[^\.]{1,4})\z/, # matches "something.tar.gz"
+        /\A(.+)\.([^\.]+)\z/ # matches "something.jpg"
       ]
       ext_regexps.each do |regexp|
         if fn =~ regexp

data/lib/carrierwave/storage/abstract.rb

@@ -1,5 +1,6 @@
 module CarrierWave
   module Storage
+
     ##
     # This file serves mostly as a specification for Storage engines. There is no requirement
     # that storage engines must be a subclass of this class. However, any storage engine must

data/lib/carrierwave/storage/file.rb

@@ -1,5 +1,11 @@
 module CarrierWave
   module Storage
+
+    ##
+    # File storage stores file to the Filesystem (surprising, no?). There's really not much
+    # to it, it uses the store_dir defined on the uploader as the storage location. That's
+    # pretty much it.
+    #
     class File < Abstract
       
       def initialize(uploader)
@@ -16,7 +22,7 @@ module CarrierWave
       #
       def self.store!(uploader, file)
         path = ::File.join(uploader.store_dir, uploader.filename)
-        path = ::File.expand_path(path, uploader.root)
+        path = ::File.expand_path(path, uploader.public)
         file.move_to(path)
         file
       end
@@ -31,7 +37,7 @@ module CarrierWave
       #
       def self.retrieve!(uploader, identifier)
         path = ::File.join(uploader.store_dir, identifier)
-        path = ::File.expand_path(path, uploader.root)
+        path = ::File.expand_path(path, uploader.public)
         CarrierWave::SanitizedFile.new(path)
       end
       

data/lib/carrierwave/storage/s3.rb

@@ -1,7 +1,31 @@
 module CarrierWave
   module Storage
+
     ##
-    # Uploads things to Amazon S3 webservices
+    # Uploads things to Amazon S3 webservices. It requies the aws/s3 gem. In order for
+    # CarrierWave to connect to Amazon S3, you'll need to specify an access key id, secret key
+    # and bucket
+    #
+    #     CarrierWave.config[:s3][:access_key_id] = "xxxxxx"
+    #     CarrierWave.config[:s3][:secret_access_key] = "xxxxxx"
+    #     CarrierWave.config[:s3][:bucket] = "my_bucket_name"
+    #
+    # You can also set the access policy for the uploaded files:
+    #
+    #     CarrierWave.config[:s3][:access] = :public_read
+    #
+    # Possible values are the 'canned access control policies' provided in the aws/s3 gem,
+    # they are:
+    #
+    #     :private              No one else has any access rights.
+    #     :public_read          The anonymous principal is granted READ access.
+    #                           If this policy is used on an object, it can be read from a
+    #                           browser with no authentication.
+    #     :public_read_write    The anonymous principal is granted READ and WRITE access.
+    #     :authenticated_read   Any principal authenticated as a registered Amazon S3 user
+    #                           is granted READ access.
+    #
+    # The default is :public_read, it should work in most cases.
     #
     class S3 < Abstract
       
@@ -75,7 +99,7 @@ module CarrierWave
       # @return [String] file's url
       #
       def url
-        "http://s3.amazonaws.com/#{self.class.bucket}/#{@store_dir}/#{@identifier}"
+        ["http://s3.amazonaws.com", self.class.bucket, @store_dir, @identifier].compact.join('/')
       end
       
     end # S3

data/lib/carrierwave/uploader.rb

@@ -1,6 +1,22 @@
 module CarrierWave
+
+  ##
+  # An uploader is a class that allows you to easily handle the caching and storage of
+  # uploaded files. Please refer to the README for configuration options.
+  #
+  # Once you have an uploader you can use it in isolation:
+  #
+  #     my_uploader = MyUploader.new
+  #     my_uploader.cache!(File.open(path_to_file))
+  #     my_uploader.retrieve_from_store!('monkey.png')
+  #
+  # Alternatively, you can mount it on an ORM or other persistence layer, with
+  # +CarrierWave::Mount#mount_uploader+. There are extensions for activerecord and datamapper
+  # these are *very* simple (they are only a dozen lines of code), so adding your own should
+  # be trivial.
+  #
   class Uploader
-  
+
     class << self
     
       ##
@@ -157,7 +173,14 @@ module CarrierWave
     end
     
     ##
-    # Apply all process callbacks added through CarrierWaveer.process
+    # @return [Boolean] Whether the uploaded file is blank
+    #
+    def blank?
+      !file or file.empty?
+    end
+    
+    ##
+    # Apply all process callbacks added through CarrierWave.process
     #
     def process!
       self.class.processors.each do |method, args|
@@ -193,7 +216,7 @@ module CarrierWave
       if file.respond_to?(:url) and not file.url.blank?
         file.url
       elsif current_path
-        File.expand_path(current_path).gsub(File.expand_path(CarrierWave.config[:public]), '')
+        File.expand_path(current_path).gsub(File.expand_path(public), '')
       end
     end
     
@@ -232,11 +255,30 @@ module CarrierWave
     end
     
     ##
-    # @return [String] the directory relative to which we will upload
+    # @return [String] the directory that is the root of the application
     #
     def root
       CarrierWave.config[:root]
     end
+    
+    ##
+    # @return [String] the directory where files will be publically accessible
+    #
+    def public
+      CarrierWave.config[:public]
+    end
+
+    ##
+    # Override this method in your uploader to provide a white list of extensions which
+    # are allowed to be uploaded.
+    #
+    # @return [NilClass, Array[String]] a white list of extensions which are allowed to be uploaded
+    # @example
+    #     def extension_white_list
+    #       %w(jpg jpeg gif png)
+    #     end
+    #
+    def extension_white_list; end
   
     ####################
     ## Cache
@@ -277,21 +319,28 @@ module CarrierWave
     # @raise [CarrierWave::FormNotMultipart] if the assigned parameter is a string
     #
     def cache!(new_file)
-      self.cache_id = CarrierWave::Uploader.generate_cache_id unless cache_id
       new_file = CarrierWave::SanitizedFile.new(new_file)
-      raise CarrierWave::FormNotMultipart, "check that your upload form is multipart encoded" if new_file.string?
+      raise CarrierWave::FormNotMultipart if new_file.string?
 
-      @file = new_file
+      unless new_file.empty?
+        if extension_white_list and not extension_white_list.include?(new_file.extension.to_s)
+          raise CarrierWave::IntegrityError, "You are not allowed to upload #{new_file.extension.inspect} files, allowed types: #{extension_white_list.inspect}"
+        end
 
-      @filename = new_file.filename
-      self.original_filename = new_file.filename
+        self.cache_id = CarrierWave::Uploader.generate_cache_id unless cache_id
+
+        @file = new_file
+
+        @filename = new_file.filename
+        self.original_filename = new_file.filename
       
-      @file = @file.copy_to(cache_path)
-      process!
+        @file = @file.copy_to(cache_path)
+        process!
 
-      versions.each do |name, v|
-        v.send(:cache_id=, cache_id)
-        v.cache!(new_file)
+        versions.each do |name, v|
+          v.send(:cache_id=, cache_id)
+          v.cache!(new_file)
+        end
       end
     end
     
@@ -352,35 +401,25 @@ module CarrierWave
     #
     # If new_file is omitted, a previously cached file will be stored.
     #
-    # If CarrierWave.config[:use_cache] is true, it will first cache the file
-    # and apply any process callbacks before uploading it.
-    #
     # @param [File, IOString, Tempfile] new_file any kind of file object
     #
     def store!(new_file=nil)
-      if CarrierWave.config[:use_cache]
-        cache!(new_file) if new_file
+      cache!(new_file) if new_file
+      if @file
         @file = storage.store!(self, @file)
         @cache_id = nil
-      else
-        new_file = CarrierWave::SanitizedFile.new(new_file)
-        
-        @filename = new_file.filename
-        self.original_filename = filename
-        
-        @file = storage.store!(self, new_file)
+        versions.each { |name, v| v.store!(new_file) }
       end
-      versions.each { |name, v| v.store!(new_file) }
     end
     
     ##
     # Retrieves the file from the storage, unless a file has
     # already been cached, stored or retrieved.
     # 
-    # @param [String] filename uniquely identifies the file to retrieve
+    # @param [String] identifier uniquely identifies the file to retrieve
     #
-    def retrieve_from_store(filename)
-      retrieve_from_store!(filename) unless file
+    def retrieve_from_store(identifier)
+      retrieve_from_store!(identifier) unless file
     rescue CarrierWave::InvalidParameter
     end
     
@@ -397,7 +436,7 @@ module CarrierWave
   private
   
     def cache_path
-      File.expand_path(File.join(cache_dir, cache_name), root)
+      File.expand_path(File.join(cache_dir, cache_name), public)
     end
   
     def storage
@@ -407,12 +446,12 @@ module CarrierWave
     attr_reader :cache_id, :original_filename
 
     def cache_id=(cache_id)
-      raise CarrierWave::InvalidParameter, "invalid cache id" unless cache_id =~ /^[\d]{8}\-[\d]{4}\-[\d]+\-[\d]{4}$/
+      raise CarrierWave::InvalidParameter, "invalid cache id" unless cache_id =~ /\A[\d]{8}\-[\d]{4}\-[\d]+\-[\d]{4}\z/
       @cache_id = cache_id
     end
     
     def original_filename=(filename)
-      raise CarrierWave::InvalidParameter, "invalid filename" unless filename =~ /^[a-z0-9\.\-\+_]+$/i
+      raise CarrierWave::InvalidParameter, "invalid filename" unless filename =~ /\A[a-z0-9\.\-\+_]+\z/i
       @original_filename = filename
     end
     

data/lib/generators/uploader_generator.rb

@@ -3,13 +3,13 @@ module Merb
     class UploaderGenerator < NamedGenerator
       
       def self.source_root
-        File.join(File.dirname(__FILE__), 'templates')
+        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.rbt'
+        t.source = 'uploader.rb'
         t.destination = "app/uploaders/#{file_name}_uploader.rb"
       end
     end

data/rails_generators/uploader/USAGE

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

data/{lib/generators/templates/uploader.rbt → rails_generators/uploader/templates/uploader.rb}

@@ -6,6 +6,7 @@ class <%= class_name %>Uploader < CarrierWave::Uploader
   
   # Choose what kind of storage to use for this uploader
   storage :file
+  #     storage :s3
   
   # Process files as they are uploaded.
   #     process :scale => [200, 300]
@@ -14,14 +15,14 @@ class <%= class_name %>Uploader < CarrierWave::Uploader
   #       # do something
   #     end 
   
-  # Create different verions of your uploaded files
+  # Create different versions of your uploaded files
   #     version :thumb do
   #       process :scale => [50, 50]
   #     end
   
   # Override the filename of the uploaded files
   #     def filename
-  #       "something"
+  #       "something.jpg"
   #     end
   
   # Override the directory where uploaded files will be stored

data/rails_generators/uploader/uploader_generator.rb

@@ -0,0 +1,19 @@
+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/spec/mount_spec.rb

@@ -97,6 +97,7 @@ describe CarrierWave::Mount 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

data/spec/sanitized_file_spec.rb

@@ -168,6 +168,12 @@ describe CarrierWave::SanitizedFile do
       end
     end
 
+    describe "#size" do
+      it "should return the size of the file" do
+        @sanitized_file.size.should == 13
+      end
+    end
+
     describe '#move_to' do
     
       after do

data/spec/spec_helper.rb

@@ -29,8 +29,6 @@ end
 
 CarrierWave.config[:public] = public_path
 CarrierWave.config[:root] = File.expand_path(File.dirname(__FILE__))
-CarrierWave.config[:store_dir] = 'public/uploads'
-CarrierWave.config[:cache_dir] = 'public/uploads/tmp'
 
 module SanitizedFileSpecHelper
   def stub_merb_tempfile(filename)

data/spec/uploader_spec.rb

@@ -55,7 +55,7 @@ describe CarrierWave::Uploader do
           public_path('monkey/apache')
         end
       end
-      @uploader.store_dir.should == 'public/uploads'
+      @uploader.store_dir.should == 'uploads'
       @uploader.thumb.store_dir.should == public_path('monkey/apache')
     end
     
@@ -133,15 +133,31 @@ describe CarrierWave::Uploader do
     end
   end
   
+  describe '#blank' do
+    it "should be true when nothing has been done" do
+      @uploader.should be_blank
+    end
+
+    it "should not be true when the file is empty" do
+      @uploader.retrieve_from_cache!('20071201-1234-345-2255/test.jpeg')
+      @uploader.should be_blank
+    end
+
+    it "should not be true when a file has been cached" do
+      @uploader.cache!(File.open(file_path('test.jpg')))
+      @uploader.should_not be_blank      
+    end
+  end
+  
   describe '#store_dir' do
     it "should default to the config option" do
-      @uploader.store_dir.should == 'public/uploads'
+      @uploader.store_dir.should == 'uploads'
     end
   end
   
   describe '#cache_dir' do
     it "should default to the config option" do
-      @uploader.cache_dir.should == 'public/uploads/tmp'
+      @uploader.cache_dir.should == 'uploads/tmp'
     end
   end
   
@@ -258,6 +274,43 @@ describe CarrierWave::Uploader do
       @uploader.should_receive(:process!)
       @uploader.cache!(File.open(file_path('test.jpg')))
     end
+    
+    it "should raise an error when trying to cache a string" do
+      running {
+        @uploader.cache!(file_path('test.jpg'))
+      }.should raise_error(CarrierWave::FormNotMultipart)
+    end
+    
+    it "should raise an error when trying to cache a pathname" do
+      running {
+        @uploader.cache!(Pathname.new(file_path('test.jpg')))
+      }.should raise_error(CarrierWave::FormNotMultipart)
+    end
+    
+    it "should do nothing when trying to cache an empty file" do
+      @uploader.cache!(nil)
+    end
+    
+    it "should not raise an integiry error if there is no white list" do
+      @uploader.stub!(:extension_white_list).and_return(nil)
+      running {
+        @uploader.cache!(File.open(file_path('test.jpg')))
+      }.should_not raise_error(CarrierWave::IntegrityError)
+    end
+    
+    it "should not raise an integiry error if there is a white list and the file is on it" do
+      @uploader.stub!(:extension_white_list).and_return(%w(jpg gif png))
+      running {
+        @uploader.cache!(File.open(file_path('test.jpg')))
+      }.should_not raise_error(CarrierWave::IntegrityError)
+    end
+
+    it "should raise an integiry error if there is a white list and the file is not on it" do
+      @uploader.stub!(:extension_white_list).and_return(%w(txt doc xls))
+      running {
+        @uploader.cache!(File.open(file_path('test.jpg')))
+      }.should raise_error(CarrierWave::IntegrityError)
+    end
   end
   
   describe '#retrieve_from_cache!' do
@@ -375,14 +428,8 @@ describe CarrierWave::Uploader do
       @uploader.store!(@file)
     end
     
-    it "should, if a files is given as an argument and use_cache is false, not cache that file" do
-      CarrierWave.config[:use_cache] = false
-      @uploader.should_not_receive(:cache!)
-      @uploader.store!(@file)
-      CarrierWave.config[:use_cache] = true
-    end
-    
     it "should use a previously cached file if no argument is given" do
+      @uploader.cache!(File.open(file_path('test.jpg')))
       @uploader.should_not_receive(:cache!)
       @uploader.store!
     end
@@ -403,6 +450,10 @@ describe CarrierWave::Uploader do
       @uploader.store!(@file)
       @uploader.file.should == @stored_file
     end
+    
+    it "should do nothing when trying to store an empty file" do
+      @uploader.store!(nil)
+    end
   end
   
   describe '#retrieve_from_store!' do
@@ -494,8 +545,8 @@ describe CarrierWave::Uploader do
 
       it "should suffix the version's store_dir" do
         @uploader.cache!(File.open(file_path('test.jpg')))
-        @uploader.store_dir.should == 'public/uploads'
-        @uploader.thumb.store_dir.should == 'public/uploads/thumb'
+        @uploader.store_dir.should == 'uploads'
+        @uploader.thumb.store_dir.should == 'uploads/thumb'
       end
       
       it "should move it to the tmp dir with the filename prefixed" do
@@ -516,8 +567,8 @@ describe CarrierWave::Uploader do
     
       it "should suffix the version's store_dir" do
         @uploader.retrieve_from_cache!('20071201-1234-345-2255/test.jpg')
-        @uploader.store_dir.should == 'public/uploads'
-        @uploader.thumb.store_dir.should == 'public/uploads/thumb'
+        @uploader.store_dir.should == 'uploads'
+        @uploader.thumb.store_dir.should == 'uploads/thumb'
       end
     end
     
@@ -551,15 +602,15 @@ describe CarrierWave::Uploader do
     
       it "should, if a file is given as argument, suffix the version's store_dir" do
         @uploader.store!(@file)
-        @uploader.store_dir.should == 'public/uploads'
-        @uploader.thumb.store_dir.should == 'public/uploads/thumb'
+        @uploader.store_dir.should == 'uploads'
+        @uploader.thumb.store_dir.should == 'uploads/thumb'
       end
     
       it "should, if a files is given as an argument and use_cache is false, suffix the version's store_dir" do
         CarrierWave.config[:use_cache] = false
         @uploader.store!(@file)
-        @uploader.store_dir.should == 'public/uploads'
-        @uploader.thumb.store_dir.should == 'public/uploads/thumb'
+        @uploader.store_dir.should == 'uploads'
+        @uploader.thumb.store_dir.should == 'uploads/thumb'
       end
     
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jnicklas-carrierwave
 version: !ruby/object:Gem::Version 
-  version: "0.1"
+  version: 0.1.1
 platform: ruby
 authors: 
 - Jonas Nicklas
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-02 00:00:00 -08:00
+date: 2009-03-13 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -45,8 +45,6 @@ files:
 - lib/carrierwave/uploader.rb
 - lib/carrierwave.rb
 - lib/generators
-- lib/generators/templates
-- lib/generators/templates/uploader.rbt
 - lib/generators/uploader_generator.rb
 - spec/fixtures
 - spec/fixtures/bork.txt
@@ -59,6 +57,11 @@ files:
 - spec/sanitized_file_spec.rb
 - spec/spec_helper.rb
 - spec/uploader_spec.rb
+- rails_generators/uploader
+- rails_generators/uploader/templates
+- rails_generators/uploader/templates/uploader.rb
+- rails_generators/uploader/uploader_generator.rb
+- rails_generators/uploader/USAGE
 has_rdoc: true
 homepage: http://www.example.com
 post_install_message: