avatar 0.0.4 → 0.0.5

data/test/lib/paperclip/lib/paperclip.rb

@@ -0,0 +1,197 @@
+# 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:: Distrbutes under the same terms as Ruby
+#
+# 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/attachment'
+
+# The base module that gets included in ActiveRecord::Base.
+module Paperclip
+  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 Rails 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
+
+  module ClassMethods
+    attr_reader :attachment_definitions
+
+    # +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"
+    # * +path+: The location of the repository of attachments on disk. This can 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 
+    #   ":rails_root/public/:class/:attachment/:id/:style_:filename". 
+    #   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"
+    # * +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. 
+    def has_attached_file name, options = {}
+      include InstanceMethods
+
+      @attachment_definitions ||= {} 
+      @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.nil?
+      end
+
+      validates_each(name) do |record, attr, value|
+        value.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
+    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
+        unless options[:in].include? instance[:"#{name}_file_size"].to_i
+          "file size is not between #{options[:in].first} and #{options[:in].last} bytes."
+        end
+      end
+    end
+
+    # Places ActiveRecord-style validations on the presence of a file.
+    def validates_attachment_presence name
+      @attachment_definitions[name][:validations] << lambda do |attachment, instance|
+        if attachment.file.nil? || !File.exist?(attachment.file.path)
+          "must be set."
+        end
+      end
+    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
+      each_attachment do |name, attachment|
+        attachment.send(:flush_writes)
+        attachment.send(:flush_deletes)
+      end
+    end
+
+    def destroy_attached_files
+      each_attachment do |name, attachment|
+        attachment.send(:queue_existing_for_delete)
+        attachment.send(:flush_deletes)
+      end
+    end
+  end
+
+end

data/test/lib/paperclip/lib/paperclip/attachment.rb

@@ -0,0 +1,230 @@
+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
+    
+    attr_reader :name, :instance, :file, :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
+      @url               = options[:url]           || 
+                           "/:attachment/:id/:style/:basename.:extension"
+      @path              = options[:path]          || 
+                           ":rails_root/public/:attachment/:id/:style/:basename.:extension"
+      @styles            = options[:styles]        || {}
+      @default_url       = options[:default_url]   || "/:attachment/:style/missing.png"
+      @validations       = options[:validations]   || []
+      @default_style     = options[:default_style] || :original
+      @queued_for_delete = []
+      @processed_files   = {}
+      @errors            = []
+      @validation_errors = nil
+      @dirty             = false
+
+      normalize_style_definition
+
+      @file              = File.new(path) if original_filename && File.exists?(path)
+    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.
+    def assign uploaded_file
+      queue_existing_for_delete
+      @errors            = []
+      @validation_errors = nil 
+
+      return nil unless valid_file?(uploaded_file)
+
+      @file                               = uploaded_file.to_tempfile
+      @instance[:"#{@name}_file_name"]    = uploaded_file.original_filename
+      @instance[:"#{@name}_content_type"] = uploaded_file.content_type
+      @instance[:"#{@name}_file_size"]    = uploaded_file.size
+
+      @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 = nil
+      @file ? interpolate(@url, style) : interpolate(@default_url, style)
+    end
+
+    # Alias to +url+
+    def to_s style = nil
+      url(style)
+    end
+
+    # Returns true if there are any errors on this attachment.
+    def valid?
+      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?
+        flush_deletes
+        flush_writes
+        true
+      else
+        flush_errors
+        false
+      end
+    end
+
+    # Returns an +IO+ representing the data of the file assigned to the given
+    # style. Useful for streaming with +send_file+.
+    def to_io style = nil
+      begin
+        style ||= @default_style
+        @processed_files[style] || File.new(path(style))
+      rescue Errno::ENOENT
+        nil
+      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
+
+    # 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 ||= {
+        :rails_root   => lambda{|attachment,style| RAILS_ROOT },
+        :class        => lambda{|attachment,style| attachment.instance.class.to_s.downcase.pluralize },
+        :basename     => lambda do |attachment,style|
+                           attachment.original_filename.gsub(/\.(.*?)$/, "")
+                         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 },
+        :partition_id => 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
+
+    private
+
+    def valid_file? file #:nodoc:
+      file.respond_to?(:original_filename) && file.respond_to?(:content_type)
+    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
+    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 post_process #:nodoc:
+      return nil if @file.nil?
+      @styles.each do |name, args|
+        begin
+          dimensions, format = args
+          @processed_files[name] = Thumbnail.make(self.file, 
+                                                  dimensions, 
+                                                  format, 
+                                                  @whiny_thumbnails)
+        rescue Errno::ENOENT  => e
+          @errors << "could not be processed because the file does not exist."
+        rescue PaperclipError => e
+          @errors << e.message
+        end
+      end
+      @processed_files[:original] = @file
+    end
+
+    def interpolate pattern, style = nil #:nodoc:
+      style ||= @default_style
+      pattern = pattern.dup
+      self.class.interpolations.each do |tag, l|
+        pattern.gsub!(/:#{tag}/) do |match|
+          l.call( self, style )
+        end
+      end
+      pattern.gsub(%r{/+}, "/")
+    end
+
+    def path style = nil #:nodoc:
+      interpolate(@path, style)
+    end
+
+    def queue_existing_for_delete #:nodoc:
+      @queued_for_delete += @processed_files.values
+      @file               = nil
+      @processed_files    = {}
+      @instance[:"#{@name}_file_name"]    = nil
+      @instance[:"#{@name}_content_type"] = nil
+      @instance[:"#{@name}_file_size"]    = nil
+    end
+
+    def flush_errors #:nodoc:
+      @errors.each do |error|
+        instance.errors.add(name, error)
+      end
+    end
+
+    def flush_writes #:nodoc:
+      @processed_files.each do |style, file|
+        FileUtils.mkdir_p( File.dirname(path(style)) )
+        @processed_files[style] = file.stream_to(path(style)) unless file.path == path(style)
+      end
+      @file = @processed_files[@default_style]
+    end
+
+    def flush_deletes #:nodoc:
+      @queued_for_delete.compact.each do |file|
+        begin
+          FileUtils.rm(file.path)
+        rescue Errno::ENOENT => e
+          # ignore them
+        end
+      end
+      @queued_for_delete = []
+    end
+  end
+end
+

data/test/lib/paperclip/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(Errno::ENOENT, file)
+    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
+      ratio = Geometry.new( dst.width / self.width, dst.height / self.height )
+
+      if crop
+        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