paperclip 2.8.0 → 3.0.2

data/lib/paperclip/railtie.rb

@@ -2,34 +2,29 @@ require 'paperclip'
 require 'paperclip/schema'
 
 module Paperclip
-  if defined? Rails::Railtie
-    require 'rails'
-    class Railtie < Rails::Railtie
-      initializer 'paperclip.insert_into_active_record' do
-        ActiveSupport.on_load :active_record do
-          Paperclip::Railtie.insert
-        end
-      end
-      rake_tasks do
-        load "tasks/paperclip.rake"
+  require 'rails'
+  class Railtie < Rails::Railtie
+    initializer 'paperclip.insert_into_active_record' do
+      ActiveSupport.on_load :active_record do
+        Paperclip::Railtie.insert
       end
     end
+    rake_tasks do
+      load "tasks/paperclip.rake"
+    end
   end
 
   class Railtie
     def self.insert
       Paperclip.options[:logger] = Rails.logger if defined?(Rails)
-      
+
       if defined?(ActiveRecord)
-        ActiveRecord::Base.send(:include, Paperclip::Glue)
         Paperclip.options[:logger] = ActiveRecord::Base.logger
-
+        ActiveRecord::Base.send(:include, Paperclip::Glue)
         ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, Paperclip::Schema)
         ActiveRecord::ConnectionAdapters::Table.send(:include, Paperclip::Schema)
         ActiveRecord::ConnectionAdapters::TableDefinition.send(:include, Paperclip::Schema)
       end
-
-      File.send(:include, Paperclip::Upfile)
     end
   end
 end

data/lib/paperclip/storage/filesystem.rb

@@ -27,23 +27,14 @@ module Paperclip
         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_name = default_style
-        if @queued_for_write[style_name]
-          @queued_for_write[style_name].rewind
-          @queued_for_write[style_name]
-        elsif exists?(style_name)
-          File.new(path(style_name), 'rb')
-        end
-      end
-
       def flush_writes #:nodoc:
         @queued_for_write.each do |style_name, file|
-          file.close
           FileUtils.mkdir_p(File.dirname(path(style_name)))
-          log("saving #{path(style_name)}")
-          FileUtils.cp(file.path, path(style_name))
+          File.open(path(style_name), "wb") do |new_file|
+            while chunk = file.read(16 * 1024)
+              new_file.write(chunk)
+            end
+          end
           FileUtils.chmod(0666&~File.umask, path(style_name))
         end
 

data/lib/paperclip/storage/fog.rb

@@ -83,7 +83,7 @@ module Paperclip
               :body         => file,
               :key          => path(style),
               :public       => fog_public,
-              :content_type => file.content_type.to_s.strip
+              :content_type => file.content_type
             ))
           rescue Excon::Errors::NotFound
             raise if retried
@@ -106,25 +106,6 @@ module Paperclip
         @queued_for_delete = []
       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)
-        if @queued_for_write[style]
-          @queued_for_write[style].rewind
-          @queued_for_write[style]
-        else
-          body      = directory.files.get(path(style)).body
-          filename  = path(style)
-          extname   = File.extname(filename)
-          basename  = File.basename(filename, extname)
-          file      = Tempfile.new([basename, extname])
-          file.binmode
-          file.write(body)
-          file.rewind
-          file
-        end
-      end
-
       def public_url(style = default_style)
         if @options[:fog_host]
           host = if @options[:fog_host].respond_to?(:call)
@@ -132,7 +113,7 @@ module Paperclip
           else
             (@options[:fog_host] =~ /%d/) ? @options[:fog_host] % (path(style).hash % 4) : @options[:fog_host]
           end
-          
+
           "#{host}/#{path(style)}"
         else
           if fog_credentials[:provider] == 'AWS'

data/lib/paperclip/storage/s3.rb

@@ -95,7 +95,7 @@ module Paperclip
           @s3_permissions = set_permissions(@options[:s3_permissions])
           @s3_protocol    = @options[:s3_protocol]    ||
             Proc.new do |style, attachment|
