andrewtimberlake-carrierwave 0.3.2.1

data/Generators

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

data/LICENSE

@@ -0,0 +1,20 @@
+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.

data/README.rdoc

@@ -0,0 +1,314 @@
+= 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/].
+* 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]
+
+== Getting Started
+
+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:
+    
+    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 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, DataMapper, Sequel
+
+If you are *not* using Merb or Rails you'll need to require the relevant ORM
+extension.
+
+    require 'carrierwave/orm/activerecord'
+    require 'carrierwave/orm/datamapper'
+    require 'carrierwave/orm/sequel'
+
+Open your model file, for ActiveRecord do something like:
+
+    class User < ActiveRecord::Base
+      mount_uploader :avatar, AvatarUploader
+    end
+
+Or for DataMapper:
+
+    class User
+      include DataMapper::Resource
+
+      mount_uploader :avatar, AvatarUploader
+    end
+
+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]
+    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.
+
+== 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 => [800, 800]
+
+      version :thumb do
+        process :crop_resized => [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 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 %>
+
+NOTE: this feature currently requires write access to your filesystem. If write
+access is unavailable you will not be able to upload files. You can prevent
+CarrierWave from writing to the file system by setting
+`CarrierWave.config[:cache_to_cache_dir] = false`. This will however break
+redisplays of forms.
+
+== Providing a default path
+
+In many cases, especially when working with images, it might be a good idea to
+provide a default path, a fallback in case no file has been uploaded. You can do
+this easily by overriding the +default_path+ method in your uploader:
+
+    class MyUploader < CarrierWave::Uploader::Base
+      def default_path
+        "images/fallback/" + [version_name, "default.png"].compact.join('_')
+      end
+    end
+
+== Using Amazon S3
+
+You'll need to configure a bucket, access id and secret key like this:
+
+    CarrierWave.config[:s3][:access_key_id] = 'xxxxxx'
+    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.
+
+And then in your uploader, set the storage to :s3
+
+    class AvatarUploader < 
+      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
+
+== 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
++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::Base
+      include CarrierWave::RMagick
+      
+      process :crop_resized => [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 :crop_resized => [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 +Paperclip::Compatibility::Paperclip+ 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
+
+== License
+
+MIT-License, see the separate LICENSE file in the source distribution.
+
+== 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

@@ -0,0 +1,29 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/carrierwave'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+Hoe.plugin :cucumberfeatures
+
+$hoe = Hoe.spec '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 << ['rspec', '>=1.2.8']
+  self.extra_dev_deps << ['cucumber', '>=0.3.96']
+  self.extra_dev_deps << ['activerecord', '>=2.3.3']
+  self.extra_dev_deps << ['dm-core', '>=0.9.11']
+  self.extra_dev_deps << ['sequel', '>=3.2.0']
+  self.extra_dev_deps << ['rmagick', '>=2.10.0']
+  self.extra_rdoc_files << 'README.rdoc'
+  self.extra_rdoc_files << 'LICENSE'
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+task :default => [:spec, :features]

data/lib/carrierwave.rb

@@ -0,0 +1,140 @@
+# encoding: utf-8
+
+require 'fileutils'
+require 'carrierwave/core_ext/blank'
+require 'carrierwave/core_ext/module_setup'
+require 'carrierwave/core_ext/inheritable_attributes'
+
+module CarrierWave
+
+  VERSION = "0.3.2"
+
+  class << self
+    attr_accessor :config, :logger
+
+    def logger
+      return @logger if @logger
+      require 'logger'
+      @logger = Logger.new(STDOUT)
+    end
+
+    ##
+    # Generates a unique cache id for use in the caching system
+    #
+    # === Returns
+    #
+    # [String] a cache id in the format YYYYMMDD-HHMM-PID-RND
+    #
+    def generate_cache_id
+      Time.now.strftime('%Y%m%d-%H%M') + '-' + Process.pid.to_s + '-' + ("%04d" % rand(9999))
+    end
+  end
+
+  class UploadError < StandardError; end
+  class NoFileError < 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
+
+  autoload :SanitizedFile, 'carrierwave/sanitized_file'
+  autoload :Mount, 'carrierwave/mount'
+  autoload :RMagick, 'carrierwave/processing/rmagick'
+  autoload :ImageScience, 'carrierwave/processing/image_science'
+
+  module Storage
+    autoload :Abstract, 'carrierwave/storage/abstract'
+    autoload :File, 'carrierwave/storage/file'
+    autoload :S3, 'carrierwave/storage/s3'
+  end
+
+  module Uploader
+    autoload :Base, 'carrierwave/uploader'
+    autoload :Cache, 'carrierwave/uploader/cache'
+    autoload :Store, 'carrierwave/uploader/store'
+    autoload :Callbacks, 'carrierwave/uploader/callbacks'
+    autoload :Processing, 'carrierwave/uploader/processing'
+    autoload :Versions, 'carrierwave/uploader/versions'
+    autoload :Remove, 'carrierwave/uploader/remove'
+    autoload :Paths, 'carrierwave/uploader/paths'
+    autoload :ExtensionWhitelist, 'carrierwave/uploader/extension_whitelist'
+    autoload :DefaultPath, 'carrierwave/uploader/default_path'
+    autoload :Proxy, 'carrierwave/uploader/proxy'
+    autoload :Url, 'carrierwave/uploader/url'
+    autoload :Mountable, 'carrierwave/uploader/mountable'
+  end
+
+  module Compatibility
+    autoload :Paperclip, 'carrierwave/compatibility/paperclip'
+  end
+
+  module Test
+    autoload :Matchers, 'carrierwave/test/matchers'
+  end
+
+end
+
+CarrierWave.config = {
+  :permissions => 0644,
+  :storage => :file,
+  :use_cache => true,
+  :storage_engines => {
+    :file => "CarrierWave::Storage::File",
+    :s3 => "CarrierWave::Storage::S3"
+  },
+  :s3 => {
+    :access => :public_read
+  },
+  :store_dir => 'uploads',
+  :cache_dir => 'uploads/tmp',
+  :cache_to_cache_dir => true,
+  :mount => {
+    :ignore_integrity_errors => true,
+    :ignore_processing_errors => true,
+    :validate_integrity => true,
+    :validate_processing => true
+  }
+}
+
+if defined?(Merb::Plugins)
+  CarrierWave.config[:root] = Merb.root
+  CarrierWave.config[:public] = Merb.dir_for(:public)
+
+  Merb::BootLoader.before_app_loads do
+    # Set logger
+    CarrierWave.logger ||= Merb.logger
+    # Setup path for uploaders and load all of them before classes are loaded
+    Merb.push_path(:uploaders, Merb.root / 'app' / 'uploaders', '*.rb')
+    Dir.glob(File.join(Merb.load_paths[:uploaders])).each {|f| require f }
+  end
+
+  orm_path = File.dirname(__FILE__) / 'carrierwave' / 'orm' / Merb.orm
+  require orm_path if File.exist?(orm_path + '.rb')
+
+  Merb.add_generators File.dirname(__FILE__) / 'generators' / 'uploader_generator'
+
+elsif defined?(Rails)
+  begin
+    CarrierWave.logger = Rails.logger
+  rescue
+    # Rails < 2.1
+    CarrierWave.logger = RAILS_DEFAULT_LOGGER
+  end
+  CarrierWave.config[:root] = Rails.root
+  CarrierWave.config[:public] = File.join(Rails.root, 'public')
+
+  require File.join(File.dirname(__FILE__), "carrierwave", "orm", 'activerecord')
+
+  ActiveSupport::Dependencies.load_paths << File.join(Rails.root, "app", "uploaders")
+
+elsif defined?(Sinatra)
+
+  CarrierWave.config[:root] = Sinatra::Application.root
+  CarrierWave.config[:public] = Sinatra::Application.public
+
+end