radiant-paperclipped-extension 0.8.1

data/vendor/plugins/paperclip/LICENSE

@@ -0,0 +1,26 @@
+
+LICENSE
+
+The MIT License
+
+Copyright (c) 2008 Jon Yurek and thoughtbot, inc.
+
+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/vendor/plugins/paperclip/README.rdoc

@@ -0,0 +1,179 @@
+=Paperclip
+
+Paperclip is intended as an easy file attachment library for ActiveRecord. The
+intent behind it was to keep setup as easy as possible and to treat files as
+much like other attributes as possible. This means they aren't saved to their
+final locations on disk, nor are they deleted if set to nil, until
+ActiveRecord::Base#save is called. It manages validations based on size and
+presence, if required. It can transform its assigned image into thumbnails if
+needed, and the prerequisites are as simple as installing ImageMagick (which,
+for most modern Unix-based systems, is as easy as installing the right
+packages). Attached files are saved to the filesystem and referenced in the
+browser by an easily understandable specification, which has sensible and
+useful defaults.
+
+See the documentation for +has_attached_file+ in Paperclip::ClassMethods for
+more detailed options.
+
+==Quick Start
+
+In your model:
+
+  class User < ActiveRecord::Base
+    has_attached_file :avatar, :styles => { :medium => "300x300>", :thumb => "100x100>" }
+  end
+
+In your migrations:
+
+  class AddAvatarColumnsToUser < ActiveRecord::Migration
+    def self.up
+      add_column :users, :avatar_file_name,    :string
+      add_column :users, :avatar_content_type, :string
+      add_column :users, :avatar_file_size,    :integer
+      add_column :users, :avatar_updated_at,   :datetime
+    end
+
+    def self.down
+      remove_column :users, :avatar_file_name
+      remove_column :users, :avatar_content_type
+      remove_column :users, :avatar_file_size
+      remove_column :users, :avatar_updated_at
+    end
+  end
+
+In your edit and new views:
+
+  <% form_for :user, @user, :url => user_path, :html => { :multipart => true } do |form| %>
+    <%= form.file_field :avatar %>
+  <% end %>
+
+In your controller:
+
+  def create
+    @user = User.create( params[:user] )
+  end
+
+In your show view:
+
+  <%= image_tag @user.avatar.url %>
+  <%= image_tag @user.avatar.url(:medium) %>
+  <%= image_tag @user.avatar.url(:thumb) %>
+
+==Usage
+
+The basics of paperclip are quite simple: Declare that your model has an
+attachment with the has_attached_file method, and give it a name. Paperclip
+will wrap up up to four attributes (all prefixed with that attachment's name,
+so you can have multiple attachments per model if you wish) and give the a
+friendly front end. The attributes are <attachment>_file_name,
+<attachment>_file_size, <attachment>_content_type, and <attachment>_updated_at.
+Only <attachment>_file_name is required for paperclip to operate. More
+information about the options to has_attached_file is available in the
+documentation of Paperclip::ClassMethods.
+
+Attachments can be validated with Paperclip's validation methods,
+validates_attachment_presence, validates_attachment_content_type, and
+validates_attachment_size.
+
+==Storage
+
+The files that are assigned as attachments are, by default, placed in the
+directory specified by the :path option to has_attached_file. By default, this
+location is ":rails_root/public/system/:attachment/:id/:style/:filename". This
+location was chosen because on standard Capistrano deployments, the
+public/system directory is symlinked to the app's shared directory, meaning it
+will survive between deployments. For example, using that :path, you may have a
+file at
+
+  /data/myapp/releases/20081229172410/public/system/avatars/13/small/my_pic.png
+
+NOTE: This is a change from previous versions of Paperclip, but is overall a
+safer choice for the default file store.
+
+You may also choose to store your files using Amazon's S3 service. You can find
+more information about S3 storage at the description for
+Paperclip::Storage::S3.
+
+Files on the local filesystem (and in the Rails app's public directory) will be
+available to the internet at large. If you require access control, it's
+possible to place your files in a different location. You will need to change
+both the :path and :url options in order to make sure the files are unavailable
+to the public. Both :path and :url allow the same set of interpolated
+variables.
+
+==Post Processing
+
+Paperclip supports an extensible selection of post-processors. When you define
+a set of styles for an attachment, by default it is expected that those
+"styles" are actually "thumbnails". However, you can do much more than just
+thumbnail images. By defining a subclass of Paperclip::Processor, you can
+perform any processing you want on the files that are attached. Any file in
+your Rails app's lib/paperclip_processors directory is automatically loaded by
+paperclip, allowing you to easily define custom processors. You can specify a
+processor with the :processors option to has_attached_file:
+
+  has_attached_file :scan, :styles => { :text => { :quality => :better } },
+                           :processors => [:ocr]
+
+This would load the hypothetical class Paperclip::Ocr, which would have the
+hash "{ :quality => :better }" passed to it along with the uploaded file. For
+more information about defining processors, see Paperclip::Processor.
+
+The default processor is Paperclip::Thumbnail. For backwards compatability
+reasons, you can pass a single geometry string or an array containing a
+geometry and a format, which the file will be converted to, like so:
+
+  has_attached_file :avatar, :styles => { :thumb => ["32x32#", :png] }
+
+This will convert the "thumb" style to a 32x32 square in png format, regardless
+of what was uploaded. If the format is not specified, it is kept the same (i.e.
+jpgs will remain jpgs).
+
+Multiple processors can be specified, and they will be invoked in the order
+they are defined in the :processors array. Each successive processor will
+be given the result of the previous processor's execution. All processors will
+receive the same parameters, which are what you define in the :styles hash.
+For example, assuming we had this definition:
+
+  has_attached_file :scan, :styles => { :text => { :quality => :better } },
+                           :processors => [:rotator, :ocr]
+
+then both the :rotator processor and the :ocr processor would receive the
+options "{ :quality => :better }". This parameter may not mean anything to one
+or more or the processors, and they are expected to ignore it.
+
+NOTE: Because processors operate by turning the original attachment into the
+styles, no processors will be run if there are no styles defined.
+
+==Events
+
+Before and after the Post Processing step, Paperclip calls back to the model
+with a few callbacks, allowing the model to change or cancel the processing
+step. The callbacks are "before_post_process" and "after_post_process" (which
+are called before and after the processing of each attachment), and the
+attachment-specific "before_<attachment>_post_process" and
+"after_<attachment>_post_process". The callbacks are intended to be as close to
+normal ActiveRecord callbacks as possible, so if you return false (specifically
+- returning nil is not the same) in a before_ filter, the post processing step
+will halt. Returning false in an after_ filter will not halt anything, but you
+can access the model and the attachment if necessary.
+
+NOTE: Post processing will not even *start* if the attachment is not valid
+according to the validations. Your callbacks and processors will *only* be
+called with valid attachments.
+
+==Testing
+
+Paperclip provides rspec-compatible matchers for testing attachments. See the
+documentation on Paperclip::Shoulda::Matchers for more information.
+
+==Contributing
+
+If you'd like to contribute a feature or bugfix: Thanks! To make sure your
+fix/feature has a high chance of being included, please read the following
+guidelines:
+
+1. Ask on the mailing list, or post a new GitHub Issue.
+2. Make sure there are tests! We will not accept any patch that is not tested.
+   It's a rare time when explicit tests aren't needed. If you have questions
+   about writing tests for paperclip, please ask the mailing list.

data/vendor/plugins/paperclip/Rakefile

@@ -0,0 +1,76 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
+require 'paperclip'
+
+desc 'Default: run unit tests.'
+task :default => [:clean, :test]
+
+desc 'Test the paperclip plugin under all supported Rails versions.'
+task :all do |t|
+  exec('rake RAILS_VERSION=2.1 && rake RAILS_VERSION=2.3 && rake RAILS_VERSION=3.0')
+end
+
+desc 'Test the paperclip plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib' << 'profile'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Start an IRB session with all necessary files required.'
+task :shell do |t|
+  chdir File.dirname(__FILE__)
+  exec 'irb -I lib/ -I lib/paperclip -r rubygems -r active_record -r tempfile -r init'
+end
+
+desc 'Generate documentation for the paperclip plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = 'Paperclip'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Update documentation on website'
+task :sync_docs => 'rdoc' do
+  `rsync -ave ssh doc/ dev@dev.thoughtbot.com:/home/dev/www/dev.thoughtbot.com/paperclip`
+end
+
+desc 'Clean up files.'
+task :clean do |t|
+  FileUtils.rm_rf "doc"
+  FileUtils.rm_rf "tmp"
+  FileUtils.rm_rf "pkg"
+  FileUtils.rm_rf "public"
+  FileUtils.rm "test/debug.log" rescue nil
+  FileUtils.rm "test/paperclip.db" rescue nil
+  Dir.glob("paperclip-*.gem").each{|f| FileUtils.rm f }
+end
+
+desc 'Build the gemspec.'
+task :gemspec do |t|
+  exec 'gem build paperclip.gemspec'
+end
+
+desc "Print a list of the files to be put into the gem"
+task :manifest => :clean do
+  spec.files.each do |file|
+    puts file
+  end
+end
+
+desc "Generate a gemspec file for GitHub"
+task :gemspec => :clean do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+end
+
+desc "Build the gem into the current directory"
+task :gem => :gemspec do
+  `gem build #{spec.name}.gemspec`
+end

data/vendor/plugins/paperclip/cucumber/paperclip_steps.rb

@@ -0,0 +1,6 @@
+When /^I attach an? "([^\"]*)" "([^\"]*)" file to an? "([^\"]*)" on S3$/ do |attachment, extension, model|
+  stub_paperclip_s3(model, attachment, extension)
+  attach_file attachment,
+              "features/support/paperclip/#{model.gsub(" ", "_").underscore}/#{attachment}.#{extension}"
+end
+

data/vendor/plugins/paperclip/generators/paperclip/USAGE

@@ -0,0 +1,5 @@
+Usage:
+
+  script/generate paperclip Class attachment1 (attachment2 ...)
+
+This will create a migration that will add the proper columns to your class's table.

data/vendor/plugins/paperclip/generators/paperclip/paperclip_generator.rb

@@ -0,0 +1,27 @@
+class PaperclipGenerator < Rails::Generator::NamedBase
+  attr_accessor :attachments, :migration_name
+
+  def initialize(args, options = {})
+    super
+    @class_name, @attachments = args[0], args[1..-1]
+  end
+
+  def manifest
+    file_name = generate_file_name
+    @migration_name = file_name.camelize
+    record do |m|
+      m.migration_template "paperclip_migration.rb.erb",
+                           File.join('db', 'migrate'),
+                           :migration_file_name => file_name
+    end
+  end
+
+  private
+
+  def generate_file_name
+    names = attachments.map{|a| a.underscore }
+    names = names[0..-2] + ["and", names[-1]] if names.length > 1
+    "add_attachments_#{names.join("_")}_to_#{@class_name.underscore}"
+  end
+
+end

data/vendor/plugins/paperclip/generators/paperclip/templates/paperclip_migration.rb.erb

@@ -0,0 +1,19 @@
+class <%= migration_name %> < ActiveRecord::Migration
+  def self.up
+<% attachments.each do |attachment| -%>
+    add_column :<%= class_name.underscore.camelize.tableize %>, :<%= attachment %>_file_name, :string
+    add_column :<%= class_name.underscore.camelize.tableize %>, :<%= attachment %>_content_type, :string
+    add_column :<%= class_name.underscore.camelize.tableize %>, :<%= attachment %>_file_size, :integer
+    add_column :<%= class_name.underscore.camelize.tableize %>, :<%= attachment %>_updated_at, :datetime
+<% end -%>
+  end
+
+  def self.down
+<% attachments.each do |attachment| -%>
+    remove_column :<%= class_name.underscore.camelize.tableize %>, :<%= attachment %>_file_name
+    remove_column :<%= class_name.underscore.camelize.tableize %>, :<%= attachment %>_content_type
+    remove_column :<%= class_name.underscore.camelize.tableize %>, :<%= attachment %>_file_size
+    remove_column :<%= class_name.underscore.camelize.tableize %>, :<%= attachment %>_updated_at
+<% end -%>
+  end
+end

data/vendor/plugins/paperclip/init.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), "lib", "paperclip")

