thorsson_carrierwave 0.4.5

data/Generators

@@ -0,0 +1,4 @@
+scope 'merb-gen' do
+  dir = File.join(File.dirname(__FILE__), 'merb_generators/')
+  Merb.add_generators dir + 'uploader_generator'
+end

data/History.txt

@@ -0,0 +1,125 @@
+=== Version 0.4.5 2010-02-20
+
+* [added] Support for Rackspace Cloudfiles
+* [added] GridFS now accepts a port
+* [fixed] s3_headers is now properly initialized
+* [fixed] work around DataMapper's patching of core method
+
+=== Version 0.4.4 2010-01-31
+
+* [added] Support for downloading remote files
+* [added] CarrierWave.clean_cached_files! to remove old cached files
+* [added] Option to set headers for S3
+* [added] GridStore now has authentication
+* [fixed] Rmagick convert method now does what it says 
+* [fixed] Content type is stored on GridStore and Amazon S3
+* [fixed] Metadata is no longer broken for S3
+
+=== Version 0.4.3 2009-12-19
+
+* [fixed] cnamed URLs on S3 no longer have a third slash after http
+* [fixed] fixed deprecation warnings on Rails 2.3.5
+
+=== Version 0.4.2 2009-11-26
+
+* [added] RightAWS as an alternative S3 implementation
+* [added] An option to enable/disable processing for tests
+* [added] Mongoid ORM support
+* [fixed] DataMapper now works both with and without dm-validations
+
+=== Version 0.4.1 2009-10-26
+
+* [changed] Major changes to the ImageScience module, it actually works now!
+* [fixed] Bug in configuration where it complais that it can't dup Symbol
+
+* [removed] Support for Sequel < 2.12
+* [removed] `crop_resized` and `resize` aliases in RMagick, use `resize_to_fill` and `resize_to_fit` respectively
+
+=== Version 0.4.0 2009-10-12
+
+* [changed] the `public` option has been renamed `root` and the old `root` option was removed. No more ambiguity.
+* [changed] Major *breaking* changes to the configuration syntax.
+
+* [removed] support for `default_path`
+* [removed] the `cache_to_cache_dir` option
+* [removed] storage no longer calls `setup!` on storage engines
+
+* [added] Support for MongoDB's GridFS store
+
+=== Version 0.3.4 2009-09-01
+
+* [added] `default_url` as a replacement for `default_path`
+* [deprecated] `default_path` is deprecated
+
+=== Version 0.3.4 2009-08-31
+
+* [fixed] Deleting no longer causes TypeError in MongoMapper
+
+=== Version 0.3.3 2009-08-29
+
+* [added] Support for MongoMapper
+* [added] Support for CNamed Bucket URLs for Amazon S3
+
+=== Version 0.3.2 2009-07-18
+
+Incremental upgrade
+
+* [added] Ruby 1.9 compatibility
+* [changed] Added Object#blank? implementation into CarrierWave, which removes any dpendencies on external libraries (extlib/activesupport)
+* [fixed] Performance issues with S3 support
+* [fixed] Sequel support for newer verions of Sequel (thanks Pavel!)
+
+=== Version 0.3.1 2009-07-01
+
+A bugfix release. Drop in compatible with 0.3.0.
+
+* [fixed] Saving a record with a mounted Uploader no longer removes uploaded file
+* [fixed] The file returned by S3 storage now has the path set to the full store path
+* [added] File returned by S3 storage now responds to S3 specific methods 
+
+=== 0.3 2009-06-20
+
+This is a stabilization release. Most features are now working as expected and
+most bugs should be fixed.
+
+* [changed] Reworked how storage engines work, some internal API changes
+* [added] Macro-like methods for RMagick, no need to call #process any more!
+* [added] Ability to super to any Mount method 
+* [fixed] Sequel support should now work as expected
+* [fixed] ActiveRecord no longer saves the record twice 
+* [added] Added convenient macro style class methods to rmagick processing
+
+=== 0.2.4 2009-06-11
+
+* [added] `resize_to_limit` method for rmagick
+* [added] Now deletes files from Amazon S3 when record is destroyed
+
+=== 0.2.3 2009-05-13
+
+* [changed] Mount now no longer returns nil if there is no stored file, it returns a blank uploader instead
+* [added] Possibility to specify a default path
+* [added] Paperclip compatibility module
+
+=== 0.2.1 2009-05-01
+
+* [changed] Url method now optionally takes versions as parameters (like Paperclip)
+* [added] A field which allows files to be removed with a checkbox in mount
+* [added] Mount_on option for Mount, to be able to override the serialization column
+* [added] Added demeter friendly column_url method to Mount
+* [added] Option to not copy files to cache dir, to prevent writes on read only fs systems (this is a workaround and needs a better solution)
+
+
+=== 0.2 2009-04-15
+
+* [changed] The version is no longer stored in the store dir. This will break the paths for files uploaded with 0.1
+* [changed] CarrierWave::Uploader is now a module, not a class, so you need to include it, not inherit from it.
+* [added] Integiry checking in uploaders via a white list of extensions
+* [added] Validations for integrity and processing in ActiveRecord, activated by default
+* [added] Support for nested versions
+* [added] Permissions option to set the permissions of the uploaded files
+* [added] Support for Sequel
+* [added] CarrierWave::Uploader#read to read the contents of the uploaded files
+
+=== 0.1 2009-03-12
+
+This is a very experimental release that has not been well tested. All of the major features are in place though. Please note that there currently is a bug with load paths in Merb, which means you need to manually require uploaders.

data/Manifest.txt

