jeremydurham-merb_paperclip 0.9.12

data/LICENSE

@@ -0,0 +1,23 @@
+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/README

@@ -0,0 +1,4 @@
+merb_paperclip
+==============
+
+A Merb plugin that is essentially a port of Jon Yurek's paperclip. For Merb + ActiveRecord only.

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+require 'merb-core'
+require 'merb-core/tasks/merb'
+
+GEM_NAME = "merb_paperclip"
+GEM_VERSION = "0.9.12"
+AUTHOR = "Jeremy Durham"
+EMAIL = "jeremydurham@gmail.com"
+HOMEPAGE = "http://www.thoughtbot.com/projects/paperclip/"
+SUMMARY = "A Merb plugin that is essentially a port of Jon Yurek's paperclip"
+
+spec = Gem::Specification.new do |s|
+  s.rubyforge_project = 'merb'
+  s.name = GEM_NAME
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.add_dependency('merb', '>= 1.0')
+  s.require_path = 'lib'
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,spec}/**/*")
+  
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the plugin as a gem"
+task :install do
+  Merb::RakeHelper.install(GEM_NAME, :version => GEM_VERSION)
+end
+
+desc "Uninstall the gem"
+task :uninstall do
+  Merb::RakeHelper.uninstall(GEM_NAME, :version => GEM_VERSION)
+end
+
+desc "Create a gemspec file"
+task :gemspec do
+  File.open("#{GEM_NAME}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/TODO

@@ -0,0 +1 @@
+TODO:

data/lib/generators/paperclip_generator.rb

@@ -0,0 +1,53 @@
+module Merb::Generators
+
+  class PaperclipGenerator < NamespacedGenerator
+    
+    def self.source_root
+      File.dirname(__FILE__) / 'templates'
+    end
+    
+    desc <<-DESC
+      Generators a paperclip migration
+    DESC
+    
+    first_argument  :name, :required => true, :desc => "model name"
+    second_argument :attachments, :required => true, :as => :array, :default => [], :desc => "space separated list of fields"
+
+    template :paperclip do
+      source(File.dirname(__FILE__) / 'templates' / '%file_name%.rb')
+      destination("schema/migrations/#{migration_file_name}.rb")
+    end
+    
+    def version
+      format("%03d", current_migration_nr + 1)
+    end
+    
+    def migration_file_name
+      names = migration_attachments
+      "#{version}_add_attachments_#{names.join("_")}_to_#{class_name.underscore}"
+    end
+    
+    def migration_name
+      names = migration_attachments
+      "add_attachments_#{names.join("_")}_to_#{class_name.underscore}".classify
+    end
+
+    protected
+    
+    def migration_attachments      
+      names = attachments.map(&:underscore)
+      attachments.length == 1 ? names : names[0..-2] + ["and", names[-1]]
+    end
+    
+    def destination_directory
+      File.join(destination_root, 'schema', 'migrations')
+    end
+
+    def current_migration_nr
+      Dir["#{destination_directory}/*"].map{|f| File.basename(f).match(/^(\d+)/)[0].to_i  }.max.to_i
+    end
+    
+  end
+
+  add :paperclip, PaperclipGenerator
+end

data/lib/generators/templates/%file_name%.rb

@@ -0,0 +1,17 @@
+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
+<% 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
+<% end -%>
+  end
+end

data/lib/merb_paperclip/merbtasks.rb

@@ -0,0 +1,38 @@
+def obtain_class
+  class_name = ENV['CLASS'] || ENV['class']
+  raise "Must specify CLASS" unless class_name
+  @klass = Object.const_get(class_name)
+end
+
+def obtain_attachments
+  name = ENV['ATTACHMENT'] || ENV['attachment']
+  raise "Class #{@klass.name} has no attachments specified" unless @klass.respond_to?(:attachment_definitions)
+  if !name.blank? && @klass.attachment_definitions.keys.include?(name)
+    [ name ]
+  else
+    @klass.attachment_definitions.keys
+  end
+end
+
+namespace :paperclip do
+  desc "Regenerates thumbnails for a given CLASS (and optional ATTACHMENT)"
+  task :refresh => :environment do
+    klass     = obtain_class
+    names     = obtain_attachments
+    instances = klass.find(:all)
+    
+    puts "Regenerating thumbnails for #{instances.length} instances of #{klass.name}:"
+    instances.each do |instance|
+      names.each do |name|
+        result = if instance.send("#{ name }?")
+          instance.send(name).reprocess!
+          instance.send(name).save
+        else
+          true
+        end
+        print result ? "." : "x"; $stdout.flush
+      end
+    end
+    puts " Done."
+  end
+end

data/lib/merb_paperclip.rb

@@ -0,0 +1,19 @@
+# make sure we're running inside Merb
+if defined?(Merb::Plugins)
+  dependency "activerecord"
+
+  # Merb gives you a Merb::Plugins.config hash...feel free to put your stuff in your piece of it
+  Merb::Plugins.config[:merb_paperclip] = {
+    :chickens => false
+  }
+  
+  Merb::BootLoader.before_app_loads do    
+    require File.join(File.dirname(__FILE__), "paperclip")  
+    Merb.add_generators(File.join(File.dirname(__FILE__), 'generators', 'paperclip_generator'))
+  end
+  
+  Merb::BootLoader.after_app_loads do
+  end
+  
+  Merb::Plugins.add_rakefiles "merb_paperclip/merbtasks"
+end

data/lib/paperclip/attachment.rb

@@ -0,0 +1,287 @@
+module Paperclip
+  # The Attachment class manages the files for a given attachment. It saves when the model saves,
+  # deletes when the model is destroyed, and processes the file upon assignment.
+  class Attachment
+    
+    def self.default_options
+      @default_options ||= {
+        :url           => "/:attachment/:id/:style/:basename.:extension",
+        :path          => ":merb_root/public/:attachment/:id/:style/:basename.:extension",
+        :styles        => {},
+        :default_url   => "/:attachment/:style/missing.png",
+        :default_style => :original,
+        :validations   => [],
+        :storage       => :filesystem
+      }
+    end
+
+    attr_reader :name, :instance, :styles, :default_style
+
+    # Creates an Attachment object. +name+ is the name of the attachment, +instance+ is the
+    # ActiveRecord object instance it's attached to, and +options+ is the same as the hash
+    # passed to +has_attached_file+.
+    def initialize name, instance, options = {}
+      @name              = name
+      @instance          = instance
+
+      options = self.class.default_options.merge(options)
+
+      @url               = options[:url]
+      @path              = options[:path]
+      @styles            = options[:styles]
+      @default_url       = options[:default_url]
+      @validations       = options[:validations]
+      @default_style     = options[:default_style]
+      @storage           = options[:storage]
+      @whiny_thumbnails  = options[:whiny_thumbnails]
+      @options           = options
+      @queued_for_delete = []
+      @queued_for_write  = {}
+      @errors            = []
+      @validation_errors = nil
+      @dirty             = false
+
+      normalize_style_definition
+      initialize_storage
+
+      logger.info("[paperclip] Paperclip attachment #{name} on #{instance.class} initialized.")
+    end
+
+    # What gets called when you call instance.attachment = File. It clears errors,
+    # assigns attributes, processes the file, and runs validations. It also queues up
+    # the previous file for deletion, to be flushed away on #save of its host.
+    # In addition to form uploads, you can also assign another Paperclip attachment:
+    #   new_user.avatar = old_user.avatar
+    def assign uploaded_file
+      %w(file_name).each do |field|
+        unless @instance.class.column_names.include?("#{name}_#{field}")
+          raise PaperclipError.new("#{self} model does not have required column '#{name}_#{field}'")
+        end
+      end
+
+      if uploaded_file.is_a?(Paperclip::Attachment)
+        uploaded_file = uploaded_file.to_file(:original)
+      end
+
+      return nil unless valid_assignment?(uploaded_file)
+      logger.info("[paperclip] Assigning #{uploaded_file.inspect} to #{name}")
+
+      queue_existing_for_delete
+      @errors            = []
+      @validation_errors = nil
+
+      return nil if uploaded_file.nil?
+
+      logger.info("[paperclip] Writing attributes for #{name}")
+      @queued_for_write[:original]        = uploaded_file['tempfile']
+      @instance[:"#{@name}_file_name"]    = uploaded_file['tempfile'].original_filename.strip.gsub /[^\w\d\.\-]+/, '_'
+      @instance[:"#{@name}_content_type"] = uploaded_file['tempfile'].content_type.strip
+      @instance[:"#{@name}_file_size"]    = uploaded_file['tempfile'].size.to_i
+      @instance[:"#{@name}_updated_at"]   = Time.now
+
+      @dirty = true
+
+      post_process
+    ensure
+      validate
+    end
+
+    # Returns the public URL of the attachment, with a given style. Note that this
+    # does not necessarily need to point to a file that your web server can access
+    # and can point to an action in your app, if you need fine grained security.
+    # This is not recommended if you don't need the security, however, for
+    # performance reasons.
+    def url style = default_style
+      url = original_filename.nil? ? interpolate(@default_url, style) : interpolate(@url, style)
+      updated_at ? [url, updated_at].compact.join(url.include?("?") ? "&" : "?") : url
+    end
+
+    # Returns the path of the attachment as defined by the :path option. If the
+    # file is stored in the filesystem the path refers to the path of the file on
+    # disk. If the file is stored in S3, the path is the "key" part of the URL,
+    # and the :bucket option refers to the S3 bucket.
+    def path style = nil #:nodoc:
+      interpolate(@path, style)
+    end
+
+    # Alias to +url+
+    def to_s style = nil
+      url(style)
+    end
+
+    # Returns true if there are no errors on this attachment.
+    def valid?
+      validate
+      errors.length == 0
+    end
+
+    # Returns an array containing the errors on this attachment.
+    def errors
+      @errors.compact.uniq
+    end
+
+    # Returns true if there are changes that need to be saved.
+    def dirty?
+      @dirty
+    end
+
+    # Saves the file, if there are no errors. If there are, it flushes them to
+    # the instance's errors and returns false, cancelling the save.
+    def save
+      if valid?
+        logger.info("[paperclip] Saving files for #{name}")
+        flush_deletes
+        flush_writes
+        @dirty = false
+        true
+      else
+        logger.info("[paperclip] Errors on #{name}. Not saving.")
+        flush_errors
+        false
+      end
+    end
+
+    # Returns the name of the file as originally assigned, and as lives in the
+    # <attachment>_file_name attribute of the model.
+    def original_filename
+      instance[:"#{name}_file_name"]
+    end
+    
+    def updated_at
+      time = instance[:"#{name}_updated_at"]
+      time && time.to_i
+    end
+
+    # A hash of procs that are run during the interpolation of a path or url.
+    # A variable of the format :name will be replaced with the return value of
+    # the proc named ":name". Each lambda takes the attachment and the current
+    # style as arguments. This hash can be added to with your own proc if
+    # necessary.
+    def self.interpolations
+      @interpolations ||= {
+        :merb_root   => lambda{|attachment,style| Merb.root },
+        :class        => lambda do |attachment,style|
+                           attachment.instance.class.name.underscore.pluralize
+                         end,
+        :basename     => lambda do |attachment,style|
+                           attachment.original_filename.gsub(File.extname(attachment.original_filename), "")
+                         end,
+        :extension    => lambda do |attachment,style| 
+                           ((style = attachment.styles[style]) && style.last) ||
+                           File.extname(attachment.original_filename).gsub(/^\.+/, "")
+                         end,
+        :id           => lambda{|attachment,style| attachment.instance.id },
+        :id_partition => lambda do |attachment, style|
+                           ("%09d" % attachment.instance.id).scan(/\d{3}/).join("/")
+                         end,
+        :attachment   => lambda{|attachment,style| attachment.name.to_s.downcase.pluralize },
+        :style        => lambda{|attachment,style| style || attachment.default_style },
+      }
+    end
+
+    # This method really shouldn't be called that often. It's expected use is in the
+    # paperclip:refresh rake task and that's it. It will regenerate all thumbnails
+    # forcefully, by reobtaining the original file and going through the post-process
+    # again.
+    def reprocess!
+      new_original = Tempfile.new("paperclip-reprocess")
+      if old_original = to_file(:original)
+        new_original.write( old_original.read )
+        new_original.rewind
+
+        @queued_for_write = { :original => new_original }
+        post_process
+
+        old_original.close if old_original.respond_to?(:close)
+
+        save
+      else
+        true
+      end
+    end
+    
+    def file?
+      !original_filename.blank?
+    end
+
+    private
+
+    def logger
+      instance.logger
+    end
+
+    def valid_assignment? file #:nodoc:
+      file.nil? || (file.is_a?(Mash) && file.has_key?(:tempfile))
+    end
+
+    def validate #:nodoc:
+      unless @validation_errors
+        @validation_errors = @validations.collect do |v|
+          v.call(self, instance)
+        end.flatten.compact.uniq
+        @errors += @validation_errors
+      end
+      @validation_errors
+    end
+
+    def normalize_style_definition
+      @styles.each do |name, args|
+        dimensions, format = [args, nil].flatten[0..1]
+        format             = nil if format == ""
+        @styles[name]      = [dimensions, format]
+      end
+    end
+
+    def initialize_storage
+      @storage_module = Paperclip::Storage.const_get(@storage.to_s.capitalize)
+      self.extend(@storage_module)
+    end
+
+    def post_process #:nodoc:
+      return if @queued_for_write[:original].nil?
+      logger.info("[paperclip] Post-processing #{name}")
+      @styles.each do |name, args|
+        begin
+          dimensions, format = args
+          dimensions = dimensions.call(instance) if dimensions.respond_to? :call
+          @queued_for_write[name] = Thumbnail.make(@queued_for_write[:original], 
+                                                   dimensions,
+                                                   format, 
+                                                   @whiny_thumnails)
+        rescue PaperclipError => e
+          @errors << e.message if @whiny_thumbnails
+        end
+      end
+    end
+
+    def interpolate pattern, style = default_style #:nodoc:
+      interpolations = self.class.interpolations.sort{|a,b| a.first.to_s <=> b.first.to_s }
+      interpolations.reverse.inject( pattern.dup ) do |result, interpolation|
+        tag, blk = interpolation
+        result.gsub(/:#{tag}/) do |match|
+          blk.call( self, style )
+        end
+      end
+    end
+
+    def queue_existing_for_delete #:nodoc:
+      return unless file?
+      logger.info("[paperclip] Queueing the existing files for #{name} for deletion.")
+      @queued_for_delete += [:original, *@styles.keys].uniq.map do |style|
+        path(style) if exists?(style)
+      end.compact
+      @instance[:"#{@name}_file_name"]    = nil
+      @instance[:"#{@name}_content_type"] = nil
+      @instance[:"#{@name}_file_size"]    = nil
+      @instance[:"#{@name}_updated_at"]   = nil
+    end
+
+    def flush_errors #:nodoc:
+      @errors.each do |error|
+        instance.errors.add(name, error)
+      end
+    end
+
+  end
+end
+

data/lib/paperclip/geometry.rb

@@ -0,0 +1,109 @@
+module Paperclip
+  
+  # Defines the geometry of an image.
+  class Geometry
+    attr_accessor :height, :width, :modifier
+
+    # Gives a Geometry representing the given height and width
+    def initialize width = nil, height = nil, modifier = nil
+      height = nil if height == ""
+      width  = nil if width  == ""
+      @height = (height || width).to_f
+      @width  = (width  || height).to_f
+      @modifier = modifier
+    end
+
+    # Uses ImageMagick to determing the dimensions of a file, passed in as either a
+    # File or path.
+    def self.from_file file
+      file = file.path if file.respond_to? "path"
+      parse(`#{Paperclip.path_for_command('identify')} "#{file}"`) ||
+        raise(NotIdentifiedByImageMagickError.new("#{file} is not recognized by the 'identify' command."))
+    end
+
+    # Parses a "WxH" formatted string, where W is the width and H is the height.
+    def self.parse string
+      if match = (string && string.match(/\b(\d*)x(\d*)\b([\>\<\#\@\%^!])?/))
+        Geometry.new(*match[1,3])
+      end
+    end
+
+    # True if the dimensions represent a square
+    def square?
+      height == width
+    end
+
+    # True if the dimensions represent a horizontal rectangle
+    def horizontal?
+      height < width
+    end
+
+    # True if the dimensions represent a vertical rectangle
+    def vertical?
+      height > width
+    end
+
+    # The aspect ratio of the dimensions.
+    def aspect
+      width / height
+    end
+
+    # Returns the larger of the two dimensions
+    def larger
+      [height, width].max
+    end
+
+    # Returns the smaller of the two dimensions
+    def smaller
+      [height, width].min
+    end
+
+    # Returns the width and height in a format suitable to be passed to Geometry.parse
+    def to_s
+      "%dx%d%s" % [width, height, modifier]
+    end
+
+    # Same as to_s
+    def inspect
+      to_s
+    end
+
+    # Returns the scaling and cropping geometries (in string-based ImageMagick format) 
+    # neccessary to transform this Geometry into the Geometry given. If crop is true, 
+    # then it is assumed the destination Geometry will be the exact final resolution. 
+    # In this case, the source Geometry is scaled so that an image containing the 
+    # destination Geometry would be completely filled by the source image, and any 
+    # overhanging image would be cropped. Useful for square thumbnail images. The cropping 
+    # is weighted at the center of the Geometry.
+    def transformation_to dst, crop = false
+
+      if crop
+        ratio = Geometry.new( dst.width / self.width, dst.height / self.height )
+        scale_geometry, scale = scaling(dst, ratio)
+        crop_geometry         = cropping(dst, ratio, scale)
+      else
+        scale_geometry        = dst.to_s
+      end
+      
+      [ scale_geometry, crop_geometry ]
+    end
+
+    private
+
+    def scaling dst, ratio
+      if ratio.horizontal? || ratio.square?
+        [ "%dx" % dst.width, ratio.width ]
+      else
+        [ "x%d" % dst.height, ratio.height ]
+      end
+    end
+
+    def cropping dst, ratio, scale
+      if ratio.horizontal? || ratio.square?
+        "%dx%d+%d+%d" % [ dst.width, dst.height, 0, (self.height * scale - dst.height) / 2 ]
+      else
+        "%dx%d+%d+%d" % [ dst.width, dst.height, (self.width * scale - dst.width) / 2, 0 ]
+      end
+    end
+  end
+end

data/lib/paperclip/iostream.rb

@@ -0,0 +1,47 @@
+# Provides method that can be included on File-type objects (IO, StringIO, Tempfile, etc) to allow stream copying
+# and Tempfile conversion.
+module IOStream
+
+  # Returns a Tempfile containing the contents of the readable object.
+  def to_tempfile
+    tempfile = Tempfile.new("stream")
+    tempfile.binmode
+    self.stream_to(tempfile)
+  end
+
+  # Copies one read-able object from one place to another in blocks, obviating the need to load
+  # the whole thing into memory. Defaults to 8k blocks. If this module is included in both
+  # StringIO and Tempfile, then either can have its data copied anywhere else without typing
+  # worries or memory overhead worries. Returns a File if a String is passed in as the destination
+  # and returns the IO or Tempfile as passed in if one is sent as the destination.
+  def stream_to path_or_file, in_blocks_of = 8192
+    dstio = case path_or_file
+            when String   then File.new(path_or_file, "wb+")
+            when IO       then path_or_file
+            when Tempfile then path_or_file
+            end
+    buffer = ""
+    self.rewind
+    while self.read(in_blocks_of, buffer) do
+      dstio.write(buffer)
+    end
+    dstio.rewind    
+    dstio
+  end
+end
+
+class IO
+  include IOStream
+end
+
+class Mash
+  include IOStream
+end
+
+%w( Tempfile StringIO ).each do |klass|
+  if Object.const_defined? klass
+    Object.const_get(klass).class_eval do
+      include IOStream
+    end
+  end
+end

data/lib/paperclip/storage.rb

@@ -0,0 +1,204 @@
+module Paperclip
+  module Storage
+
+    # The default place to store attachments is in the filesystem. Files on the local
+    # filesystem can be very easily served by Apache without requiring a hit to your app.
+    # They also can be processed more easily after they've been saved, as they're just
+    # normal files. There is one Filesystem-specific option for has_attached_file.
+    # * +path+: The location of the repository of attachments on disk. This can (and, in
+    #   almost all cases, should) be coordinated with the value of the +url+ option to
+    #   allow files to be saved into a place where Apache can serve them without
+    #   hitting your app. Defaults to 
+    #   ":merb_root/public/:attachment/:id/:style/:basename.:extension"
+    #   By default this places the files in the app's public directory which can be served 
+    #   directly. If you are using capistrano for deployment, a good idea would be to 
+    #   make a symlink to the capistrano-created system directory from inside your app's 
+    #   public directory.
+    #   See Paperclip::Attachment#interpolate for more information on variable interpolaton.
+    #     :path => "/var/app/attachments/:class/:id/:style/:filename"
+    module Filesystem
+      def self.extended base
+      end
+      
+      def exists?(style = default_style)
+        if original_filename
+          File.exist?(path(style))
+        else
+          false
+        end
+      end
+
+      # Returns representation of the data of the file assigned to the given
+      # style, in the format most representative of the current storage.
+      def to_file style = default_style
+        @queued_for_write[style] || (File.new(path(style)) if exists?(style))
+      end
+      alias_method :to_io, :to_file
+
+      def flush_writes #:nodoc:
+        logger.info("[paperclip] Writing files for #{name}")
+        @queued_for_write.each do |style, file|
+          FileUtils.mkdir_p(File.dirname(path(style)))
+          logger.info("[paperclip] -> #{path(style)}")
+          result = file.stream_to(path(style))
+          file.close
+          result.close
+        end
+        @queued_for_write = {}
+      end
+
+      def flush_deletes #:nodoc:
+        logger.info("[paperclip] Deleting files for #{name}")
+        @queued_for_delete.each do |path|
+          begin
+            logger.info("[paperclip] -> #{path}")
+            FileUtils.rm(path) if File.exist?(path)
+          rescue Errno::ENOENT => e
+            # ignore file-not-found, let everything else pass
+          end
+        end
+        @queued_for_delete = []
+      end
+    end
+
+    # Amazon's S3 file hosting service is a scalable, easy place to store files for
+    # distribution. You can find out more about it at http://aws.amazon.com/s3
+    # There are a few S3-specific options for has_attached_file:
+    # * +s3_credentials+: Takes a path, a File, or a Hash. The path (or File) must point
+    #   to a YAML file containing the +access_key_id+ and +secret_access_key+ that Amazon
+    #   gives you. You can 'environment-space' this just like you do to your
+    #   database.yml file, so different environments can use different accounts:
+    #     development:
+    #       access_key_id: 123...
+    #       secret_access_key: 123... 
+    #     test:
+    #       access_key_id: abc...
+    #       secret_access_key: abc... 
+    #     production:
+    #       access_key_id: 456...
+    #       secret_access_key: 456... 
+    #   This is not required, however, and the file may simply look like this:
+    #     access_key_id: 456...
+    #     secret_access_key: 456... 
+    #   In which case, those access keys will be used in all environments.
+    # * +s3_permissions+: This is a String that should be one of the "canned" access
+    #   policies that S3 provides (more information can be found here:
+    #   http://docs.amazonwebservices.com/AmazonS3/2006-03-01/RESTAccessPolicy.html#RESTCannedAccessPolicies)
+    #   The default for Paperclip is "public-read".
+    # * +s3_protocol+: The protocol for the URLs generated to your S3 assets. Can be either 
+    #   'http' or 'https'. Defaults to 'http' when your :s3_permissions are 'public-read' (the
+    #   default), and 'https' when your :s3_permissions are anything else.
+    # * +bucket+: This is the name of the S3 bucket that will store your files. Remember
+    #   that the bucket must be unique across all of Amazon S3. If the bucket does not exist
+    #   Paperclip will attempt to create it. The bucket name will not be interpolated.
+    # * +url+: There are two options for the S3 url. You can choose to have the bucket's name
+    #   placed domain-style (bucket.s3.amazonaws.com) or path-style (s3.amazonaws.com/bucket).
+    #   Normally, this won't matter in the slightest and you can leave the default (which is
+    #   path-style, or :s3_path_url). But in some cases paths don't work and you need to use
+    #   the domain-style (:s3_domain_url). Anything else here will be treated like path-style.
+    # * +path+: This is the key under the bucket in which the file will be stored. The
+    #   URL will be constructed from the bucket and the path. This is what you will want
+    #   to interpolate. Keys should be unique, like filenames, and despite the fact that
+    #   S3 (strictly speaking) does not support directories, you can still use a / to
+    #   separate parts of your file name.
+    module S3
+      def self.extended base
+        require 'right_aws'
+        base.instance_eval do
+          @bucket         = @options[:bucket]
+          @s3_credentials = parse_credentials(@options[:s3_credentials])
+          @s3_options     = @options[:s3_options] || {}
+          @s3_permissions = @options[:s3_permissions] || 'public-read'
+          @s3_protocol    = @options[:s3_protocol] || (@s3_permissions == 'public-read' ? 'http' : 'https')
+          @url            = ":s3_path_url" unless @url.to_s.match(/^s3.*url$/)
+        end
+        base.class.interpolations[:s3_path_url] = lambda do |attachment, style|
+          "#{attachment.s3_protocol}://s3.amazonaws.com/#{attachment.bucket_name}/#{attachment.path(style).gsub(%r{^/}, "")}"
+        end
+        base.class.interpolations[:s3_domain_url] = lambda do |attachment, style|
+          "#{attachment.s3_protocol}://#{attachment.bucket_name}.s3.amazonaws.com/#{attachment.path(style).gsub(%r{^/}, "")}"
+        end
+        ActiveRecord::Base.logger.info("[paperclip] S3 Storage Initalized.")
+      end
+
+      def s3
+        @s3 ||= RightAws::S3.new(@s3_credentials[:access_key_id],
+                                 @s3_credentials[:secret_access_key],
+                                 @s3_options)
+      end
+
+      def s3_bucket
+        @s3_bucket ||= s3.bucket(@bucket, true, @s3_permissions)
+      end
+
+      def bucket_name
+        @bucket
+      end
+
+      def parse_credentials creds
+        creds = find_credentials(creds).stringify_keys
+        (creds[Merb.env] || creds).symbolize_keys
+      end
+      
+      def exists?(style = default_style)
+        s3_bucket.key(path(style)) ? true : false
+      end
+
+      def s3_protocol
+        @s3_protocol
+      end
+
+      # Returns representation of the data of the file assigned to the given
+      # style, in the format most representative of the current storage.
+      def to_file style = default_style
+        @queued_for_write[style] || s3_bucket.key(path(style))
+      end
+      alias_method :to_io, :to_file
+
+      def flush_writes #:nodoc:
+        logger.info("[paperclip] Writing files for #{name}")
+        @queued_for_write.each do |style, file|
+          begin
+            logger.info("[paperclip] -> #{path(style)}")
+            key = s3_bucket.key(path(style))
+            key.data = file
+            key.put(nil, @s3_permissions)
+          rescue RightAws::AwsError => e
+            raise
+          end
+        end
+        @queued_for_write = {}
+      end
+
+      def flush_deletes #:nodoc:
+        logger.info("[paperclip] Writing files for #{name}")
+        @queued_for_delete.each do |path|
+          begin
+            logger.info("[paperclip] -> #{path}")
+            if file = s3_bucket.key(path)
+              file.delete
+            end
+          rescue RightAws::AwsError
+            # Ignore this.
+          end
+        end
+        @queued_for_delete = []
+      end
+      
+      def find_credentials creds
+        case creds
+        when File:
+          YAML.load_file(creds.path)
+        when String:
+          YAML.load_file(creds)
+        when Hash:
+          creds
+        else
+          raise ArgumentError, "Credentials are not a path, file, or hash."
+        end
+      end
+      private :find_credentials
+
+    end
+  end
+end

data/lib/paperclip/thumbnail.rb

@@ -0,0 +1,80 @@
+module Paperclip
+  # Handles thumbnailing images that are uploaded.
+  class Thumbnail
+
+    attr_accessor :file, :current_geometry, :target_geometry, :format, :whiny_thumbnails
+
+    # Creates a Thumbnail object set to work on the +file+ given. It
+    # will attempt to transform the image into one defined by +target_geometry+
+    # which is a "WxH"-style string. +format+ will be inferred from the +file+
+    # unless specified. Thumbnail creation will raise no errors unless
+    # +whiny_thumbnails+ is true (which it is, by default.
+    def initialize file, target_geometry, format = nil, whiny_thumbnails = true
+      @file             = file
+      @crop             = target_geometry[-1,1] == '#'
+      @target_geometry  = Geometry.parse target_geometry
+      @current_geometry = Geometry.from_file file
+      @whiny_thumbnails = whiny_thumbnails
+
+      @current_format   = File.extname(@file.path)
+      @basename         = File.basename(@file.path, @current_format)
+      
+      @format = format
+    end
+
+    # Creates a thumbnail, as specified in +initialize+, +make+s it, and returns the
+    # resulting Tempfile.
+    def self.make file, dimensions, format = nil, whiny_thumbnails = true
+      new(file, dimensions, format, whiny_thumbnails).make
+    end
+
+    # Returns true if the +target_geometry+ is meant to crop.
+    def crop?
+      @crop
+    end
+
+    # Performs the conversion of the +file+ into a thumbnail. Returns the Tempfile
+    # that contains the new image.
+    def make
+      src = @file
+      dst = Tempfile.new([@basename, @format].compact.join("."))
+      dst.binmode
+
+      command = <<-end_command
+        #{ Paperclip.path_for_command('convert') }
+        "#{ File.expand_path(src.path) }"
+        #{ transformation_command }
+        "#{ File.expand_path(dst.path) }"
+      end_command
+      success = system(command.gsub(/\s+/, " "))
+
+      if success && $?.exitstatus != 0 && @whiny_thumbnails
+        raise PaperclipError, "There was an error processing this thumbnail"
+      end
+
+      dst
+    end
+
+    # Returns the command ImageMagick's +convert+ needs to transform the image
+    # into the thumbnail.
+    def transformation_command
+      scale, crop = @current_geometry.transformation_to(@target_geometry, crop?)
+      trans = "-scale \"#{scale}\""
+      trans << " -crop \"#{crop}\" +repage" if crop
+      trans
+    end
+  end
+
+  # Due to how ImageMagick handles its image format conversion and how Tempfile
+  # handles its naming scheme, it is necessary to override how Tempfile makes
+  # its names so as to allow for file extensions. Idea taken from the comments
+  # on this blog post:
+  # http://marsorange.com/archives/of-mogrify-ruby-tempfile-dynamic-class-definitions
+  class Tempfile < ::Tempfile
+    # Replaces Tempfile's +make_tmpname+ with one that honors file extensions.
+    def make_tmpname(basename, n)
+      extension = File.extname(basename)
+      sprintf("%s,%d,%d%s", File.basename(basename, extension), $$, n, extension)
+    end
+  end
+end

data/lib/paperclip/upfile.rb

@@ -0,0 +1,37 @@
+module Paperclip
+  # The Upfile module is a convenience module for adding uploaded-file-type methods
+  # to the +File+ class. Useful for testing.
+  #   user.avatar = File.new("test/test_avatar.jpg")
+  module Upfile
+
+    # Infer the MIME-type of the file from the extension.
+    def content_type
+      type = (self.path.match(/\.(\w+)$/)[1] rescue "octet-stream").downcase
+      case type
+      when %r"jpe?g"                 then "image/jpeg"
+      when %r"tiff?"                 then "image/tiff"
+      when %r"png", "gif", "bmp"     then "image/#{type}"
+      when "txt"                     then "text/plain"
+      when %r"html?"                 then "text/html"
+      when "csv", "xml", "css", "js" then "text/#{type}"
+      else "application/x-#{type}"
+      end
+    end
+
+    # Returns the file's normal name.
+    def original_filename
+      File.basename(self.path)
+    end
+
+    # Returns the size of the file.
+    def size
+      File.size(self)
+    end
+  end
+
+end
+
+class File #:nodoc:
+  include Paperclip::Upfile
+end
+

data/lib/paperclip.rb

@@ -0,0 +1,246 @@
+# 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 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 'tempfile'
+require 'paperclip/upfile'
+require 'paperclip/iostream'
+require 'paperclip/geometry'
+require 'paperclip/thumbnail'
+require 'paperclip/storage'
+require 'paperclip/attachment'
+
+# The base module that gets included in ActiveRecord::Base. See the
+# documentation for Paperclip::ClassMethods for more useful information.
+module Paperclip
+
+  VERSION = "2.1.2"
+
+  class << self
+    # Provides configurability to Paperclip. There are a number of options available, such as:
+    # * whiny_thumbnails: Will raise an error if Paperclip cannot process thumbnails of 
+    #   an uploaded image. Defaults to true.
+    # * image_magick_path: Defines the path at which to find the +convert+ and +identify+ 
+    #   programs if they are not visible to Merb the system's search path. Defaults to 
+    #   nil, which uses the first executable found in the search path.
+    def options
+      @options ||= {
+        :whiny_thumbnails  => true,
+        :image_magick_path => nil
+      }
+    end
+
+    def path_for_command command #:nodoc:
+      path = [options[:image_magick_path], command].compact
+      File.join(*path)
+    end
+
+    def included base #:nodoc:
+      base.extend ClassMethods
+    end
+  end
+
+  class PaperclipError < StandardError #:nodoc:
+  end
+
+  class NotIdentifiedByImageMagickError < 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 "/:class/:attachment/:id/:style_:filename". See
+    #   Paperclip::Attachment#interpolate for more information on variable interpolaton.
+    #     :url => "/:attachment/:id/:style_:basename:extension"
+    #     :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 
+    #   "/:class/:attachment/missing_:style.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_thumbnails+: Will raise an error if Paperclip cannot process thumbnails of an
+    #   uploaded image. This will ovrride the global setting for this attachment. 
+    #   Defaults to true. 
+    # * +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_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|
+        value.send(:flush_errors) unless value.valid?
+      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
+    def validates_attachment_size name, options = {}
+      attachment_definitions[name][:validations] << lambda do |attachment, instance|
+        unless options[:greater_than].nil?
+          options[:in] = (options[:greater_than]..(1/0)) # 1/0 => Infinity
+        end
+        unless options[:less_than].nil?
+          options[:in] = (0..options[:less_than])
+        end
+        
+        if attachment.file? && !options[:in].include?(instance[:"#{name}_file_size"].to_i)
+          min = options[:in].first
+          max = options[:in].last
+          
+          if options[:message]
+            options[:message].gsub(/:min/, min.to_s).gsub(/:max/, max.to_s)
+          else
+            "file size is not between #{min} and #{max} bytes."
+          end
+        end
+      end
+    end
+
+    # Adds errors if thumbnail creation fails. The same as specifying :whiny_thumbnails => true.
+    def validates_attachment_thumbnails name, options = {}
+      attachment_definitions[name][:whiny_thumbnails] = true
+    end
+
+    # Places ActiveRecord-style validations on the presence of a file.
+    def validates_attachment_presence name, options = {}
+      attachment_definitions[name][:validations] << lambda do |attachment, instance|
+        unless attachment.file?
+          options[:message] || "must be set."
+        end
+      end
+    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 uploads
+    #   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.
+    def validates_attachment_content_type name, options = {}
+      attachment_definitions[name][:validations] << lambda do |attachment, instance|
+        valid_types = [options[:content_type]].flatten
+        
+        unless attachment.original_filename.nil?
+          unless options[:content_type].blank?
+            content_type = instance[:"#{name}_content_type"]
+            unless valid_types.any?{|t| t === content_type }
+              options[:message] || "is not one of the allowed file types."
+            end
+          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
+      @attachments ||= {}
+      @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
+      logger.info("[paperclip] Saving attachments.")
+      each_attachment do |name, attachment|
+        attachment.send(:save)
+      end
+    end
+
+    def destroy_attached_files
+      logger.info("[paperclip] Deleting attachments.")
+      each_attachment do |name, attachment|
+        attachment.send(:queue_existing_for_delete)
+        attachment.send(:flush_deletes)
+      end
+    end
+  end
+
+end
+
+# Set it all up.
+if Object.const_defined?("ActiveRecord")
+  ActiveRecord::Base.send(:include, Paperclip)
+  File.send(:include, Paperclip::Upfile)
+end

data/spec/merb_paperclip_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "merb_paperclip" do
+  it "should do nothing" do
+    true.should == true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: jeremydurham-merb_paperclip
+version: !ruby/object:Gem::Version 
+  version: 0.9.12
+platform: ruby
+authors: 
+- Jeremy Durham
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-01 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: merb
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.4
+    version: 
+description: A Merb plugin that is essentially a port of Jon Yurek's paperclip
+email: jeremydurham@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/generators
+- lib/generators/paperclip_generator.rb
+- lib/generators/templates
+- lib/generators/templates/%file_name%.rb
+- lib/merb_paperclip
+- lib/merb_paperclip/merbtasks.rb
+- lib/merb_paperclip.rb
+- lib/paperclip
+- lib/paperclip/attachment.rb
+- lib/paperclip/geometry.rb
+- lib/paperclip/iostream.rb
+- lib/paperclip/storage.rb
+- lib/paperclip/thumbnail.rb
+- lib/paperclip/upfile.rb
+- lib/paperclip.rb
+- spec/merb_paperclip_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://www.thoughtbot.com/projects/paperclip/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: merb
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A Merb plugin that is essentially a port of Jon Yurek's paperclip
+test_files: []
+