data/vendor/plugins/paperclip/lib/generators/paperclip/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    rails generate paperclip Thing
+
+    This will create:
+        what/will/it/create

data/vendor/plugins/paperclip/lib/generators/paperclip/paperclip_generator.rb

@@ -0,0 +1,31 @@
+require 'rails/generators/active_record'
+
+class PaperclipGenerator < ActiveRecord::Generators::Base
+  desc "Create a migration to add paperclip-specific fields to your model."
+
+  argument :attachment_names, :required => true, :type => :array, :desc => "The names of the attachment(s) to add.",
+           :banner => "attachment_one attachment_two attachment_three ..."
+
+  def self.source_root
+    @source_root ||= File.expand_path('../templates', __FILE__)
+  end
+
+  def generate_migration
+    migration_template "paperclip_migration.rb.erb", "db/migrate/#{migration_file_name}"
+  end
+
+  protected
+
+  def migration_name
+    "add_attachment_#{attachment_names.join("_")}_to_#{name.underscore}"
+  end
+
+  def migration_file_name
+    "#{migration_name}.rb"
+  end
+
+  def migration_class_name
+    migration_name.camelize
+  end
+
+end

data/vendor/plugins/paperclip/lib/generators/paperclip/templates/paperclip_migration.rb.erb

@@ -0,0 +1,19 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+  def self.up
+<% attachment_names.each do |attachment| -%>
+    add_column :<%= name.underscore.camelize.tableize %>, :<%= attachment %>_file_name, :string
+    add_column :<%= name.underscore.camelize.tableize %>, :<%= attachment %>_content_type, :string
+    add_column :<%= name.underscore.camelize.tableize %>, :<%= attachment %>_file_size, :integer
+    add_column :<%= name.underscore.camelize.tableize %>, :<%= attachment %>_updated_at, :datetime
+<% end -%>
+  end
+
+  def self.down
+<% attachment_names.each do |attachment| -%>
+    remove_column :<%= name.underscore.camelize.tableize %>, :<%= attachment %>_file_name
+    remove_column :<%= name.underscore.camelize.tableize %>, :<%= attachment %>_content_type
+    remove_column :<%= name.underscore.camelize.tableize %>, :<%= attachment %>_file_size
+    remove_column :<%= name.underscore.camelize.tableize %>, :<%= attachment %>_updated_at
+<% end -%>
+  end
+end

