kt-paperclip 4.4.0

data/lib/paperclip/content_type_detector.rb

@@ -0,0 +1,79 @@
+module Paperclip
+  class ContentTypeDetector
+    # The content-type detection strategy is as follows:
+    #
+    # 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
+    #    `file` command and MIME::Types.
+    #
+    # 3. Standard types: Return the first standard (without an x- prefix) entry
+    #    in MIME::Types
+    #
+    # 4. Experimental types: If there were no standard types in MIME::Types
+    #    list, try to return the first experimental one
+    #
+    # 5. Raw `file` command: Just use the output of the `file` command raw, or
+    #    a sensible default. This is cached from Step 2.
+
+    EMPTY_TYPE = "inode/x-empty"
+    SENSIBLE_DEFAULT = "application/octet-stream"
+
+    def initialize(filepath)
+      @filepath = filepath
+    end
+
+    # Returns a String describing the file's content type
+    def detect
+      if blank_name?
+        SENSIBLE_DEFAULT
+      elsif empty_file?
+        EMPTY_TYPE
+      elsif calculated_type_matches.any?
+        calculated_type_matches.first
+      else
+        type_from_file_contents || SENSIBLE_DEFAULT
+      end.to_s
+    end
+
+    private
+
+    def blank_name?
+      @filepath.nil? || @filepath.empty?
+    end
+
+    def empty_file?
+      File.exist?(@filepath) && File.size(@filepath) == 0
+    end
+
+    alias :empty? :empty_file?
+
+    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(@filepath).collect(&:content_type)
+    end
+
+    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 type_from_mime_magic
+      @type_from_mime_magic ||=
+        MimeMagic.by_magic(File.open(@filepath)).try(:type)
+    end
+
+    def type_from_file_command
+      @type_from_file_command ||=
+        FileCommandContentTypeDetector.new(@filepath).detect
+    end
+  end
+end

data/lib/paperclip/deprecations.rb

@@ -0,0 +1,42 @@
+require "active_support/deprecation"
+
+module Paperclip
+  class Deprecations
+    class << self
+      def check
+        warn_aws_sdk_v1 if aws_sdk_v1?
+        warn_outdated_rails if active_model_version < "4.2"
+      end
+
+      private
+
+      def active_model_version
+        ::ActiveModel::VERSION::STRING
+      end
+
+      def aws_sdk_v1?
+        defined?(::AWS) && aws_sdk_version < "2"
+      end
+
+      def warn_aws_sdk_v1
+        warn "[paperclip] [deprecation] AWS SDK v1 has been deprecated in " \
+             "paperclip 5. Please consider upgrading to AWS 2 before " \
+             "upgrading paperclip."
+      end
+
+      def warn_outdated_rails
+        warn "[paperclip] [deprecation] Rails 3.2 and 4.1 are unsupported as " \
+             "of Rails 5 release. Please upgrade to Rails 4.2 before " \
+             "upgrading paperclip."
+      end
+
+      def aws_sdk_version
+        ::AWS::VERSION
+      end
+
+      def warn(message)
+        ActiveSupport::Deprecation.warn(message)
+      end
+    end
+  end
+end

data/lib/paperclip/errors.rb

@@ -0,0 +1,32 @@
+module Paperclip
+  # A base error class for Paperclip. Most of the error that will be thrown
+  # from Paperclip will inherits from this class.
+  class Error < StandardError
+  end
+
+  module Errors
+    # Will be thrown when a storage method is not found.
+    class StorageMethodNotFound < Paperclip::Error
+    end
+
+    # Will be thrown when a command or executable is not found.
+    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.
+    class NotIdentifiedByImageMagickError < Paperclip::Error
+    end
+
+    # Will be thrown if the interpolation is creating an infinite loop. If you
+    # are creating an interpolator which might cause an infinite loop, you
+    # should be throwing this error upon the infinite loop as well.
+    class InfiniteInterpolationError < Paperclip::Error
+    end
+  end
+end

data/lib/paperclip/file_command_content_type_detector.rb