-              permission  = (@s3_permissions[style.to_sym] || @s3_permissions[:default])
+              permission  = (@s3_permissions[style.to_s.to_sym] || @s3_permissions[:default])
               permission  = permission.call(attachment, style) if permission.is_a?(Proc)
               (permission == :public_read) ? 'http' : 'https'
             end
@@ -141,7 +141,8 @@ module Paperclip
 
       def expiring_url(time = 3600, style_name = default_style)
         if path
-          s3_object(style_name).url_for(:read, :expires => time, :secure => use_secure_protocol?(style_name)).to_s
+          base_options = { :expires => time, :secure => use_secure_protocol?(style_name) }
+          s3_object(style_name).url_for(:read, base_options.merge(s3_url_options)).to_s
         end
       end
 
@@ -159,6 +160,12 @@ module Paperclip
         @s3_host_alias
       end
 
+      def s3_url_options
+        s3_url_options = @options[:s3_url_options] || {}
+        s3_url_options = s3_url_options.call(instance) if s3_url_options.is_a?(Proc)
+        s3_url_options
+      end
+
       def bucket_name
         @bucket = @options[:bucket] || s3_credentials[:bucket]
         @bucket = @bucket.call(self) if @bucket.is_a?(Proc)
@@ -227,6 +234,7 @@ module Paperclip
       end
 
       def parse_credentials creds
+        creds = creds.respond_to?('call') ? creds.call(self) : creds
         creds = find_credentials(creds).stringify_keys
         env = Object.const_defined?(:Rails) ? Rails.env : nil
         (creds[env] || creds).symbolize_keys
@@ -256,23 +264,6 @@ module Paperclip
         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
-        if @queued_for_write[style]
-          @queued_for_write[style].rewind
-          return @queued_for_write[style]
-        end
-        filename = path(style)
-        extname  = File.extname(filename)
-        basename = File.basename(filename, extname)
-        file = Tempfile.new([basename, extname])
-        file.binmode
-        file.write(s3_object(style).read)
-        file.rewind
-        return file
-      end
-
       def create_bucket
         s3_interface.buckets.create(bucket_name)
       end
@@ -284,7 +275,7 @@ module Paperclip
             acl = @s3_permissions[style] || @s3_permissions[:default]
             acl = acl.call(self, style) if acl.respond_to?(:call)
             write_options = {
-              :content_type => file.content_type.to_s.strip,
+              :content_type => file.content_type,
               :acl => acl
             }
             write_options[:metadata] = @s3_metadata unless @s3_metadata.empty?
@@ -325,19 +316,11 @@ module Paperclip
         when Hash
           creds
         else
-          raise ArgumentError, "Credentials are not a path, file, or hash."
+          raise ArgumentError, "Credentials are not a path, file, proc, or hash."
         end
       end
       private :find_credentials
 
-      def establish_connection!
-        @connection ||= 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
-      private :establish_connection!
-
       def use_secure_protocol?(style_name)
         s3_protocol(style_name) == "https"
       end

data/lib/paperclip/tempfile.rb

@@ -0,0 +1,41 @@
+module Paperclip
+  # Overriding some implementation of Tempfile
+  class Tempfile < ::Tempfile
+    # 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
+    #
+    # This is Ruby 1.8.7's implementation.
+    def make_tmpname(basename, n)
+      if RUBY_PLATFORM =~ /java/
+        case basename
+        when Array
+          prefix, suffix = *basename
+        else
+          prefix, suffix = basename, ''
+        end
+
+        t = Time.now.strftime("%y%m%d")
+        path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}-#{n}#{suffix}"
+      else
+        super
+      end
+    end
+  end
+
+  module TempfileEncoding
+    # This overrides Tempfile#binmode to make sure that the extenal encoding
+    # for binary mode is ASCII-8BIT. This behavior is what's in CRuby, but not
+    # in JRuby
+    def binmode
+      set_encoding('ASCII-8BIT')
+      super
+    end
+  end
+end
+
+if RUBY_PLATFORM =~ /java/
+  ::Tempfile.send :include, Paperclip::TempfileEncoding
+end

