paperclip 3.5.4 → 6.1.0

data/lib/paperclip/callbacks.rb

@@ -7,7 +7,7 @@ module Paperclip
 
     module Defining
       def define_paperclip_callbacks(*callbacks)
-        define_callbacks *[callbacks, {:terminator => "result == false"}].flatten
+        define_callbacks(*[callbacks, { terminator: hasta_la_vista_baby }].flatten)
         callbacks.each do |callback|
           eval <<-end_callbacks
             def before_#{callback}(*args, &blk)
@@ -19,6 +19,18 @@ module Paperclip
           end_callbacks
         end
       end
+
+      private
+
+      def hasta_la_vista_baby
+        lambda do |_, result|
+          if result.respond_to?(:call)
+            result.call == false
+          else
+            result == false
+          end
+        end
+      end
     end
 
     module Running

data/lib/paperclip/content_type_detector.rb

@@ -2,7 +2,7 @@ module Paperclip
   class ContentTypeDetector
     # The content-type detection strategy is as follows:
     #
-    # 1. Blank/Empty files: If there's no filename or the file is empty,
+    # 1. Blank/Empty files: If there's no filepath or the file is empty,
     #    provide a sensible default (application/octet-stream or inode/x-empty)
     #
     # 2. Calculated match: Return the first result that is found by both the
@@ -20,8 +20,8 @@ module Paperclip
     EMPTY_TYPE = "inode/x-empty"
     SENSIBLE_DEFAULT = "application/octet-stream"
 
-    def initialize(filename)
-      @filename = filename
+    def initialize(filepath)
+      @filepath = filepath
     end
 
     # Returns a String describing the file's content type
@@ -32,45 +32,49 @@ module Paperclip
         EMPTY_TYPE
       elsif calculated_type_matches.any?
         calculated_type_matches.first
-      elsif official_type_matches.any?
-        official_type_matches.first
-      elsif unofficial_type_matches.any?
-        unofficial_type_matches.first
       else
-        type_from_file_command || SENSIBLE_DEFAULT
+        type_from_file_contents || SENSIBLE_DEFAULT
       end.to_s
     end
 
     private
 
+    def blank_name?
+      @filepath.nil? || @filepath.empty?
+    end
+
     def empty_file?
-      File.exists?(@filename) && File.size(@filename) == 0
+      File.exist?(@filepath) && File.size(@filepath) == 0
     end
-    
+
     alias :empty? :empty_file?
 
-    def blank_name?
-      @filename.nil? || @filename.empty?
+    def calculated_type_matches
+      possible_types.select do |content_type|
+        content_type == type_from_file_contents
+      end
     end
 
     def possible_types
-      MIME::Types.type_for(@filename).collect(&:content_type)
-    end
-
-    def calculated_type_matches
-      possible_types.select{|content_type| content_type == type_from_file_command }
+      MIME::Types.type_for(@filepath).collect(&:content_type)
     end
 
-    def official_type_matches
-      possible_types.reject{|content_type| content_type.match(/\/x-/) }
+    def type_from_file_contents
+      type_from_mime_magic || type_from_file_command
+    rescue Errno::ENOENT => e
+      Paperclip.log("Error while determining content type: #{e}")
+      SENSIBLE_DEFAULT
     end
 
-    def unofficial_type_matches
-      possible_types.select{|content_type| content_type.match(/\/x-/) }
+    def type_from_mime_magic
+      @type_from_mime_magic ||= File.open(@filepath) do |file|
+        MimeMagic.by_magic(file).try(:type)
+      end
     end
 
     def type_from_file_command
-      @type_from_file_command ||= FileCommandContentTypeDetector.new(@filename).detect
+      @type_from_file_command ||=
+        FileCommandContentTypeDetector.new(@filepath).detect
     end
   end
 end

data/lib/paperclip/errors.rb

@@ -13,8 +13,15 @@ module Paperclip
     class CommandNotFoundError < Paperclip::Error
     end
 