@@ -0,0 +1,30 @@
+module Paperclip
+  class FileCommandContentTypeDetector
+    SENSIBLE_DEFAULT = "application/octet-stream"
+
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def detect
+      type_from_file_command
+    end
+
+    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
+               Paperclip.run("file", "-b --mime :file", file: @filename)
+             rescue Cocaine::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,16 @@
+# encoding: utf-8
+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.rb

@@ -0,0 +1,158 @@
+module Paperclip
+
+  # Defines the geometry of an image.
+  class Geometry
+    attr_accessor :height, :width, :modifier
+
+    EXIF_ROTATED_ORIENTATION_VALUES = [5, 6, 7, 8]
+
+    # Gives a Geometry representing the given height and width
+    def initialize(width = nil, height = nil, modifier = nil)
+      if width.is_a?(Hash)
+        options = width
+        @height = options[:height].to_f
+        @width = options[:width].to_f
+        @modifier = options[:modifier]
+        @orientation = options[:orientation].to_i
+      else
+        @height = height.to_f
+        @width  = width.to_f
+        @modifier = modifier
+      end
+    end
+
+    # Extracts the Geometry from a file (or path to a file)
+    def self.from_file(file)
+      GeometryDetector.new(file).make
+    end
+
+    # Extracts the Geometry from a "WxH,O" string
+    # Where W is the width, H is the height,
+    # and O is the EXIF orientation
+    def self.parse(string)
+      GeometryParser.new(string).make
+    end
+
+    # Swaps the height and width if necessary
+    def auto_orient
+      if EXIF_ROTATED_ORIENTATION_VALUES.include?(@orientation)
+        @height, @width = @width, @height
+        @orientation -= 4
+      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
+      s = ""
+      s << width.to_i.to_s if width > 0
+      s << "x#{height.to_i}" if height > 0
+      s << modifier.to_s
+      s
+    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
+      if crop
+        ratio = Geometry.new( dst.width / self.width, dst.height / self.height )
+        scale_geometry, scale = scaling(dst, ratio)
+        crop_geometry         = cropping(dst, ratio, scale)
+      else
+        scale_geometry        = dst.to_s
+      end
+
+      [ scale_geometry, crop_geometry ]
+    end
+
+    # resize to a new geometry
+    # @param geometry [String] the Paperclip geometry definition to resize to
+    # @example
+    #   Paperclip::Geometry.new(150, 150).resize_to('50x50!')
+    #   #=> Paperclip::Geometry(50, 50)
+    def resize_to(geometry)
+      new_geometry = Paperclip::Geometry.parse geometry
+      case new_geometry.modifier
+      when '!', '#'
+        new_geometry
+      when '>'
+        if new_geometry.width >= self.width && new_geometry.height >= self.height
+          self
+        else
+          scale_to new_geometry
+        end
+      when '<'
+        if new_geometry.width <= self.width || new_geometry.height <= self.height
+          self
+        else
+          scale_to new_geometry
+        end
+      else
+        scale_to new_geometry
+      end
+    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
+
+    # scale to the requested geometry and preserve the aspect ratio
+    def scale_to(new_geometry)
+      scale = [new_geometry.width.to_f / self.width.to_f , new_geometry.height.to_f / self.height.to_f].min
+      Paperclip::Geometry.new((self.width * scale).round, (self.height * scale).round)
+    end
+  end
+end

data/lib/paperclip/geometry_detector_factory.rb