data/lib/paperclip/thumbnail.rb

@@ -44,7 +44,6 @@ module Paperclip
 
       @current_format      = File.extname(@file.path)
       @basename            = File.basename(@file.path, @current_format)
-
     end
 
     # Returns true if the +target_geometry+ is meant to crop.
@@ -76,9 +75,9 @@ module Paperclip
 
         success = Paperclip.run("convert", parameters, :source => "#{File.expand_path(src.path)}#{'[0]' unless animated?}", :dest => File.expand_path(dst.path))
       rescue Cocaine::ExitStatusError => e
-        raise PaperclipError, "There was an error processing the thumbnail for #{@basename}" if @whiny
+        raise Paperclip::Error, "There was an error processing the thumbnail for #{@basename}" if @whiny
       rescue Cocaine::CommandNotFoundError => e
-        raise Paperclip::CommandNotFoundError.new("Could not run the `convert` command. Please install ImageMagick.")
+        raise Paperclip::Errors::CommandNotFoundError.new("Could not run the `convert` command. Please install ImageMagick.")
       end
 
       dst

data/lib/paperclip/validators.rb

@@ -0,0 +1,45 @@
+require 'active_support/concern'
+require 'paperclip/validators/attachment_content_type_validator'
+require 'paperclip/validators/attachment_presence_validator'
+require 'paperclip/validators/attachment_size_validator'
+
+module Paperclip
+  module Validators
+    extend ActiveSupport::Concern
+
+    included do
+      extend  HelperMethods
+      include HelperMethods
+    end
+
+    module ClassMethods
+      # This method is a shortcut to validator classes that is in
+      # "Attachment...Validator" format. It is almost the same thing as the
+      # +validates+ method that shipped with Rails, but this is customized to
+      # be using with attachment validators. This is helpful when you're using
+      # multiple attachment validators on a single attachment.
+      #
+      # Example of using the validator:
+      #
+      #   validates_attachment :avatar, :presence => true,
+      #      :content_type => { :content_type => "image/jpg" },
+      #      :size => { :in => 0..10.kilobytes }
+      #
+      def validates_attachment(*attributes)
+        options = attributes.extract_options!.dup
+
+        Paperclip::Validators.constants.each do |constant|
+          if constant.to_s =~ /^Attachment(.+)Validator$/
+            validator_kind = $1.underscore.to_sym
+
+            if options.has_key?(validator_kind)
+              options[:"attachment_#{validator_kind}"] = options.delete(validator_kind)
+            end
+          end
+        end
+
+        validates(*attributes + [options])
+      end
+    end
+  end
+end

data/lib/paperclip/validators/attachment_content_type_validator.rb

@@ -0,0 +1,47 @@
+module Paperclip
+  module Validators
+    class AttachmentContentTypeValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        attribute = "#{attribute}_content_type".to_sym
+        value = record.send(:read_attribute_for_validation, attribute)
+        allowed_types = [options[:content_type]].flatten
+
+        if value.present? && allowed_types.none? { |type| type === value }
+          record.errors.add(attribute, :invalid, options.merge(
+            :types => allowed_types.join(', ')
+          ))
+        end
+      end
+
+      def check_validity!
+        unless options.has_key?(:content_type)
+          raise ArgumentError, "You must pass in :content_type to the validator"
+        end
+      end
+    end
+
+    module HelperMethods
+      # 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.
+      # * +if+: A lambda or name of an instance method. 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.
+      # You'll still need to have a virtual attribute (created by +attr_accessor+)
+      # name +[attachment]_content_type+ to be able to use this validator.
+      def validates_attachment_content_type(*attr_names)
+        validates_with AttachmentContentTypeValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/paperclip/validators/attachment_presence_validator.rb