+    # Attachments require a content_type or file_name validator,
+    # or to have explicitly opted out of them.
+    class MissingRequiredValidatorError < Paperclip::Error
+    end
+
     # Will be thrown when ImageMagic cannot determine the uploaded file's
-    # metadata, usually this would mean the file is not an image.
+    # metadata, usually this would mean the file is not an image. If you are
+    # consistently receiving this error on PDFs make sure that you have
+    # installed Ghostscript.
     class NotIdentifiedByImageMagickError < Paperclip::Error
     end
 

data/lib/paperclip/file_command_content_type_detector.rb

@@ -13,20 +13,18 @@ module Paperclip
     private
 
     def type_from_file_command
+      # On BSDs, `file` doesn't give a result code of 1 if the file doesn't exist.
       type = begin
-        # On BSDs, `file` doesn't give a result code of 1 if the file doesn't exist.
-        Paperclip.run("file", "-b --mime :file", :file => @filename)
-      rescue Cocaine::CommandLineError => e
-        Paperclip.log("Error while determining content type: #{e}")
-        SENSIBLE_DEFAULT
-      end
+               Paperclip.run("file", "-b --mime :file", file: @filename)
+             rescue Terrapin::CommandLineError => e
+               Paperclip.log("Error while determining content type: #{e}")
+               SENSIBLE_DEFAULT
+             end
 
       if type.nil? || type.match(/\(.*?\)/)
         type = SENSIBLE_DEFAULT
       end
       type.split(/[:;\s]+/)[0]
     end
-
   end
 end
-

data/lib/paperclip/filename_cleaner.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 module Paperclip
   class FilenameCleaner
     def initialize(invalid_character_regex)

data/lib/paperclip/geometry_detector_factory.rb

@@ -14,17 +14,19 @@ module Paperclip
 
     def geometry_string
       begin
