paperclip 3.4.0 → 6.1.0

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

@@ -0,0 +1,15 @@
+module Paperclip
+  class FilenameCleaner
+    def initialize(invalid_character_regex)
+      @invalid_character_regex = invalid_character_regex
+    end
+
+    def call(filename)
+      if @invalid_character_regex
+        filename.gsub(@invalid_character_regex, "_")
+      else
+        filename
+      end
+    end
+  end
+end

data/lib/paperclip/geometry_detector_factory.rb

@@ -14,12 +14,19 @@ module Paperclip
 
     def geometry_string
       begin
-        silence_stream(STDERR) do
-          Paperclip.run("identify", "-format '%wx%h,%[exif:orientation]' :file", :file => "#{path}[0]")
-        end
-      rescue Cocaine::ExitStatusError
+        orientation = Paperclip.options[:use_exif_orientation] ?
+          "%[exif:orientation]" : "1"
+        Paperclip.run(
+          Paperclip.options[:is_windows] ? "magick identify" : "identify",
+          "-format '%wx%h,#{orientation}' :file", {
+            :file => "#{path}[0]"
+          }, {
+            :swallow_stderr => true
+          }
+        )
+      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,8 +8,7 @@ module Paperclip
       base.extend ClassMethods
       base.send :include, Callbacks
       base.send :include, Validators
-      base.send :include, Schema if defined? ActiveRecord
-      base.class_attribute :attachment_definitions
+      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

@@ -0,0 +1,115 @@
+module Paperclip
+  class HasAttachedFile
+    def self.define_on(klass, name, options)
+      new(klass, name, options).define
+    end
+
+    def initialize(klass, name, options)
+      @klass = klass
+      @name = name
+      @options = options
+    end
+
+    def define
+      define_flush_errors
+      define_getters
+      define_setter
+      define_query
+      register_new_attachment
+      add_active_record_callbacks
+      add_paperclip_callbacks
+      add_required_validations
+    end
+
+    private
+
+    def define_flush_errors
+      @klass.send(:validates_each, @name) do |record, attr, value|
+        attachment = record.send(@name)
+        attachment.send(:flush_errors)
+      end
+    end
+
+    def define_getters
+      define_instance_getter
+      define_class_getter
+    end
+
+    def define_instance_getter
+      name = @name
+      options = @options
+
+      @klass.send :define_method, @name do |*args|
+        ivar = "@attachment_#{name}"
+        attachment = instance_variable_get(ivar)
+
+        if attachment.nil?
+          attachment = Attachment.new(name, self, options)
+          instance_variable_set(ivar, attachment)
+        end
+
+        if args.length > 0
+          attachment.to_s(args.first)
+        else
+          attachment
+        end
+      end
+    end
+
+    def define_class_getter
+      @klass.extend(ClassMethods)
+    end
+
+    def define_setter
+      name = @name
+      @klass.send :define_method, "#{@name}=" do |file|
+        send(name).assign(file)
+      end
+    end
+
+    def define_query
+      name = @name
+      @klass.send :define_method, "#{@name}?" do
+        send(name).file?
+      end
+    end
+
+    def register_new_attachment
+      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) }
+      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
+      @klass.send(
+        :define_paperclip_callbacks,
+        :post_process, :"#{@name}_post_process")
+    end
+
+    module ClassMethods
+      def attachment_definitions
+        Paperclip::AttachmentRegistry.definitions_for(self)
+      end
+    end
+  end
+end

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+.
@@ -49,15 +53,6 @@ module Paperclip
       end
     end
 
-    def check_for_path_clash(name,path,klass)
-      @names_path ||= {}
-      default_path = path || Attachment.default_options[:path]
-      if @names_path[name] && @names_path[name][:path] == default_path && @names_path[name][:class] != klass && @names_path[name][:path] !~ /:class/
-        log("Duplicate path for #{name} with #{default_path}. This will clash with attachment defined in #{@names_path[name][:class]} class")
-      end
-      @names_path[name] = {:path => default_path, :class => klass}
-    end
-
     def reset_duplicate_clash_check!
       @names_url = nil
     end

data/lib/paperclip/interpolations/plural_cache.rb