@@ -0,0 +1,111 @@
+Generators
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+carrierwave.gemspec
+cucumber.yml
+features/caching.feature
+features/download.feature
+features/file_storage.feature
+features/file_storage_overridden_filename.feature
+features/file_storage_overridden_store_dir.feature
+features/file_storage_reversing_processor.feature
+features/fixtures/bork.txt
+features/fixtures/monkey.txt
+features/grid_fs_storage.feature
+features/mount_activerecord.feature
+features/mount_datamapper.feature
+features/step_definitions/activerecord_steps.rb
+features/step_definitions/caching_steps.rb
+features/step_definitions/datamapper_steps.rb
+features/step_definitions/download_steps.rb
+features/step_definitions/file_steps.rb
+features/step_definitions/general_steps.rb
+features/step_definitions/mount_steps.rb
+features/step_definitions/store_steps.rb
+features/support/activerecord.rb
+features/support/datamapper.rb
+features/support/env.rb
+features/versions_basics.feature
+features/versions_nested_versions.feature
+features/versions_overridden_filename.feature
+features/versions_overriden_store_dir.feature
+lib/carrierwave.rb
+lib/carrierwave/compatibility/paperclip.rb
+lib/carrierwave/core_ext/blank.rb
+lib/carrierwave/core_ext/file.rb
+lib/carrierwave/core_ext/inheritable_attributes.rb
+lib/carrierwave/core_ext/module_setup.rb
+lib/carrierwave/mount.rb
+lib/carrierwave/orm/activerecord.rb
+lib/carrierwave/orm/datamapper.rb
+lib/carrierwave/orm/mongoid.rb
+lib/carrierwave/orm/mongomapper.rb
+lib/carrierwave/orm/sequel.rb
+lib/carrierwave/processing/image_science.rb
+lib/carrierwave/processing/mini_magick.rb
+lib/carrierwave/processing/rmagick.rb
+lib/carrierwave/sanitized_file.rb
+lib/carrierwave/storage/abstract.rb
+lib/carrierwave/storage/cloud_files.rb
+lib/carrierwave/storage/file.rb
+lib/carrierwave/storage/grid_fs.rb
+lib/carrierwave/storage/right_s3.rb
+lib/carrierwave/storage/s3.rb
+lib/carrierwave/test/matchers.rb
+lib/carrierwave/uploader.rb
+lib/carrierwave/uploader/cache.rb
+lib/carrierwave/uploader/callbacks.rb
+lib/carrierwave/uploader/configuration.rb
+lib/carrierwave/uploader/default_url.rb
+lib/carrierwave/uploader/download.rb
+lib/carrierwave/uploader/extension_whitelist.rb
+lib/carrierwave/uploader/mountable.rb
+lib/carrierwave/uploader/processing.rb
+lib/carrierwave/uploader/proxy.rb
+lib/carrierwave/uploader/remove.rb
+lib/carrierwave/uploader/store.rb
+lib/carrierwave/uploader/url.rb
+lib/carrierwave/uploader/versions.rb
+merb_generators/uploader_generator.rb
+rails_generators/uploader/USAGE
+rails_generators/uploader/templates/uploader.rb
+rails_generators/uploader/uploader_generator.rb
+script/console
+script/destroy
+script/generate
+spec/compatibility/paperclip_spec.rb
+spec/fixtures/bork.txt
+spec/fixtures/landscape.jpg
+spec/fixtures/portrait.jpg
+spec/fixtures/test.jpeg
+spec/fixtures/test.jpg
+spec/mount_spec.rb
+spec/orm/activerecord_spec.rb
+spec/orm/datamapper_spec.rb
+spec/orm/mongoid_spec.rb
+spec/orm/mongomapper_spec.rb
+spec/orm/sequel_spec.rb
+spec/processing/image_science_spec.rb
+spec/processing/mini_magick_spec.rb
+spec/processing/rmagick_spec.rb
+spec/sanitized_file_spec.rb
+spec/spec_helper.rb
+spec/storage/cloudfiles_spec.rb
+spec/storage/grid_fs_spec.rb
+spec/storage/right_s3_spec.rb
+spec/storage/s3_spec.rb
+spec/uploader/cache_spec.rb
+spec/uploader/configuration_spec.rb
+spec/uploader/default_url_spec.rb
+spec/uploader/download_spec.rb
+spec/uploader/extension_whitelist_spec.rb
+spec/uploader/mountable_spec.rb
+spec/uploader/paths_spec.rb
+spec/uploader/processing_spec.rb
+spec/uploader/proxy_spec.rb
+spec/uploader/remove_spec.rb
+spec/uploader/store_spec.rb
+spec/uploader/url_spec.rb
+spec/uploader/versions_spec.rb

data/README.rdoc

@@ -0,0 +1,528 @@
+= 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, a Rackspace Cloud Files 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 and Rackspace Cloud Files.
+Define +store_dir+ as +nil+ if you'd like to store files at the root level.
+
+== 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 Rackspace Cloud Files
+
+Cloud Files support requires a {Rackspace Cloud}[http://rackspacecloud.com] username and API key.
+You must also create a container for Carrierwave to use, and mark it public (publish it to the CDN)
+
+    CarrierWave.configure do |config|
+      config.cloud_files_user_name = 'xxxxxx'
+      config.cloud_files_api_key = 'xxxxxxxxxxxxxxxxxxxxx'
+      config.cloud_files_container = '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 :cloud_files
+
+    class AvatarUploader < CarrierWave::Uploader::Base
+      storage :cloud_files
+    end
+
+That's it! You can still use the <code>CarrierWave::Uploader#url</code> method to return
+the url to the file on the Cloud Files CDN.
+
+== 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
+* H. Wade Minter
+* Trevor Turk
+* Nicklas Ramhöj
+* Matt Hooks
+
+== 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!