@@ -0,0 +1,26 @@
+require 'active_model/validations/presence'
+
+module Paperclip
+  module Validators
+    class AttachmentPresenceValidator < ActiveModel::Validations::PresenceValidator
+      def validate(record)
+        [attributes].flatten.map do |attribute|
+          if record.send(:read_attribute_for_validation, "#{attribute}_file_name").blank?
+            record.errors.add(attribute, :blank, options)
+          end
+        end
+      end
+    end
+
+    module HelperMethods
+      # Places ActiveRecord-style validations on the presence of a file.
+      # Options:
+      # * +if+: A lambda or name of an instance method. Validation will only
+      #   be run if this lambda or method returns true.
+      # * +unless+: Same as +if+ but validates if lambda or method returns false.
+      def validates_attachment_presence(*attr_names)
+        validates_with AttachmentPresenceValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/paperclip/validators/attachment_size_validator.rb

@@ -0,0 +1,102 @@
+require 'active_model/validations/numericality'
+
+module Paperclip
+  module Validators
+    class AttachmentSizeValidator < ActiveModel::Validations::NumericalityValidator
+      AVAILABLE_CHECKS = [:less_than, :less_than_or_equal_to, :greater_than, :greater_than_or_equal_to]
+
+      def initialize(options)
+        extract_options(options)
+        super
+      end
+
+      def validate_each(record, attr_name, value)
+        attr_name = "#{attr_name}_file_size".to_sym
+        value = record.send(:read_attribute_for_validation, attr_name)
+
+        unless value.blank?
+          options.slice(*AVAILABLE_CHECKS).each do |option, option_value|
+            option_value = option_value.call(record) if option_value.is_a?(Proc)
+            option_value = extract_option_value(option, option_value)
+
+            unless value.send(CHECKS[option], option_value)
+              error_message_key = options[:in] ? :in_between : option
+              record.errors.add(attr_name, error_message_key, filtered_options(value).merge(
+                :min => min_value_in_human_size(record),
+                :max => max_value_in_human_size(record),
+                :count => human_size(option_value)
+              ))
+            end
+          end
+        end
+      end
+
+      def check_validity!
+        unless (AVAILABLE_CHECKS + [:in]).any? { |argument| options.has_key?(argument) }
+          raise ArgumentError, "You must pass either :less_than, :greater_than, or :in to the validator"
+        end
+      end
+
+      private
+
+      def extract_options(options)
+        if range = options[:in]
+          if !options[:in].respond_to?(:call)
+            options[:less_than_or_equal_to] = range.max
+            options[:greater_than_or_equal_to] = range.min
+          else
+            options[:less_than_or_equal_to] = range
+            options[:greater_than_or_equal_to] = range
+          end
+        end
+      end
+
+      def extract_option_value(option, option_value)
+        if option_value.is_a?(Range)
+          if [:less_than, :less_than_or_equal_to].include?(option)
+            option_value.max
+          else
+            option_value.min
+          end
+        else
+          option_value
+        end
+      end
+
+      def human_size(size)
+        storage_units_format = I18n.translate(:'number.human.storage_units.format', :locale => options[:locale], :raise => true)
+        unit = I18n.translate(:'number.human.storage_units.units.byte', :locale => options[:locale], :count => size.to_i, :raise => true)
+        storage_units_format.gsub(/%n/, size.to_i.to_s).gsub(/%u/, unit).html_safe
+      end
+
+      def min_value_in_human_size(record)
+        value = options[:greater_than_or_equal_to] || options[:greater_than]
+        value = value.call(record) if value.respond_to?(:call)
+        value = value.min if value.respond_to?(:min)
+        human_size(value)
+      end
+
+      def max_value_in_human_size(record)
+        value = options[:less_than_or_equal_to] || options[:less_than]
+        value = value.call(record) if value.respond_to?(:call)
+        value = value.max if value.respond_to?(:max)
+        human_size(value)
+      end
+    end
+
+    module HelperMethods
+      # 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 an instance method. Validation will only
+      #   be run if this lambda or method returns true.
+      # * +unless+: Same as +if+ but validates if lambda or method returns false.
+      def validates_attachment_size(*attr_names)
+        validates_with AttachmentSizeValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end