data/vendor/plugins/paperclip/lib/paperclip.rb

@@ -0,0 +1,397 @@
+# Paperclip allows file attachments that are stored in the filesystem. All graphical
+# transformations are done using the Graphics/ImageMagick command line utilities and
+# are stored in Tempfiles until the record is saved. Paperclip does not require a
+# separate model for storing the attachment's information, instead adding a few simple
+# columns to your table.
+#
+# Author:: Jon Yurek
+# Copyright:: Copyright (c) 2008-2009 thoughtbot, inc.
+# License:: MIT License (http://www.opensource.org/licenses/mit-license.php)
+#
+# Paperclip defines an attachment as any file, though it makes special considerations
+# for image files. You can declare that a model has an attached file with the
+# +has_attached_file+ method:
+#
+#   class User < ActiveRecord::Base
+#     has_attached_file :avatar, :styles => { :thumb => "100x100" }
+#   end
+#
+#   user = User.new
+#   user.avatar = params[:user][:avatar]
+#   user.avatar.url
+#   # => "/users/avatars/4/original_me.jpg"
+#   user.avatar.url(:thumb)
+#   # => "/users/avatars/4/thumb_me.jpg"
+#
+# See the +has_attached_file+ documentation for more details.
+
+require 'erb'
+require 'tempfile'
+require 'paperclip/version'
+require 'paperclip/upfile'
+require 'paperclip/iostream'
+require 'paperclip/geometry'
+require 'paperclip/processor'
+require 'paperclip/thumbnail'
+require 'paperclip/storage'
+require 'paperclip/interpolations'
+require 'paperclip/style'
+require 'paperclip/attachment'
+require 'paperclip/callback_compatability'
+require 'paperclip/railtie'
+if defined?(Rails.root) && Rails.root
+  Dir.glob(File.join(File.expand_path(Rails.root), "lib", "paperclip_processors", "*.rb")).each do |processor|
+    require processor
+  end
+end
+
+# The base module that gets included in ActiveRecord::Base. See the
+# documentation for Paperclip::ClassMethods for more useful information.
+module Paperclip
+
+  class << self
+    # Provides configurability to Paperclip. There are a number of options available, such as:
+    # * whiny: Will raise an error if Paperclip cannot process thumbnails of
+    #   an uploaded image. Defaults to true.
+    # * log: Logs progress to the Rails log. Uses ActiveRecord's logger, so honors
+    #   log levels, etc. Defaults to true.
+    # * command_path: Defines the path at which to find the command line
+    #   programs if they are not visible to Rails the system's search path. Defaults to
+    #   nil, which uses the first executable found in the user's search path.
+    # * image_magick_path: Deprecated alias of command_path.
+    def options
+      @options ||= {
+        :whiny             => true,
+        :image_magick_path => nil,
+        :command_path      => nil,
+        :log               => true,
+        :log_command       => true,
+        :swallow_stderr    => true
+      }
+    end
+
+    def configure
+      yield(self) if block_given?
+    end
+
+    def path_for_command command #:nodoc:
+      if options[:image_magick_path]
+        warn("[DEPRECATION] :image_magick_path is deprecated and will be removed. Use :command_path instead")
+      end
+      path = [options[:command_path] || options[:image_magick_path], command].compact
+      File.join(*path)
+    end
+
+    def interpolates key, &block
+      Paperclip::Interpolations[key] = block
+    end
+
+    # The run method takes a command to execute and an array of parameters
+    # that get passed to it. The command is prefixed with the :command_path
+    # option from Paperclip.options. If you have many commands to run and
+    # they are in different paths, the suggested course of action is to
+    # symlink them so they are all in the same directory.
+    #
+    # If the command returns with a result code that is not one of the
+    # expected_outcodes, a PaperclipCommandLineError will be raised. Generally
+    # a code of 0 is expected, but a list of codes may be passed if necessary.
+    # These codes should be passed as a hash as the last argument, like so:
+    #
+    #   Paperclip.run("echo", "something", :expected_outcodes => [0,1,2,3])
+    #
+    # This method can log the command being run when
+    # Paperclip.options[:log_command] is set to true (defaults to false). This
+    # will only log if logging in general is set to true as well.
+    def run cmd, *params
+      options           = params.last.is_a?(Hash) ? params.pop : {}
+      expected_outcodes = options[:expected_outcodes] || [0]
+      params            = quote_command_options(*params).join(" ")
+
+      command = %Q[#{path_for_command(cmd)} #{params}]
+      command = "#{command} 2>#{bit_bucket}" if Paperclip.options[:swallow_stderr]
+      Paperclip.log(command) if Paperclip.options[:log_command]
+
+      begin
+        output = `#{command}`
+
+        raise CommandNotFoundError if $?.exitstatus == 127
+
+        unless expected_outcodes.include?($?.exitstatus)
+          raise PaperclipCommandLineError,
+            "Error while running #{cmd}. Expected return code to be #{expected_outcodes.join(", ")} but was #{$?.exitstatus}",
+            output
+        end
+      rescue Errno::ENOENT => e
+        raise CommandNotFoundError
+      end
+
+      output
+    end
+
+    def quote_command_options(*options)
+      options.map do |option|
+        option.split("'").map{|m| "'#{m}'" }.join("\\'")
+      end
+    end
+
+    def bit_bucket #:nodoc:
+      File.exists?("/dev/null") ? "/dev/null" : "NUL"
+    end
+
+    def included base #:nodoc:
+      base.extend ClassMethods
+      if base.respond_to?("set_callback")
+        base.send :include, Paperclip::CallbackCompatability::Rails3
+      else
+        base.send :include, Paperclip::CallbackCompatability::Rails21
+      end
+    end
+
+    def processor name #:nodoc:
+      name = name.to_s.camelize
+      processor = Paperclip.const_get(name)
+      unless processor.ancestors.include?(Paperclip::Processor)
+        raise PaperclipError.new("Processor #{name} was not found")
+      end
+      processor
+    end
+
+    # Log a paperclip-specific line. Uses ActiveRecord::Base.logger
+    # by default. Set Paperclip.options[:log] to false to turn off.
+    def log message
+      logger.info("[paperclip] #{message}") if logging?
+    end
+
+    def logger #:nodoc:
+      ActiveRecord::Base.logger
+    end
+
+    def logging? #:nodoc:
+      options[:log]
+    end
+  end
+
+  class PaperclipError < StandardError #:nodoc:
+  end
+
+  class PaperclipCommandLineError < PaperclipError #:nodoc:
+    attr_accessor :output
+    def initialize(msg = nil, output = nil)
+      super(msg)
+      @output = output
+    end
+  end
+
+  class CommandNotFoundError < PaperclipError
+  end
+
+  class NotIdentifiedByImageMagickError < PaperclipError #:nodoc:
+  end
+
+  class InfiniteInterpolationError < PaperclipError #:nodoc:
+  end
+
+  module ClassMethods
+    # +has_attached_file+ gives the class it is called on an attribute that maps to a file. This
+    # is typically a file stored somewhere on the filesystem and has been uploaded by a user.
+    # The attribute returns a Paperclip::Attachment object which handles the management of
+    # that file. The intent is to make the attachment as much like a normal attribute. The
+    # thumbnails will be created when the new file is assigned, but they will *not* be saved
+    # until +save+ is called on the record. Likewise, if the attribute is set to +nil+ is
+    # called on it, the attachment will *not* be deleted until +save+ is called. See the
+    # Paperclip::Attachment documentation for more specifics. There are a number of options
+    # you can set to change the behavior of a Paperclip attachment:
+    # * +url+: The full URL of where the attachment is publically accessible. This can just
+    #   as easily point to a directory served directly through Apache as it can to an action
+    #   that can control permissions. You can specify the full domain and path, but usually
+    #   just an absolute path is sufficient. The leading slash *must* be included manually for
+    #   absolute paths. The default value is
+    #   "/system/:attachment/:id/:style/:filename". See
+    #   Paperclip::Attachment#interpolate for more information on variable interpolaton.
+    #     :url => "/:class/:attachment/:id/:style_:filename"
+    #     :url => "http://some.other.host/stuff/:class/:id_:extension"
+    # * +default_url+: The URL that will be returned if there is no attachment assigned.
+    #   This field is interpolated just as the url is. The default value is
+    #   "/:attachment/:style/missing.png"
+    #     has_attached_file :avatar, :default_url => "/images/default_:style_avatar.png"
+    #     User.new.avatar_url(:small) # => "/images/default_small_avatar.png"
+    # * +styles+: A hash of thumbnail styles and their geometries. You can find more about
+    #   geometry strings at the ImageMagick website
+    #   (http://www.imagemagick.org/script/command-line-options.php#resize). Paperclip
+    #   also adds the "#" option (e.g. "50x50#"), which will resize the image to fit maximally
+    #   inside the dimensions and then crop the rest off (weighted at the center). The
+    #   default value is to generate no thumbnails.
+    # * +default_style+: The thumbnail style that will be used by default URLs.
+    #   Defaults to +original+.
+    #     has_attached_file :avatar, :styles => { :normal => "100x100#" },
+    #                       :default_style => :normal
+    #     user.avatar.url # => "/avatars/23/normal_me.png"
+    # * +whiny+: Will raise an error if Paperclip cannot post_process an uploaded file due
+    #   to a command line error. This will override the global setting for this attachment.
+    #   Defaults to true. This option used to be called :whiny_thumbanils, but this is
+    #   deprecated.
+    # * +convert_options+: When creating thumbnails, use this free-form options
+    #   array to pass in various convert command options.  Typical options are "-strip" to
+    #   remove all Exif data from the image (save space for thumbnails and avatars) or
+    #   "-depth 8" to specify the bit depth of the resulting conversion.  See ImageMagick
+    #   convert documentation for more options: (http://www.imagemagick.org/script/convert.php)
+    #   Note that this option takes a hash of options, each of which correspond to the style
+    #   of thumbnail being generated. You can also specify :all as a key, which will apply
+    #   to all of the thumbnails being generated. If you specify options for the :original,
+    #   it would be best if you did not specify destructive options, as the intent of keeping
+    #   the original around is to regenerate all the thumbnails when requirements change.
+    #     has_attached_file :avatar, :styles => { :large => "300x300", :negative => "100x100" }
+    #                                :convert_options => {
+    #                                  :all => "-strip",
+    #                                  :negative => "-negate"
+    #                                }
+    #   NOTE: While not deprecated yet, it is not recommended to specify options this way.
+    #   It is recommended that :convert_options option be included in the hash passed to each
+    #   :styles for compatability with future versions.
+    #   NOTE: Strings supplied to :convert_options are split on space in order to undergo
+    #   shell quoting for safety. If your options require a space, please pre-split them
+    #   and pass an array to :convert_options instead.
+    # * +storage+: Chooses the storage backend where the files will be stored. The current
+    #   choices are :filesystem and :s3. The default is :filesystem. Make sure you read the
+    #   documentation for Paperclip::Storage::Filesystem and Paperclip::Storage::S3
+    #   for backend-specific options.
+    def has_attached_file name, options = {}
+      include InstanceMethods
+
+      write_inheritable_attribute(:attachment_definitions, {}) if attachment_definitions.nil?
+      attachment_definitions[name] = {:validations => []}.merge(options)
+
+      after_save :save_attached_files
+      before_destroy :destroy_attached_files
+
+      define_paperclip_callbacks :post_process, :"#{name}_post_process"
+
+      define_method name do |*args|
+        a = attachment_for(name)
+        (args.length > 0) ? a.to_s(args.first) : a
+      end
+
+      define_method "#{name}=" do |file|
+        attachment_for(name).assign(file)
+      end
+
+      define_method "#{name}?" do
+        attachment_for(name).file?
+      end
+
+      validates_each(name) do |record, attr, value|
+        attachment = record.attachment_for(name)
+        attachment.send(:flush_errors)
+      end
+    end
+
+    # Places ActiveRecord-style validations on the size of the file assigned. The
+    # possible options are:
+    # * +in+: a Range of bytes (i.e. +1..1.megabyte+),
+    # * +less_than+: equivalent to :in => 0..options[:less_than]
+    # * +greater_than+: equivalent to :in => options[:greater_than]..Infinity
+    # * +message+: error message to display, use :min and :max as replacements
+    # * +if+: A lambda or name of a method on the instance. Validation will only
+    #   be run is this lambda or method returns true.
+    # * +unless+: Same as +if+ but validates if lambda or method returns false.
+    def validates_attachment_size name, options = {}
+      min     = options[:greater_than] || (options[:in] && options[:in].first) || 0
+      max     = options[:less_than]    || (options[:in] && options[:in].last)  || (1.0/0)
+      range   = (min..max)
+      message = options[:message] || "file size must be between :min and :max bytes."
+      message = message.gsub(/:min/, min.to_s).gsub(/:max/, max.to_s)
+
+      validates_inclusion_of :"#{name}_file_size",
+                             :in      => range,
+                             :message => message,
+                             :if      => options[:if],
+                             :unless  => options[:unless]
+    end
+
+    # Adds errors if thumbnail creation fails. The same as specifying :whiny_thumbnails => true.
+    def validates_attachment_thumbnails name, options = {}
+      warn('[DEPRECATION] validates_attachment_thumbnail is deprecated. ' +
+           'This validation is on by default and will be removed from future versions. ' +
+           'If you wish to turn it off, supply :whiny => false in your definition.')
+      attachment_definitions[name][:whiny_thumbnails] = true
+    end
+
+    # Places ActiveRecord-style validations on the presence of a file.
+    # Options:
+    # * +if+: A lambda or name of a method on the instance. Validation will only
+    #   be run is this lambda or method returns true.
+    # * +unless+: Same as +if+ but validates if lambda or method returns false.
+    def validates_attachment_presence name, options = {}
+      message = options[:message] || "must be set."
+      validates_presence_of :"#{name}_file_name",
+                            :message => message,
+                            :if      => options[:if],
+                            :unless  => options[:unless]
+    end
+
+    # Places ActiveRecord-style validations on the content type of the file
+    # assigned. The possible options are:
+    # * +content_type+: Allowed content types.  Can be a single content type
+    #   or an array.  Each type can be a String or a Regexp. It should be
+    #   noted that Internet Explorer upload files with content_types that you
+    #   may not expect. For example, JPEG images are given image/pjpeg and
+    #   PNGs are image/x-png, so keep that in mind when determining how you
+    #   match.  Allows all by default.
+    # * +message+: The message to display when the uploaded file has an invalid
+    #   content type.
+    # * +if+: A lambda or name of a method on the instance. Validation will only
+    #   be run is this lambda or method returns true.
+    # * +unless+: Same as +if+ but validates if lambda or method returns false.
+    # NOTE: If you do not specify an [attachment]_content_type field on your
+    # model, content_type validation will work _ONLY upon assignment_ and
+    # re-validation after the instance has been reloaded will always succeed.
+    def validates_attachment_content_type name, options = {}
+      types = [options.delete(:content_type)].flatten
+      validates_each(:"#{name}_content_type", options) do |record, attr, value|
+        unless types.any?{|t| t === value }
+          if record.errors.method(:add).arity == -2
+            message = options[:message] || "is not one of #{types.join(", ")}"
+            record.errors.add(:"#{name}_content_type", message)
+          else
+            record.errors.add(:"#{name}_content_type", :inclusion, :default => options[:message], :value => value)
+          end
+        end
+      end
+    end
+
+    # Returns the attachment definitions defined by each call to
+    # has_attached_file.
+    def attachment_definitions
+      read_inheritable_attribute(:attachment_definitions)
+    end
+  end
+
+  module InstanceMethods #:nodoc:
+    def attachment_for name
+      @_paperclip_attachments ||= {}
+      @_paperclip_attachments[name] ||= Attachment.new(name, self, self.class.attachment_definitions[name])
+    end
+
+    def each_attachment
+      self.class.attachment_definitions.each do |name, definition|
+        yield(name, attachment_for(name))
+      end
+    end
+
+    def save_attached_files
+      Paperclip.log("Saving attachments.")
+      each_attachment do |name, attachment|
+        attachment.send(:save)
+      end
+    end
+
+    def destroy_attached_files
+      Paperclip.log("Deleting attachments.")
+      each_attachment do |name, attachment|
+        attachment.send(:queue_existing_for_delete)
+        attachment.send(:flush_deletes)
+      end
+    end
+  end
+
+end