dm-paperclip 2.4.1 → 2.5.0

data/lib/dm-paperclip/storage/s3/aws_library.rb

@@ -0,0 +1,41 @@
+module Paperclip
+  module Storage
+    module S3
+      # Mixin which interfaces with the 'aws' and 'right_aws' libraries.
+      module AwsLibrary
+        protected
+
+        def s3_connect!
+          @s3 = Aws::S3.new(
+            @s3_credentials[:access_key_id],
+            @s3_credentials[:secret_access_key]
+          )
+          @s3_bucket = @s3.bucket(bucket_name)
+        end
+
+        def s3_expiring_url(key,time)
+          @s3.interface.get_link(bucket_name,key,time)
+        end
+
+        def s3_exists?(key)
+          @s3_bucket.keys(:prefix => key).any? { |s3_key| s3_key.name == key }
+        end
+
+        def s3_download(key,file)
+          @s3_bucket.key(key).get { |chunk| file.write(chunk) }
+        end
+
+        def s3_store(key,file)
+          @s3_bucket.key(key).put(
+            file,
+            @s3_permissions.to_s.gsub('_','-')
+          )
+        end
+
+        def s3_delete(key)
+          @s3_bucket.key(key).delete
+        end
+      end
+    end
+  end
+end

data/lib/dm-paperclip/storage/s3/aws_s3_library.rb

@@ -0,0 +1,60 @@
+module Paperclip
+  module Storage
+    module S3
+      # Mixin which interfaces with the 'aws-s3' library.
+      module AwsS3Library
+        protected
+
+        def s3_connect!
+          AWS::S3::Base.establish_connection!(@s3_options.merge(
+            :access_key_id => @s3_credentials[:access_key_id],
+            :secret_access_key => @s3_credentials[:secret_access_key]
+          ))
+        end
+
+        def s3_expiring_url(key,time)
+          AWS::S3::S3Object.url_for(key, bucket_name, :expires_in => time)
+        end
+
+        def s3_exists?(key)
+          AWS::S3::S3Object.exists?(key, bucket_name)
+        end
+
+        def s3_download(key,file)
+          file.write(AWS::S3::S3Object.value(key, bucket_name))
+        end
+
+        def s3_create_bucket
+          AWS::S3::Bucket.create(bucket_name)
+        end
+
+        def s3_store(key,file)
+          begin
+            AWS::S3::S3Object.store(
+              key,
+              file,
+              bucket_name,
+              {
+                :content_type => instance_read(:content_type),
+                :access => @s3_permissions,
+              }.merge(@s3_headers)
+            )
+          rescue AWS::S3::NoSuchBucket => e
+            s3_create_bucket
+            retry
+          rescue AWS::S3::ResponseError => e
+            raise
+          end
+        end
+
+        def s3_delete(key)
+          begin
+            AWS::S3::S3Object.delete(key, bucket_name)
+          rescue AWS::S3::ResponseError
+            # Ignore this.
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dm-paperclip/style.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+module Paperclip
+  # The Style class holds the definition of a thumbnail style,  applying
+  # whatever processing is required to normalize the definition and delaying
+  # the evaluation of block parameters until useful context is available.
+
+  class Style
+
+    attr_reader :name, :attachment, :format
+
+    # Creates a Style object. +name+ is the name of the attachment,
+    # +definition+ is the style definition from has_attached_file, which
+    # can be string, array or hash
+    def initialize name, definition, attachment
+      @name = name
+      @attachment = attachment
+      if definition.is_a? Hash
+        @geometry = definition.delete(:geometry)
+        @format = definition.delete(:format)
+        @processors = definition.delete(:processors)
+        @other_args = definition
+      else
+        @geometry, @format = [definition, nil].flatten[0..1]
+        @other_args = {}
+      end
+      @format  = nil if Paperclip::Ext.blank?(@format)
+    end
+
+    # retrieves from the attachment the processors defined in the has_attached_file call
+    # (which method (in the attachment) will call any supplied procs)
+    # There is an important change of interface here: a style rule can set its own processors
+    # by default we behave as before, though.
+    def processors
+      @processors || attachment.processors
+    end
+
+    # retrieves from the attachment the whiny setting
+    def whiny
+      attachment.whiny
+    end
+
+    # returns true if we're inclined to grumble
+    def whiny?
+      !!whiny
+    end
+
+    def convert_options
+      attachment.send(:extra_options_for, name)
+    end
+
+    # returns the geometry string for this style
+    # if a proc has been supplied, we call it here
+    def geometry
+      @geometry.respond_to?(:call) ? @geometry.call(attachment.instance) : @geometry
+    end
+
+    # Supplies the hash of options that processors expect to receive as their second argument
+    # Arguments other than the standard geometry, format etc are just passed through from
+    # initialization and any procs are called here, just before post-processing.
+    def processor_options
+      args = {}
+      @other_args.each do |k,v|
+        args[k] = v.respond_to?(:call) ? v.call(attachment) : v
+      end
+      [:processors, :geometry, :format, :whiny, :convert_options].each do |k|
+        (arg = send(k)) && args[k] = arg
+      end
+      args
+    end
+
+    # Supports getting and setting style properties with hash notation to ensure backwards-compatibility
+    # eg. @attachment.styles[:large][:geometry]@ will still work
+    def [](key)
+      if [:name, :convert_options, :whiny, :processors, :geometry, :format].include?(key)
+        send(key)
+      elsif defined? @other_args[key]
+        @other_args[key]
+      end
+    end
+
+    def []=(key, value)
+      if [:name, :convert_options, :whiny, :processors, :geometry, :format].include?(key)
+        send("#{key}=".intern, value)
+      else
+        @other_args[key] = value
+      end
+    end
+
+  end
+end