@@ -0,0 +1,18 @@
+module Paperclip
+  module Interpolations
+    class PluralCache
+      def initialize
+        @symbol_cache = {}.compare_by_identity
+        @klass_cache = {}.compare_by_identity
+      end
+
+      def pluralize_symbol(symbol)
+        @symbol_cache[symbol] ||= symbol.to_s.downcase.pluralize
+      end
+
+      def underscore_and_pluralize_class(klass)
+        @klass_cache[klass] ||= klass.name.underscore.pluralize
+      end
+    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,22 +31,30 @@ 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
+      @plural_cache ||= PluralCache.new
     end
 
     # 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
     # contains ":url" to prevent infinite recursion. This interpolation
     # is used in the default :path to ease default specifications.
-    RIGHT_HERE = "#{__FILE__.gsub(%r{^\./}, "")}:#{__LINE__ + 3}"
+    RIGHT_HERE = "#{__FILE__.gsub(%r{\A\./}, "")}:#{__LINE__ + 3}"
     def url attachment, style_name
       raise Errors::InfiniteInterpolationError if caller.any?{|b| b.index(RIGHT_HERE) }
       attachment.url(style_name, :timestamp => false, :escape => false)
@@ -81,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?
-      attachment.instance.class.to_s.underscore.pluralize
+      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))}$/, "")
+      File.basename(attachment.original_filename, ".*".freeze)
     end
 
     # Returns the extension of the file. e.g. "jpg" for "file.jpg"
@@ -94,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(/^\.+/, "")
+        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
@@ -124,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{/([^/]*)$}.match(attachment.content_type)[1]
+        %r{/([^/]*)\z}.match(attachment.content_type)[1]
       end
     end
 
@@ -158,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
@@ -169,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
-      attachment.name.to_s.downcase.pluralize
+      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 :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,18 +33,42 @@ module Paperclip
     end
 
     def original_filename=(new_filename)
+      return unless new_filename
       @original_filename = new_filename.gsub(OS_RESTRICTED_CHARACTERS, "_")
     end
 
+    def nil?
+      false
+    end
+
+    def assignment?
+      true
+    end
+
     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]
@@ -14,23 +21,27 @@ module Paperclip
     private
 
     def cache_current_values
-      @original_filename = @target.original_filename
+      self.original_filename = @target.original_filename
       @content_type = @target.content_type
       @tempfile = copy_to_tempfile(@target)
       @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

@@ -0,0 +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
+
+    def initialize(target_uri, options = {})
+      super(extract_target(target_uri), options)
+    end
+
+    private
+
+    def extract_target(uri)
+      data_uri_parts = uri.match(REGEXP) || []
+      StringIO.new(Base64.decode64(data_uri_parts[2] || ""))
+    end
+  end
+end

data/lib/paperclip/io_adapters/empty_string_adapter.rb

@@ -0,0 +1,19 @@
+module Paperclip
+  class EmptyStringAdapter < AbstractAdapter
+    def self.register
+      Paperclip.io_adapters.register self do |target|
+        target.is_a?(String) && target.empty?
+      end
+    end
+
+    def nil?
+      false
+    end
+
+    def assignment?
+      false
+    end
+  end
+end
+
+Paperclip::EmptyStringAdapter.register

data/lib/paperclip/io_adapters/file_adapter.rb

@@ -1,15 +1,23 @@
 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
-      @original_filename = @target.original_filename if @target.respond_to?(:original_filename)
-      @original_filename ||= File.basename(@target.path)
+      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
       @size = File.size(@target)
@@ -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

@@ -0,0 +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, options = {})
+      escaped = URI.escape(target)
+      super(URI(target == URI.unescape(target) ? escaped : target), options)
+    end
+  end
+end

data/lib/paperclip/io_adapters/identity_adapter.rb

@@ -1,12 +1,18 @@
 module Paperclip
   class IdentityAdapter < AbstractAdapter
-    def new(adapter)
-      adapter
+    def self.register
+      Paperclip.io_adapters.register Paperclip::IdentityAdapter.new do |target|
+        Paperclip.io_adapters.registered?(target)
+      end
+    end
+
+    def initialize
     end
-  end
-end
 
-Paperclip.io_adapters.register Paperclip::IdentityAdapter.new do |target|
-  Paperclip.io_adapters.registered?(target)
+    def new(target, _)
+      target
+    end
+  end
 end
 
+Paperclip::IdentityAdapter.register