@@ -0,0 +1,48 @@
+module Paperclip
+  class GeometryDetector
+    def initialize(file)
+      @file = file
+      raise_if_blank_file
+    end
+
+    def make
+      geometry = GeometryParser.new(geometry_string.strip).make
+      geometry || raise(Errors::NotIdentifiedByImageMagickError.new)
+    end
+
+    private
+
+    def geometry_string
+      begin
+        orientation = Paperclip.options[:use_exif_orientation] ?
+          "%[exif:orientation]" : "1"
+        Paperclip.run(
+          "identify",
+          "-format '%wx%h,#{orientation}' :file", {
+            :file => "#{path}[0]"
+          }, {
+            :swallow_stderr => true
+          }
+        )
+      rescue Cocaine::ExitStatusError
+        ""
+      rescue Cocaine::CommandNotFoundError => e
+        raise_because_imagemagick_missing
+      end
+    end
+
+    def path
+      @file.respond_to?(:path) ? @file.path : @file
+    end
+
+    def raise_if_blank_file
+      if path.blank?
+        raise Errors::NotIdentifiedByImageMagickError.new("Cannot find the geometry of a file with a blank name")
+      end
+    end
+
+    def raise_because_imagemagick_missing
+      raise Errors::CommandNotFoundError.new("Could not run the `identify` command. Please install ImageMagick.")
+    end
+  end
+end

data/lib/paperclip/geometry_parser_factory.rb

@@ -0,0 +1,31 @@
+module Paperclip
+  class GeometryParser
+    FORMAT = /\b(\d*)x?(\d*)\b(?:,(\d?))?(\@\>|\>\@|[\>\<\#\@\%^!])?/i
+    def initialize(string)
+      @string = string
+    end
+
+    def make
+      if match
+        Geometry.new(
+          :height => @height,
+          :width => @width,
+          :modifier => @modifier,
+          :orientation => @orientation
+        )
+      end
+    end
+
+    private
+
+    def match
+      if actual_match = @string && @string.match(FORMAT)
+        @width = actual_match[1]
+        @height = actual_match[2]
+        @orientation = actual_match[3]
+        @modifier = actual_match[4]
+      end
+      actual_match
+    end
+  end
+end

data/lib/paperclip/glue.rb

@@ -0,0 +1,17 @@
+require 'paperclip/callbacks'
+require 'paperclip/validators'
+require 'paperclip/schema'
+
+module Paperclip
+  module Glue
+    def self.included(base)
+      base.extend ClassMethods
+      base.send :include, Callbacks
+      base.send :include, Validators
+      base.send :include, Schema if defined? ActiveRecord
+
+      locale_path = Dir.glob(File.dirname(__FILE__) + "/locales/*.{rb,yml}")
+      I18n.load_path += locale_path unless I18n.load_path.include?(locale_path)
+    end
+  end
+end

data/lib/paperclip/has_attached_file.rb

@@ -0,0 +1,109 @@
+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) }
+      @klass.send(:after_commit, :on => :destroy) { send(name).send(:flush_deletes) }
+    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

@@ -0,0 +1,56 @@
+module Paperclip
+  module Helpers
+    def configure
+      yield(self) if block_given?
+    end
+
+    def interpolates key, &block
+      Paperclip::Interpolations[key] = block
+    end
+
+    # The run method takes the name of a binary to run, the arguments to that binary
+    # and some options:
+    #
+    #   :command_path -> A $PATH-like variable that defines where to look for the binary
+    #                    on the filesystem. Colon-separated, just like $PATH.
+    #
+    #   :expected_outcodes -> An array of integers that defines the expected exit codes
+    #                         of the binary. Defaults to [0].
+    #
+    #   :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.
+    #
+    #   :swallow_stderr -> Set to true if you don't care what happens on STDERR.
+    #
+    def run(cmd, arguments = "", interpolation_values = {}, local_options = {})
+      command_path = options[:command_path]
+      Cocaine::CommandLine.path = [Cocaine::CommandLine.path, 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)
+    end
+
+    # Find all instances of the given Active Record model +klass+ with attachment +name+.
+    # This method is used by the refresh rake tasks.
+    def each_instance_with_attachment(klass, name)
+      class_for(klass).unscoped.where("#{name}_file_name IS NOT NULL").find_each do |instance|
+        yield(instance)
+      end
+    end
+
+    def class_for(class_name)
+      class_name.split('::').inject(Object) do |klass, partial_class_name|
+        if klass.const_defined?(partial_class_name)
+          klass.const_get(partial_class_name, false)
+        else
+          klass.const_missing(partial_class_name)
+        end
+      end
+    end
+
+    def reset_duplicate_clash_check!
+      @names_url = nil
+    end
+  end
+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