data/lib/dm-paperclip/thumbnail.rb

@@ -2,7 +2,7 @@ module Paperclip
   # Handles thumbnailing images that are uploaded.
   class Thumbnail < Processor
 
-    attr_accessor :current_geometry, :target_geometry, :format, :whiny, :convert_options
+    attr_accessor :current_geometry, :target_geometry, :format, :whiny, :convert_options, :source_file_options
 
     # Creates a Thumbnail object set to work on the +file+ given. It
     # will attempt to transform the image into one defined by +target_geometry+
@@ -12,17 +12,23 @@ module Paperclip
     # set, the options will be appended to the convert command upon image conversion
     def initialize file, options = {}, attachment = nil
       super
-      geometry          = options[:geometry]
-      @file             = file
-      @crop             = geometry[-1,1] == '#'
-      @target_geometry  = Geometry.parse geometry
-      @current_geometry = Geometry.from_file @file
-      @convert_options  = options[:convert_options]
-      @whiny            = options[:whiny].nil? ? true : options[:whiny]
-      @format           = options[:format]
 
-      @current_format   = File.extname(@file.path)
-      @basename         = File.basename(@file.path, @current_format)
+      geometry             = options[:geometry]
+      @file                = file
+      @crop                = geometry[-1,1] == '#'
+      @target_geometry     = Geometry.parse geometry
+      @current_geometry    = Geometry.from_file @file
+      @source_file_options = options[:source_file_options]
+      @convert_options     = options[:convert_options]
+      @whiny               = options[:whiny].nil? ? true : options[:whiny]
+      @format              = options[:format]
+
+      @source_file_options = @source_file_options.split(/\s+/) if @source_file_options.respond_to?(:split)
+      @convert_options     = @convert_options.split(/\s+/)     if @convert_options.respond_to?(:split)
+
+      @current_format      = File.extname(@file.path)
+      @basename            = File.basename(@file.path, @current_format)
+
     end
 
     # Returns true if the +target_geometry+ is meant to crop.
@@ -32,25 +38,28 @@ module Paperclip
 
     # Returns true if the image is meant to make use of additional convert options.
     def convert_options?
-      not @convert_options.blank?
+      !@convert_options.nil? && !@convert_options.empty?
     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 = Tempfile.new([@basename, @format ? ".#{@format}" : ''])
       dst.binmode
 
-      command = <<-end_command
-        "#{ File.expand_path(src.path) }[0]"
-        #{ transformation_command }
-        "#{ File.expand_path(dst.path) }"
-      end_command
-
       begin
-        success = Paperclip.run("convert", command.gsub(/\s+/, " "))
-      rescue PaperclipCommandLineError
+        parameters = []
+        parameters << source_file_options
+        parameters << ":source"
+        parameters << transformation_command
+        parameters << convert_options
+        parameters << ":dest"
+
+        parameters = parameters.flatten.compact.join(" ").strip.squeeze(" ")
+
+        success = Paperclip.run("convert", parameters, :source => "#{File.expand_path(src.path)}[0]", :dest => File.expand_path(dst.path))
+      rescue PaperclipCommandLineError => e
         raise PaperclipError, "There was an error processing the thumbnail for #{@basename}" if @whiny
       end
 
@@ -61,9 +70,9 @@ module Paperclip
     # into the thumbnail.
     def transformation_command
       scale, crop = @current_geometry.transformation_to(@target_geometry, crop?)