+        orientation = Paperclip.options[:use_exif_orientation] ?
+          "%[exif:orientation]" : "1"
         Paperclip.run(
-          "identify",
-          "-format '%wx%h,%[exif:orientation]' :file", {
+          Paperclip.options[:is_windows] ? "magick identify" : "identify",
+          "-format '%wx%h,#{orientation}' :file", {
             :file => "#{path}[0]"
           }, {
             :swallow_stderr => true
           }
         )
-      rescue Cocaine::ExitStatusError
+      rescue Terrapin::ExitStatusError
         ""
-      rescue Cocaine::CommandNotFoundError => e
+      rescue Terrapin::CommandNotFoundError => e
         raise_because_imagemagick_missing
       end
     end

data/lib/paperclip/geometry_parser_factory.rb

@@ -1,6 +1,6 @@
 module Paperclip
   class GeometryParser
-    FORMAT = /\b(\d*)x?(\d*)\b(?:,(\d?))?([\>\<\#\@\%^!])?/i
+    FORMAT = /\b(\d*)x?(\d*)\b(?:,(\d?))?(\@\>|\>\@|[\>\<\#\@\%^!])?/i
     def initialize(string)
       @string = string
     end

data/lib/paperclip/glue.rb

@@ -8,7 +8,7 @@ module Paperclip
       base.extend ClassMethods
       base.send :include, Callbacks
       base.send :include, Validators
-      base.send :include, Schema if defined? ActiveRecord
+      base.send :include, Schema if defined? ActiveRecord::Base
 
       locale_path = Dir.glob(File.dirname(__FILE__) + "/locales/*.{rb,yml}")
       I18n.load_path += locale_path unless I18n.load_path.include?(locale_path)

data/lib/paperclip/has_attached_file.rb

@@ -18,6 +18,7 @@ module Paperclip
       register_new_attachment
       add_active_record_callbacks
       add_paperclip_callbacks
+      add_required_validations
     end
 
     private
@@ -77,11 +78,26 @@ module Paperclip
       Paperclip::AttachmentRegistry.register(@klass, @name, @options)
     end
 
+    def add_required_validations
+      options = Paperclip::Attachment.default_options.deep_merge(@options)
+      if options[:validate_media_type] != false
+        name = @name
+        @klass.validates_media_type_spoof_detection name,
+          :if => ->(instance){ instance.send(name).dirty? }
+      end
+    end
+
     def add_active_record_callbacks
       name = @name
       @klass.send(:after_save) { send(name).send(:save) }
       @klass.send(:before_destroy) { send(name).send(:queue_all_for_delete) }
-      @klass.send(:after_commit, :on => :destroy) { send(name).send(:flush_deletes) }
+      if @klass.respond_to?(:after_commit)
+        @klass.send(:after_commit, on: :destroy) do
+          send(name).send(:flush_deletes)
+        end
+      else
+        @klass.send(:after_destroy) { send(name).send(:flush_deletes) }
+      end
     end
 
     def add_paperclip_callbacks

data/lib/paperclip/helpers.rb

@@ -8,27 +8,31 @@ module Paperclip
       Paperclip::Interpolations[key] = block
     end
 
-    # The run method takes the name of a binary to run, the arguments to that binary
-    # and some options:
+    # The run method takes the name of a binary to run, the arguments
+    # to that binary, the values to interpolate and some local options.
     #
-    #   :command_path -> A $PATH-like variable that defines where to look for the binary
-    #                    on the filesystem. Colon-separated, just like $PATH.
+    #  :cmd -> The name of a binary to run.
     #
-    #   :expected_outcodes -> An array of integers that defines the expected exit codes
-    #                         of the binary. Defaults to [0].
+    #  :arguments -> The command line arguments to that binary.
     #
-    #   :log_command -> Log the command being run when set to true (defaults to true).
-    #                   This will only log if logging in general is set to true as well.
+    #  :interpolation_values -> Values to be interpolated into the arguments.
     #
-    #   :swallow_stderr -> Set to true if you don't care what happens on STDERR.
+    #  :local_options -> The options to be used by Cocain::CommandLine.
+    #                    These could be: runner
+    #                                    logger
+    #                                    swallow_stderr
+    #                                    expected_outcodes
+    #                                    environment
+    #                                    runner_options
     #
     def run(cmd, arguments = "", interpolation_values = {}, local_options = {})
       command_path = options[:command_path]
-      Cocaine::CommandLine.path = [Cocaine::CommandLine.path, command_path].flatten.compact.uniq
+      terrapin_path_array = Terrapin::CommandLine.path.try(:split, Terrapin::OS.path_separator)
+      Terrapin::CommandLine.path = [terrapin_path_array, command_path].flatten.compact.uniq
       if logging? && (options[:log_command] || local_options[:log_command])
         local_options = local_options.merge(:logger => logger)
       end
-      Cocaine::CommandLine.new(cmd, arguments, local_options).run(interpolation_values)
+      Terrapin::CommandLine.new(cmd, arguments, local_options).run(interpolation_values)
     end
 
     # Find all instances of the given Active Record model +klass+ with attachment +name+.

data/lib/paperclip/interpolations/plural_cache.rb

@@ -2,15 +2,16 @@ module Paperclip
   module Interpolations
     class PluralCache
       def initialize
-        @cache = {}
+        @symbol_cache = {}.compare_by_identity
+        @klass_cache = {}.compare_by_identity
       end
 
-      def pluralize(word)
-        @cache[word] ||= word.pluralize
+      def pluralize_symbol(symbol)
+        @symbol_cache[symbol] ||= symbol.to_s.downcase.pluralize
       end
 
-      def underscore_and_pluralize(word)
-        @cache[word] ||= word.underscore.pluralize
+      def underscore_and_pluralize_class(klass)
+        @klass_cache[klass] ||= klass.name.underscore.pluralize
       end
     end
   end

data/lib/paperclip/interpolations.rb

@@ -5,11 +5,13 @@ module Paperclip
   # Paperclip.interpolates method.
   module Interpolations
     extend self
+    ID_PARTITION_LIMIT = 1_000_000_000
 
     # Hash assignment of interpolations. Included only for compatibility,
     # and is not intended for normal use.
     def self.[]= name, block
       define_method(name, &block)
+      @interpolators_cache = nil
     end
 
     # Hash access of interpolations. Included only for compatibility,
@@ -20,7 +22,7 @@ module Paperclip
 
     # Returns a sorted list of all interpolations.
     def self.all
-      self.instance_methods(false).sort
+      self.instance_methods(false).sort!
     end
 
     # Perform the actual interpolation. Takes the pattern to interpolate
@@ -29,11 +31,15 @@ module Paperclip
     # an interpolation pattern for Paperclip to use.
     def self.interpolate pattern, *args
       pattern = args.first.instance.send(pattern) if pattern.kind_of? Symbol
-      all.reverse.inject(pattern) do |result, tag|
-        result.gsub(/:#{tag}/) do |match|
-          send( tag, *args )
-        end
+      result = pattern.dup
+      interpolators_cache.each do |method, token|
+        result.gsub!(token) { send(method, *args) } if result.include?(token)
       end
+      result
+    end
+
+    def self.interpolators_cache
+      @interpolators_cache ||= all.reverse!.map! { |method| [method, ":#{method}"] }
     end
 
     def self.plural_cache
@@ -42,7 +48,7 @@ module Paperclip
 
     # Returns the filename, the same way as ":basename.:extension" would.
     def filename attachment, style_name
-      [ basename(attachment, style_name), extension(attachment, style_name) ].reject(&:blank?).join(".")
+      [ basename(attachment, style_name), extension(attachment, style_name) ].delete_if(&:empty?).join(".".freeze)
     end
 
     # Returns the interpolated URL. Will raise an error if the url itself
@@ -85,12 +91,12 @@ module Paperclip
     # all class names. Calling #class will return the expected class.
     def class attachment = nil, style_name = nil
       return super() if attachment.nil? && style_name.nil?
-      plural_cache.underscore_and_pluralize(attachment.instance.class.to_s)
+      plural_cache.underscore_and_pluralize_class(attachment.instance.class)
     end
 
     # Returns the basename of the file. e.g. "file" for "file.jpg"
     def basename attachment, style_name
-      attachment.original_filename.gsub(/#{Regexp.escape(File.extname(attachment.original_filename))}\Z/, "")
+      File.basename(attachment.original_filename, ".*".freeze)
     end
 
     # Returns the extension of the file. e.g. "jpg" for "file.jpg"
@@ -98,7 +104,15 @@ module Paperclip
     # of the actual extension.
     def extension attachment, style_name
       ((style = attachment.styles[style_name.to_s.to_sym]) && style[:format]) ||
-        File.extname(attachment.original_filename).gsub(/\A\.+/, "")
+        File.extname(attachment.original_filename).sub(/\A\.+/, "".freeze)
+    end
+
+    # Returns the dot+extension of the file. e.g. ".jpg" for "file.jpg"
+    # If the style has a format defined, it will return the format instead
+    # of the actual extension. If the extension is empty, no dot is added.
+    def dotextension attachment, style_name
+      ext = extension(attachment, style_name)
+      ext.empty? ? ext : ".#{ext}"
     end
 
     # Returns an extension based on the content type. e.g. "jpeg" for
@@ -128,7 +142,7 @@ module Paperclip
         # It's possible, though unlikely, that the mime type is not in the
         # database, so just use the part after the '/' in the mime type as the
         # extension.
-        %r{/([^/]*)\Z}.match(attachment.content_type)[1]
+        %r{/([^/]*)\z}.match(attachment.content_type)[1]
       end
     end
 
@@ -162,9 +176,13 @@ module Paperclip
     def id_partition attachment, style_name
       case id = attachment.instance.id
       when Integer
-        ("%09d" % id).scan(/\d{3}/).join("/")
+        if id < ID_PARTITION_LIMIT
+          ("%09d".freeze % id).scan(/\d{3}/).join("/".freeze)
+        else
+          ("%012d".freeze % id).scan(/\d{3}/).join("/".freeze)
+        end
       when String
-        id.scan(/.{3}/).first(3).join("/")
+        id.scan(/.{3}/).first(3).join("/".freeze)
       else
         nil
       end
@@ -173,7 +191,7 @@ module Paperclip
     # Returns the pluralized form of the attachment name. e.g.
     # "avatars" for an attachment of :avatar
     def attachment attachment, style_name
-      plural_cache.pluralize(attachment.name.to_s.downcase)
+      plural_cache.pluralize_symbol(attachment.name)
     end
 
     # Returns the style, or the default style if nil is supplied.

data/lib/paperclip/io_adapters/abstract_adapter.rb

@@ -4,11 +4,24 @@ module Paperclip
   class AbstractAdapter
     OS_RESTRICTED_CHARACTERS = %r{[/:]}
 
-    attr_reader :content_type, :original_filename, :size
-    delegate :binmode, :binmode?, :close, :close!, :closed?, :eof?, :path, :rewind, :unlink, :to => :@tempfile
+    attr_reader :content_type, :original_filename, :size, :tempfile
+    delegate :binmode, :binmode?, :close, :close!, :closed?, :eof?, :path, :readbyte, :rewind, :unlink, :to => :@tempfile
+    alias :length :size
+
+    def initialize(target, options = {})
+      @target = target
+      @options = options
+    end
 
     def fingerprint
-      @fingerprint ||= Digest::MD5.file(path).to_s
+      @fingerprint ||= begin
+        digest = @options.fetch(:hash_digest).new
+        File.open(path, "rb") do |f|
+          buf = ""
+          digest.update(buf) while f.read(16384, buf)
+        end
+        digest.hexdigest
+      end
     end
 
     def read(length = nil, buffer = nil)
@@ -20,6 +33,7 @@ module Paperclip
     end
 
     def original_filename=(new_filename)
+      return unless new_filename
       @original_filename = new_filename.gsub(OS_RESTRICTED_CHARACTERS, "_")
     end
 
@@ -34,12 +48,27 @@ module Paperclip
     private
 
     def destination
-      @destination ||= TempfileFactory.new.generate(original_filename)
+      @destination ||= TempfileFactory.new.generate(@original_filename.to_s)
     end
 
     def copy_to_tempfile(src)
-      FileUtils.cp(src.path, destination.path)
+      link_or_copy_file(src.path, destination.path)
       destination
     end
+
+    def link_or_copy_file(src, dest)
+      begin
+        Paperclip.log("Trying to link #{src} to #{dest}")
+        FileUtils.ln(src, dest, force: true) # overwrite existing
+      rescue Errno::EXDEV, Errno::EPERM, Errno::ENOENT, Errno::EEXIST => e
+        Paperclip.log(
+          "Link failed with #{e.message}; copying link #{src} to #{dest}"
+        )
+        FileUtils.cp(src, dest)
+      end
+
+      @destination.close
+      @destination.open.binmode
+    end
   end
 end

data/lib/paperclip/io_adapters/attachment_adapter.rb

@@ -1,6 +1,13 @@
 module Paperclip
   class AttachmentAdapter < AbstractAdapter
-    def initialize(target)
+    def self.register
+      Paperclip.io_adapters.register self do |target|
+        Paperclip::Attachment === target || Paperclip::Style === target
+      end
+    end
+
+    def initialize(target, options = {})
+      super
       @target, @style = case target
       when Paperclip::Attachment
         [target, :original]
@@ -20,17 +27,21 @@ module Paperclip
       @size = @tempfile.size || @target.size
     end
 
-    def copy_to_tempfile(src)
-      if src.respond_to? :copy_to_local_file
-        src.copy_to_local_file(@style, destination.path)
+    def copy_to_tempfile(source)
+      if source.staged?
+        link_or_copy_file(source.staged_path(@style), destination.path)
       else
-        FileUtils.cp(src.path(@style), destination.path)
+        begin
+          source.copy_to_local_file(@style, destination.path)
+        rescue Errno::EACCES
+          # clean up lingering tempfile if we cannot access source file
+          destination.close(true)
+          raise
+        end
       end
       destination
     end
   end
 end
 
-Paperclip.io_adapters.register Paperclip::AttachmentAdapter do |target|
-  Paperclip::Attachment === target || Paperclip::Style === target
-end
+Paperclip::AttachmentAdapter.register

data/lib/paperclip/io_adapters/data_uri_adapter.rb

@@ -1,27 +1,22 @@
 module Paperclip
   class DataUriAdapter < StringioAdapter
+    def self.register
+      Paperclip.io_adapters.register self do |target|
+        String === target && target =~ REGEXP
+      end
+    end
 
-    REGEXP = /\Adata:([-\w]+\/[-\w\+]+);base64,(.*)/m
+    REGEXP = /\Adata:([-\w]+\/[-\w\+\.]+)?;base64,(.*)/m
 
-    def initialize(target_uri)
-      @target_uri = target_uri
-      cache_current_values
-      @tempfile = copy_to_tempfile
+    def initialize(target_uri, options = {})
+      super(extract_target(target_uri), options)
     end
 
     private
 
-    def cache_current_values
-      self.original_filename = 'base64.txt'
-      data_uri_parts ||= @target_uri.match(REGEXP) || []
-      @content_type = data_uri_parts[1] || 'text/plain'
-      @target = StringIO.new(Base64.decode64(data_uri_parts[2] || ''))
-      @size = @target.size
+    def extract_target(uri)
+      data_uri_parts = uri.match(REGEXP) || []
+      StringIO.new(Base64.decode64(data_uri_parts[2] || ""))
     end
-
   end
 end
-
-Paperclip.io_adapters.register Paperclip::DataUriAdapter do |target|
-  String === target && target =~ Paperclip::DataUriAdapter::REGEXP
-end

data/lib/paperclip/io_adapters/empty_string_adapter.rb

@@ -1,6 +1,9 @@
 module Paperclip
   class EmptyStringAdapter < AbstractAdapter
-    def initialize(target)
+    def self.register
+      Paperclip.io_adapters.register self do |target|
+        target.is_a?(String) && target.empty?
+      end
     end
 
     def nil?
@@ -13,6 +16,4 @@ module Paperclip
   end
 end
 
-Paperclip.io_adapters.register Paperclip::EmptyStringAdapter do |target|
-  target.is_a?(String) && target.empty?
-end
+Paperclip::EmptyStringAdapter.register

data/lib/paperclip/io_adapters/file_adapter.rb

@@ -1,14 +1,22 @@
 module Paperclip
   class FileAdapter < AbstractAdapter
-    def initialize(target)
-      @target = target
+    def self.register
+      Paperclip.io_adapters.register self do |target|
+        File === target || ::Tempfile === target
+      end
+    end
+
+    def initialize(target, options = {})
+      super
       cache_current_values
     end
 
     private
 
     def cache_current_values
-      self.original_filename = @target.original_filename if @target.respond_to?(:original_filename)
+      if @target.respond_to?(:original_filename)
+        self.original_filename = @target.original_filename
+      end
       self.original_filename ||= File.basename(@target.path)
       @tempfile = copy_to_tempfile(@target)
       @content_type = ContentTypeDetector.new(@target.path).detect
@@ -17,6 +25,4 @@ module Paperclip
   end
 end
 
-Paperclip.io_adapters.register Paperclip::FileAdapter do |target|
-  File === target || Tempfile === target
-end
+Paperclip::FileAdapter.register

data/lib/paperclip/io_adapters/http_url_proxy_adapter.rb

@@ -1,15 +1,16 @@
 module Paperclip
   class HttpUrlProxyAdapter < UriAdapter
+    def self.register
+      Paperclip.io_adapters.register self do |target|
+        String === target && target =~ REGEXP
+      end
+    end
 
     REGEXP = /\Ahttps?:\/\//
 
-    def initialize(target)
-      super(URI(target))
+    def initialize(target, options = {})
+      escaped = URI.escape(target)
+      super(URI(target == URI.unescape(target) ? escaped : target), options)
     end
-
   end
 end
-
-Paperclip.io_adapters.register Paperclip::HttpUrlProxyAdapter do |target|
-  String === target && target =~ Paperclip::HttpUrlProxyAdapter::REGEXP
-end