kt-paperclip 6.2.0

data/lib/paperclip/attachment_registry.rb

@@ -0,0 +1,60 @@
+require "singleton"
+
+module Paperclip
+  class AttachmentRegistry
+    include Singleton
+
+    def self.register(klass, attachment_name, attachment_options)
+      instance.register(klass, attachment_name, attachment_options)
+    end
+
+    def self.clear
+      instance.clear
+    end
+
+    def self.names_for(klass)
+      instance.names_for(klass)
+    end
+
+    def self.each_definition(&block)
+      instance.each_definition(&block)
+    end
+
+    def self.definitions_for(klass)
+      instance.definitions_for(klass)
+    end
+
+    def initialize
+      clear
+    end
+
+    def register(klass, attachment_name, attachment_options)
+      @attachments ||= {}
+      @attachments[klass] ||= {}
+      @attachments[klass][attachment_name] = attachment_options
+    end
+
+    def clear
+      @attachments = Hash.new { |h, k| h[k] = {} }
+    end
+
+    def names_for(klass)
+      @attachments[klass].keys
+    end
+
+    def each_definition
+      @attachments.each do |klass, attachments|
+        attachments.each do |name, options|
+          yield klass, name, options
+        end
+      end
+    end
+
+    def definitions_for(klass)
+      parent_classes = klass.ancestors.reverse
+      parent_classes.each_with_object({}) do |ancestor, inherited_definitions|
+        inherited_definitions.deep_merge! @attachments[ancestor]
+      end
+    end
+  end
+end

data/lib/paperclip/callbacks.rb

@@ -0,0 +1,42 @@
+module Paperclip
+  module Callbacks
+    def self.included(base)
+      base.extend(Defining)
+      base.send(:include, Running)
+    end
+
+    module Defining
+      def define_paperclip_callbacks(*callbacks)
+        define_callbacks(*[callbacks, { terminator: hasta_la_vista_baby }].flatten)
+        callbacks.each do |callback|
+          eval <<-end_callbacks
+            def before_#{callback}(*args, &blk)
+              set_callback(:#{callback}, :before, *args, &blk)
+            end
+            def after_#{callback}(*args, &blk)
+              set_callback(:#{callback}, :after, *args, &blk)
+            end
+          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
+      def run_paperclip_callbacks(callback, &block)
+        run_callbacks(callback, &block)
+      end
+    end
+  end
+end

data/lib/paperclip/content_type_detector.rb

@@ -0,0 +1,80 @@
+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 ||= File.open(@filepath) do |file|
+        MimeMagic.by_magic(file).try(:type)
+      end
+    end
+
+    def type_from_file_command
+      @type_from_file_command ||=
+        FileCommandContentTypeDetector.new(@filepath).detect
+    end
+  end
+end

data/lib/paperclip/errors.rb

@@ -0,0 +1,34 @@
+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. If you are
+    # consistently receiving this error on PDFs make sure that you have
+    # installed Ghostscript.
+    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,28 @@
+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 Terrapin::CommandLineError => e
+               Paperclip.log("Error while determining content type: #{e}")
+               SENSIBLE_DEFAULT
+             end
+
+      type = SENSIBLE_DEFAULT if type.nil? || type.match(/\(.*?\)/)
+      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.rb

@@ -0,0 +1,157 @@
+module Paperclip
+  # Defines the geometry of an image.
+  class Geometry
+    attr_accessor :height, :width, :modifier
+
+    EXIF_ROTATED_ORIENTATION_VALUES = [5, 6, 7, 8].freeze
+
+    # 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 / width, dst.height / 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 >= width && new_geometry.height >= height
+          self
+        else
+          scale_to new_geometry
+        end
+      when "<"
+        if new_geometry.width <= width || new_geometry.height <= 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, (height * scale - dst.height) / 2]
+      else
+        "%dx%d+%d+%d" % [dst.width, dst.height, (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 / width.to_f, new_geometry.height.to_f / height.to_f].min
+      Paperclip::Geometry.new((width * scale).round, (height * scale).round)
+    end
+  end
+end

data/lib/paperclip/geometry_detector_factory.rb

@@ -0,0 +1,45 @@
+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
+      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 Terrapin::CommandNotFoundError => e
+      raise_because_imagemagick_missing
+    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