-      trans = "-resize \"#{scale}\""
-      trans << " -crop \"#{crop}\" +repage" if crop
-      trans << " #{convert_options}" if convert_options?
+      trans = []
+      trans << "-resize" << %["#{scale}"] unless scale.nil? || scale.empty?
+      trans << "-crop" << %["#{crop}"] << "+repage" if crop
       trans
     end
   end

data/lib/dm-paperclip/upfile.rb

@@ -8,13 +8,18 @@ module Paperclip
     def content_type
       type = (self.path.match(/\.(\w+)$/)[1] rescue "octet-stream").downcase
       case type
-      when %r"jpe?g"                 then "image/jpeg"
+      when %r"jp(e|g|eg)"            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}"
+      when "js"                      then "application/js"
+      when "csv", "xml", "css"       then "text/#{type}"
+      else
+        # On BSDs, `file` doesn't give a result code of 1 if the file doesn't exist.
+        content_type = (Paperclip.run("file", "-b --mime-type :file", :file => self.path).split(':').last.strip rescue "application/x-#{type}")
+        content_type = "application/x-#{type}" if content_type.match(/\(.*?\)/)
+        content_type
       end
     end
 
@@ -32,16 +37,19 @@ end
 
 if defined? StringIO
   class StringIO
-    attr_accessor :original_filename, :content_type
+    attr_accessor :original_filename, :content_type, :fingerprint
     def original_filename
       @original_filename ||= "stringio.txt"
     end
     def content_type
       @content_type ||= "text/plain"
     end
+    def fingerprint
+      @fingerprint ||= Digest::MD5.hexdigest(self.string)
+    end
   end
 end
 
 class File #:nodoc:
   include Paperclip::Upfile
-end
+end

data/lib/dm-paperclip/validations.rb

@@ -10,8 +10,7 @@ module Paperclip
       # * +greater_than+: equivalent to :in => options[:greater_than]..Infinity
       # * +message+: error message to display, use :min and :max as replacements
       def validates_attachment_size(*fields)
-        opts = opts_from_validator_args(fields)
-        add_validator_to_context(opts, fields, Paperclip::Validate::SizeValidator)
+        validators.add(Paperclip::Validate::SizeValidator, *fields)
       end
 
       # Adds errors if thumbnail creation fails. The same as specifying :whiny_thumbnails => true.
@@ -21,8 +20,7 @@ module Paperclip
 
       # Places ActiveRecord-style validations on the presence of a file.
       def validates_attachment_presence(*fields)
-        opts = opts_from_validator_args(fields)
-        add_validator_to_context(opts, fields, Paperclip::Validate::RequiredFieldValidator)
+        validators.add(Paperclip::Validate::RequiredFieldValidator, *fields)
       end
 
       # Places ActiveRecord-style validations on the content type of the file assigned. The
@@ -30,45 +28,41 @@ module Paperclip
       # * +content_type+: Allowed content types.  Can be a single content type or an array.  Allows all by default.
       # * +message+: The message to display when the uploaded file has an invalid content type.
       def validates_attachment_content_type(*fields)
-        opts = opts_from_validator_args(fields)
-        add_validator_to_context(opts, fields, Paperclip::Validate::ContentTypeValidator)
+        validators.add(Paperclip::Validate::ContentTypeValidator, *fields)
       end
 
+      # Places ActiveRecord-style validations on the geometry of the file assigned. The
+      # required options are:
+      # * +height+: a Range of pixels (i.e. 100..300+),
+      # * +width+: a Range of pixels (i.e. 100..300+)
+      def validates_attachment_geometry(*fields)
+        validators.add(Paperclip::Validate::GeometryValidator, *fields)
+      end
     end
 
     class SizeValidator < DataMapper::Validate::GenericValidator #:nodoc:
-      def initialize(field_name, options={})
-        super
-        @field_name, @options = field_name, options
-      end
-
       def call(target)
         field_value = target.validation_property_value(:"#{@field_name}_file_size")
         return true if field_value.nil?
 
-        @options[:in] = (@options[:greater_than]..(1/0)) unless @options[:greater_than].nil?
+        @options[:in] = (@options[:greater_than]..(1.0/0)) unless @options[:greater_than].nil?
         @options[:in] = (0..@options[:less_than])        unless @options[:less_than].nil?
         return true if @options[:in].include? field_value.to_i
 
         error_message ||= @options[:message] unless @options[:message].nil?
