dsturnbull-carrierwave 0.4.5

data/README.rdoc

@@ -0,0 +1,502 @@
+= CarrierWave
+
+http://carrierwave.rubyforge.org
+
+== Summary
+
+This plugin for Merb and Rails provides a simple and extremely flexible way to
+upload files.
+
+== Description
+
+* RDoc Documentation {available at Rubyforge}[http://carrierwave.rubyforge.org/rdoc].
+* Source code {hosted at GitHub}[http://github.com/jnicklas/carrierwave]
+* Please {report any issues}[http://github.com/jnicklas/carrierwave/issues] on GitHub
+* Please direct any questions at the {mailing list}[http://groups.google.com/group/carrierwave]
+* Check out the {example app}[http://github.com/jnicklas/carrierwave-example-app]
+
+== Getting Started
+
+Install the latest stable release:
+
+    [sudo] gem install carrierwave
+
+In Merb, add it as a dependency to your config/dependencies.rb:
+
+    dependency 'carrierwave'
+
+In Rails, add it to your environment.rb:
+
+    config.gem "carrierwave"
+
+== Quick Start
+
+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
+
+Check out this file for some hints on how you can customize your uploader. It
+should look something like this:
+
+    class AvatarUploader < CarrierWave::Uploader::Base
+      storage :file
+    end
+
+You can use your uploader class to store and retrieve files like this:
+
+    uploader = AvatarUploader.new
+
+    uploader.store!(my_file)
+
+    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, an Amazon S3 store and a store for MongoDB's GridFS 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, DataMapper, Sequel, MongoMapper
+
+Make sure you are loading CarrierWave after loading your ORM, otherwise you'll
+need to require the relevant extension manually, e.g.:
+
+    require 'carrierwave/orm/activerecord'
+
+Add a string column to the model you want to mount the uploader on:
+
+    add_column :user, :avatar, :string
+
+Open your model file and mount the uploader:
+
+    class User
+      mount_uploader :avatar, AvatarUploader
+    end
+
+This works the same with all supported ORMs.
+
+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]
+    u.avatar = File.open('somewhere')
+    u.save!
+    u.avatar.url # => '/url/to/file.png'
+    u.avatar.current_path # => 'path/to/file.png'
+
+== Changing the storage directory
+
+In order to change where uploaded files are put, just override the +store_dir+
+method:
+
+    class MyUploader < CarrierWave::Uploader::Base
+      def store_dir
+        'public/my/upload/directory'
+      end
+    end
+
+This works for the file storage as well as Amazon S3.
+
+== Securing uploads
+
+Certain file might be dangerous if uploaded to the wrong location, such as php files or other script files. CarrierWave allows you to specify a white-list of allowed extensions.
+
+If you're mounting the uploader, uploading a file with the wrong extension will make the record invalid instead. Otherwise, an error is raised.
+
+    class MyUploader < CarrierWave::Uploader::Base
+      def extension_white_list
+        %w(jpg jpeg gif png)
+      end
+    end
+
+== 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::Base
+      include CarrierWave::RMagick
+
+      process :resize_to_fit => [800, 800]
+
+      version :thumb do
+        process :resize_to_fill => [200,200]
+      end
+
+    end
+
+When this uploader is used, an uploaded image would be scaled to be no larger
+than 800 by 800 pixels. A version called thumb is then created, which is scaled
+and cropped to exactly 200 by 200 pixels. The uploader could be used like this:
+
+    uploader = AvatarUploader.new
+    uploader.store!(my_file)                              # size: 1024x768
+
+    uploader.url # => '/url/to/my_file.png'               # size: 800x600
+    uploader.thumb.url # => '/url/to/thumb_my_file.png'   # size: 200x200
+
+One important thing to remember is that process is called *before* versions are
+created. This can cut down on processing cost.
+
+It is possible to nest versions within versions:
+
+    class MyUploader < CarrierWave::Uploader::Base
+
+      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+. 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 the 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 %>
+
+== Removing uploaded files
+
+If you want to remove a previously uploaded file on a mounted uploader, you can
+easily add a checkbox to the form which will remove the file when checked.
+
+    <% form_for @user do |f| %>
+      <p>
+        <label>My Avatar</label>
+        <%= image_tag(@user.avatar_url) if @user.avatar? %>
+        <%= f.file_field :avatar %>
+      </p>
+
+      <p>
+        <label>
+          <%= f.check_box :remove_avatar %>
+          Remove avatar
+        </label>
+      </p>
+    <% end %>
+
+If you want to remove the file manually, you can call <code>remove_avatar!</code>.
+
+== Uploading files from a remote location
+
+Your users may find it convenient to upload a file from a location on the Internet
+via a URL. CarrierWave makes this simple, just add the appropriate column to your
+form and you're good to go:
+
+    <% form_for @user do |f| %>
+      <p>
+        <label>My Avatar URL:</label>
+        <%= image_tag(@user.avatar_url) if @user.avatar? %>
+        <%= f.text_field :remote_avatar_url %>
+      </p>
+    <% end %>
+
+== Providing a default URL
+
+In many cases, especially when working with images, it might be a good idea to
+provide a default url, a fallback in case no file has been uploaded. You can do
+this easily by overriding the +default_url+ method in your uploader:
+
+    class MyUploader < CarrierWave::Uploader::Base
+      def default_url
+        "/images/fallback/" + [version_name, "default.png"].compact.join('_')
+      end
+    end
+
+== Configuring CarrierWave
+
+CarrierWave has a broad range of configuration options, which you can configure,
+both globally and on a per-uploader basis:
+
+    CarrierWave.configure do |config|
+      config.permissions = 0666
+      config.storage = :s3
+    end
+
+Or alternatively:
+
+    class AvatarUploader < CarrierWave::Uploader::Base
+      permissions 0777
+    end
+
+== Testing CarrierWave
+
+It's a good idea to test you uploaders in isolation. In order to speed up your
+tests, it's recommended to switch off processing in your tests, and to use the
+file storage. In Rails you could do that by adding an initializer with:
+
+    if Rails.env.test?
+      CarrierWave.configure do |config|
+        config.storage = :file
+        config.enable_processing = false
+      end
+    end
+
+If you need to test your processing, you should test it in isolation, and enable
+processing only for those tests that need it.
+
+CarrierWave comes with some RSpec matchers which you may find useful:
+
+    require 'carrierwave/test/matchers'
+
+    describe MyUploader do
+      before do
+        MyUploader.enable_processing = true
+        @uploader = MyUploader.new(@user, :avatar)
+        @uploader.store!(File.open(path_to_file))
+      end
+
+      after do
+        MyUploader.enable_processing = false
+      end
+
+      context 'the thumb version' do
+        it "should scale down a landscape image to be exactly 64 by 64 pixels" do
+          @uploader.thumb.should have_dimensions(200, 200)
+        end
+      end
+
+      context 'the small version' do
+        it "should scale down a landscape image to fit within 200 by 200 pixels" do
+          @uploader.small.should be_no_larger_than(200, 200)
+        end
+      end
+
+      it "should make the image readable only to the owner and not executable" do
+        @uploader.should have_premissions(0600)
+      end
+    end
+
+== Using Amazon S3
+
+You'll need to configure a bucket, access id and secret key like this:
+
+    CarrierWave.configure do |config|
+      config.s3_access_key_id = 'xxxxxx'
+      config.s3_secret_access_key = 'xxxxxx'
+      config.s3_bucket = 'name_of_bucket'
+    end
+
+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::Base
+      storage :s3
+    end
+
+That's it! You can still use the <code>CarrierWave::Uploader#url</code> method to return
+the url to the file on Amazon S3.
+
+Alternatively, and especially if your bucket is located in Europe, you can use the
+RightAWS library by setting the storage to :right_s3
+
+    class AvatarUploader < CarrierWave::Uploader::Base
+      storage :right_s3
+    end
+
+CarrierWave uses the RightAWS S3 Interface directly, meaning that the performance issues
+mentioned by Jonathan Yurek for paperclip do not apply: http://groups.google.com/group/paperclip-plugin/browse_thread/thread/d4dc166a9a5f0df4#
+
+
+== Using MongoDB's GridFS store
+
+You'll need to configure the database and host to use:
+
+    CarrierWave.configure do |config|
+      config.grid_fs_database = 'my_mongo_database'
+      config.grid_fs_host = 'mongo.example.com'
+    end
+
+The defaults are 'carrierwave' and 'localhost'.
+
+And then in your uploader, set the storage to <code>:grid_fs</code>:
+
+    class AvatarUploader < CarrierWave::Uploader::Base
+      storage :grid_fs
+    end
+
+Since GridFS doesn't make the files available via HTTP, you'll need to stream
+them yourself. In Rails for example, you could use the +send_data+ method. You
+can tell CarrierWave the URL you will serve your images from, allowing it to
+generate the correct URL, by setting eg:
+
+    CarrierWave.configure do |config|
+      config.grid_fs_access_url = "/image/show"
+    end
+
+== 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, you'll need to
+include it in your Uploader:
+
+    class AvatarUploader < CarrierWave::Uploader::Base
+      include CarrierWave::RMagick
+    end
+
+The RMagick module gives you a few methods, like
+<code>CarrierWave::RMagick#resize_to_fill</code> 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::Base
+      include CarrierWave::RMagick
+
+      process :resize_to_fill => [200, 200]
+      process :convert => 'png'
+
+      def filename
+        super + '.png'
+      end
+    end
+
+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.
+
+    class AvatarUploader < CarrierWave::Uploader::Base
+      include CarrierWave::ImageScience
+
+      process :resize_to_fill => [200, 200]
+    end
+
+== Using MiniMagick
+
+MiniMagick is similar to RMagick but performs all the operations using the 'mogrify'
+command which is part of the standard ImageMagick kit. This allows you to have the power
+of ImageMagick without having to worry about installing all the RMagick libraries.
+
+See the MiniMagick site for more details:
+
+http://github.com/probablycorey/mini_magick
+
+And the ImageMagick command line options for more for whats on offer:
+
+http://www.imagemagick.org/script/command-line-options.php
+
+Currently, the MiniMagick carrierwave processor provides exactly the same methods as
+for the RMagick processor.
+
+    class AvatarUploader < CarrierWave::Uploader::Base
+      include CarrierWave::MiniMagick
+
+      process :resize_to_fill => [200, 200]
+    end
+
+== Migrating
+
+If you are using Paperclip, you can use the provided compatibility module:
+
+    class AvatarUploader < CarrierWave::Uploader::Base
+      include CarrierWave::Compatibility::Paperclip
+    end
+
+See the documentation for <code>Paperclip::Compatibility::Paperclip</code> for more
+detaills.
+
+Be sure to use mount_on to specify the correct column:
+
+    mount_uploader :avatar, AvatarUploader, :mount_on => :avatar_file_name
+
+Unfortunately AttachmentFoo differs too much in philosophy for there to be a
+sensible compatibility mode. Patches for migrating from other solutions will be
+happily accepted.
+
+== i18n
+
+The activerecord validations use the Rails i18n framework. Add these keys to
+your translations file:
+
+    carrierwave:
+      errors:
+        integrity: 'Not an image.'
+        processing: 'Cannot resize image.'
+
+== Contributors
+
+These people have contributed their time and effort to CarrierWave:
+
+* Jonas Nicklas
+* Pavel Kunc
+* Andrew Timberlake
+* Durran Jordan
+* Scott Motte
+* Sho Fukamachi
+* Sam Lown
+* Dave Ott
+* Quin Hoxie
+
+== License
+
+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
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+== Development
+
+If you want to run the tests (and you should) it might be convenient to install
+the development dependencies, you can do that with:
+
+    sudo gem install carrierwave --development
+
+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.
+
+Issues are reported on GitHub, pull requests are very welcome!

data/Rakefile

@@ -0,0 +1,38 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'carrierwave'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+Hoe.plugin :cucumberfeatures
+
+$hoe = Hoe.spec 'dsturnbull-carrierwave' do
+  self.developer 'Jonas Nicklas', 'jonas.nicklas@gmail.com'
+  self.rubyforge_name = self.name
+  self.readme_file = 'README.rdoc'
+  self.version = CarrierWave::VERSION
+  self.extra_dev_deps << ['newgem', '>=1.5.2']
+  self.extra_dev_deps << ['rspec', '>=1.2.8']
+  self.extra_dev_deps << ['cucumber', '>=0.3.96']
+  self.extra_dev_deps << ['activerecord', '>=2.3.3']
+  self.extra_dev_deps << ['sqlite3-ruby', '>=1.2.5']
+  self.extra_dev_deps << ['dm-core', '>=0.9.11']
+  self.extra_dev_deps << ['data_objects', '>=0.9.12']
+  self.extra_dev_deps << ['do_sqlite3', '>=0.9.11']
+  self.extra_dev_deps << ['sequel', '>=3.2.0']
+  self.extra_dev_deps << ['rmagick', '>=2.10.0']
+  self.extra_dev_deps << ['mini_magick', '>=1.2.5']
+  self.extra_dev_deps << ['mongo_mapper', '>=0.6.8']
+  self.extra_dev_deps << ['mongoid', '>=0.10.4']
+  self.extra_dev_deps << ['aws-s3', '>=0.6.2']
+  self.extra_dev_deps << ['timecop', '>=0.3.4']
+  self.extra_rdoc_files << 'README.rdoc'
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+task :default => [:spec, :features]

data/cucumber.yml

@@ -0,0 +1,2 @@
+default: --format pretty --no-source
+html: --format html --out features.html

data/features/caching.feature

@@ -0,0 +1,28 @@
+Feature: uploader with file storage
+  In order to be able to temporarily store files to disk
+  As a developer using CarrierWave
+  I want to cache files
+  
+  Scenario: cache a file
+    Given an uploader class that uses the 'file' storage
+    And an instance of that class
+    When I cache the file 'fixtures/bork.txt'
+    Then there should be a file called 'bork.txt' somewhere in a subdirectory of 'public/uploads/tmp'
+    And the file called 'bork.txt' in a subdirectory of 'public/uploads/tmp' should be identical to the file at 'fixtures/bork.txt'
+  
+  Scenario: cache two files in succession
+    Given an uploader class that uses the 'file' storage
+    And an instance of that class
+    When I cache the file 'fixtures/bork.txt'
+    Then there should be a file called 'bork.txt' somewhere in a subdirectory of 'public/uploads/tmp'
+    And the file called 'bork.txt' in a subdirectory of 'public/uploads/tmp' should be identical to the file at 'fixtures/bork.txt'
+    When I cache the file 'fixtures/monkey.txt'
+    Then there should be a file called 'monkey.txt' somewhere in a subdirectory of 'public/uploads/tmp'
+    And the file called 'monkey.txt' in a subdirectory of 'public/uploads/tmp' should be identical to the file at 'fixtures/monkey.txt'
+  
+  Scenario: retrieving a file from cache
+    Given an uploader class that uses the 'file' storage
+    And an instance of that class
+    And the file 'fixtures/bork.txt' is cached file at 'public/uploads/tmp/20090212-2343-8336-0348/bork.txt'
+    When I retrieve the cache name '20090212-2343-8336-0348/bork.txt' from the cache
+    Then the uploader should have 'public/uploads/tmp/20090212-2343-8336-0348/bork.txt' as its current path

data/features/download.feature

@@ -0,0 +1,20 @@
+Feature: downloading files 
+  In order to allow users to upload remote files
+  As a developer using CarrierWave
+  I want to download files to the filesystem via HTTP
+  
+  Background:
+    Given an uploader class that uses the 'file' storage
+    And an instance of that class
+  
+  Scenario: download a file
+    When I download the file 'http://s3.amazonaws.com/Monkey/testfile.txt'
+    Then there should be a file called 'testfile.txt' somewhere in a subdirectory of 'public/uploads/tmp'
+    And the file called 'testfile.txt' in a subdirectory of 'public/uploads/tmp' should contain 'S3 Remote File'
+  
+  Scenario: downloading a file then storing
+    When I download the file 'http://s3.amazonaws.com/Monkey/testfile.txt'
+    And I store the file
+    Then there should be a file at 'public/uploads/testfile.txt'
+    And the file at 'public/uploads/testfile.txt' should contain 'S3 Remote File'
+

data/features/file_storage.feature

@@ -0,0 +1,37 @@
+Feature: uploader with file storage
+  In order to be awesome
+  As a developer using CarrierWave
+  I want to upload files to the filesystem
+  
+  Background:
+    Given an uploader class that uses the 'file' storage
+    And an instance of that class    
+  
+  Scenario: store a file
+    When I store the file 'fixtures/bork.txt'
+    Then there should be a file at 'public/uploads/bork.txt'
+    And the file at 'public/uploads/bork.txt' should be identical to the file at 'fixtures/bork.txt'
+  
+  Scenario: store two files in succession
+    When I store the file 'fixtures/bork.txt'
+    Then there should be a file at 'public/uploads/bork.txt'
+    And the file at 'public/uploads/bork.txt' should be identical to the file at 'fixtures/bork.txt'
+    When I store the file 'fixtures/monkey.txt'
+    Then there should be a file at 'public/uploads/monkey.txt'
+    And the file at 'public/uploads/monkey.txt' should be identical to the file at 'fixtures/monkey.txt'
+  
+  Scenario: cache a file and then store it
+    When I cache the file 'fixtures/bork.txt'
+    Then there should be a file called 'bork.txt' somewhere in a subdirectory of 'public/uploads/tmp'
+    And the file called 'bork.txt' in a subdirectory of 'public/uploads/tmp' should be identical to the file at 'fixtures/bork.txt'
+    And there should not be a file at 'public/uploads/bork.txt'
+    When I store the file
+    Then there should be a file at 'public/uploads/bork.txt'
+    And the file at 'public/uploads/bork.txt' should be identical to the file at 'fixtures/bork.txt'
+  
+  Scenario: retrieving a file from cache then storing
+    Given the file 'fixtures/bork.txt' is cached file at 'public/uploads/tmp/20090212-2343-8336-0348/bork.txt'
+    When I retrieve the cache name '20090212-2343-8336-0348/bork.txt' from the cache
+    And I store the file
+    Then there should be a file at 'public/uploads/bork.txt'
+    And the file at 'public/uploads/bork.txt' should be identical to the file at 'fixtures/bork.txt'

data/features/file_storage_overridden_filename.feature

@@ -0,0 +1,38 @@
+Feature: uploader with file storage and overriden filename
+  In order to be awesome
+  As a developer using CarrierWave
+  I want to upload files to the filesystem with an overriden filename
+  
+  Background:
+    Given an uploader class that uses the 'file' storage
+    And that the uploader reverses the filename
+    And an instance of that class 
+  
+  Scenario: store a file
+    When I store the file 'fixtures/bork.txt'
+    Then there should be a file at 'public/uploads/txt.krob'
+    And the file at 'public/uploads/txt.krob' should be identical to the file at 'fixtures/bork.txt'
+  
+  Scenario: store two files in succession
+    When I store the file 'fixtures/bork.txt'
+    Then there should be a file at 'public/uploads/txt.krob'
+    And the file at 'public/uploads/txt.krob' should be identical to the file at 'fixtures/bork.txt'
+    When I store the file 'fixtures/monkey.txt'
+    Then there should be a file at 'public/uploads/txt.yeknom'
+    And the file at 'public/uploads/txt.yeknom' should be identical to the file at 'fixtures/monkey.txt'
+  
+  Scenario: cache a file and then store it
+    When I cache the file 'fixtures/bork.txt'
+    Then there should be a file called 'bork.txt' somewhere in a subdirectory of 'public/uploads/tmp'
+    And the file called 'bork.txt' in a subdirectory of 'public/uploads/tmp' should be identical to the file at 'fixtures/bork.txt'
+    And there should not be a file at 'public/uploads/txt.krob'
+    When I store the file
+    Then there should be a file at 'public/uploads/txt.krob'
+    And the file at 'public/uploads/txt.krob' should be identical to the file at 'fixtures/bork.txt'
+  
+  Scenario: retrieving a file from cache then storing
+    Given the file 'fixtures/bork.txt' is cached file at 'public/uploads/tmp/20090212-2343-8336-0348/bork.txt'
+    When I retrieve the cache name '20090212-2343-8336-0348/bork.txt' from the cache
+    And I store the file
+    Then there should be a file at 'public/uploads/txt.krob'
+    And the file at 'public/uploads/txt.krob' should be identical to the file at 'fixtures/bork.txt'