-        error_message ||= "%s must be less than %s bytes".t(Extlib::Inflection.humanize(@field_name), @options[:less_than]) unless @options[:less_than].nil?
-        error_message ||= "%s must be greater than %s bytes".t(Extlib::Inflection.humanize(@field_name), @options[:greater_than]) unless @options[:greater_than].nil?
-        error_message ||= "%s must be between %s and %s bytes".t(Extlib::Inflection.humanize(@field_name), @options[:in].first, @options[:in].last)
+        error_message ||= sprintf("%s must be less than %s bytes",DataMapper::Inflector.humanize(@field_name), @options[:less_than]) unless @options[:less_than].nil?
+        error_message ||= sprintf("%s must be greater than %s bytes",DataMapper::Inflector.humanize(@field_name), @options[:greater_than]) unless @options[:greater_than].nil?
+        error_message ||= sprintf("%s must be between %s and %s bytes",DataMapper::Inflector.humanize(@field_name), @options[:in].first, @options[:in].last)
         add_error(target, error_message , @field_name)
         return false
       end
     end
 
     class RequiredFieldValidator < DataMapper::Validate::GenericValidator #:nodoc:
-      def initialize(field_name, options={})
-        super
-        @field_name, @options = field_name, options
-      end
-
       def call(target)
         field_value = target.validation_property_value(@field_name)
-        if field_value.nil? || field_value.original_filename.blank?
-          error_message = @options[:message] || "%s must be set".t(Extlib::Inflection.humanize(@field_name))
+        if field_value.nil? || Paperclip::Ext.blank?(field_value.original_filename)
+          error_message = @options[:message] || sprintf("%s must be set",DataMapper::Inflector.humanize(@field_name))
           add_error(target, error_message , @field_name)
           return false
         end
@@ -77,21 +71,16 @@ module Paperclip
     end
 
     class ContentTypeValidator < DataMapper::Validate::GenericValidator #:nodoc:
-      def initialize(field_name, options={})
-        super
-        @field_name, @options = field_name, options
-      end
-
       def call(target)
         valid_types = [@options[:content_type]].flatten
         field_value = target.validation_property_value(@field_name)
 
-        unless field_value.nil? || field_value.original_filename.blank?
-          unless @options[:content_type].blank?
+        unless field_value.nil? || Paperclip::Ext.blank?(field_value.original_filename)
+          unless Paperclip::Ext.blank?(@options[:content_type])
             content_type = target.validation_property_value(:"#{@field_name}_content_type")
             unless valid_types.any?{|t| t === content_type }
               error_message ||= @options[:message] unless @options[:message].nil?
-              error_message ||= "%s's content type of '%s' is not a valid content type".t(Extlib::Inflection.humanize(@field_name), content_type)
+              error_message ||= sprintf("%s's content type of '%s' is not a valid content type",DataMapper::Inflector.humanize(@field_name), content_type)
               add_error(target, error_message , @field_name)
               return false
             end
@@ -103,22 +92,36 @@ module Paperclip
     end
 
     class CopyAttachmentErrors < DataMapper::Validate::GenericValidator #:nodoc:
-      def initialize(field_name, options={})
-        super
-        @field_name, @options = field_name, options
-      end
-
       def call(target)
         field_value = target.validation_property_value(@field_name)
-        unless field_value.nil? || field_value.original_filename.blank?
+        unless field_value.nil? || Paperclip::Ext.blank?(field_value.original_filename)
           return true if field_value.errors.length == 0
-          field_value.errors.each { |message| add_error(target, message, @field_name) }
+          field_value.errors.each do |error, message|
+            [message].flatten.each { |m| add_error(target, m, @field_name) }
+          end
           return false
         end
         return true
       end
     end
 
+    class GeometryValidator < DataMapper::Validate::GenericValidator #:nodoc:
+      def call(target)
+        field_value = target.validation_property_value(@field_name)
+        return true if field_value.queued_for_write[:original].nil?
+
+        geometry = Paperclip::Geometry.from_file(field_value.queued_for_write[:original].path)
+        
+        return true if @options[:width].include?(geometry.width) && @options[:height].include?(geometry.height)
+
+        error_message ||= sprintf("%s width must be between %s and %s px", DataMapper::Inflector.humanize(@field_name), @options[:width].begin, @options[:width].end) unless @options[:width].include?(geometry.width)
+        error_message ||= sprintf("%s height must be between %s and %s px", DataMapper::Inflector.humanize(@field_name), @options[:height].begin, @options[:height].end) unless@options[:height].include?(geometry.height)
+
+        add_error(target, error_message , @field_name)
+        return false
+      end
+    end
+
   end
 end