jr-paperclip 7.3.0

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,85 @@
+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_marcel || type_from_file_command
+    rescue Errno::ENOENT => e
+      Paperclip.log("Error while determining content type: #{e}")
+      SENSIBLE_DEFAULT
+    end
+
+    def type_from_marcel
+      return @type_from_marcel if defined? @type_from_marcel
+
+      @type_from_marcel = Marcel::MimeType.for Pathname.new(@filepath),
+                                               name: @filepath
+      # Marcel::MineType returns 'application/octet-stream' if it can't find
+      # a valid type.
+      @type_from_marcel = nil if @type_from_marcel == SENSIBLE_DEFAULT
+      @type_from_marcel
+    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 = String.new
+      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("Could not identify image size"))
+    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

data/lib/paperclip/geometry_parser_factory.rb

@@ -0,0 +1,31 @@
+module Paperclip
+  class GeometryParser
+    FORMAT = /\b(\d*)x?(\d*)\b(?:,(\d?))?(\@\>|\>\@|[\>\<\#\@\%^!])?/i.freeze
+    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,18 @@
+require "paperclip/callbacks"
+require "paperclip/validators"
+require "paperclip/schema"
+
+module Paperclip
+  module Glue
+    LOCALE_PATHS = Dir.glob("#{File.dirname(__FILE__)}/locales/*.{rb,yml}")
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.send :include, Callbacks
+      base.send :include, Validators
+      base.send :include, Schema if defined? ActiveRecord::Base
+
+      I18n.load_path += LOCALE_PATHS unless (LOCALE_PATHS - I18n.load_path).empty?
+    end
+  end
+end

data/lib/paperclip/has_attached_file.rb

@@ -0,0 +1,116 @@
+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.empty?
+          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", :"#{@name}_validate"
+      )
+    end
+
+    module ClassMethods
+      def attachment_definitions
+        Paperclip::AttachmentRegistry.definitions_for(self)
+      end
+    end
+  end
+end

data/lib/paperclip/helpers.rb

@@ -0,0 +1,60 @@
+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, the values to interpolate and some local options.
+    #
+    #  :cmd -> The name of a binary to run.
+    #
+    #  :arguments -> The command line arguments to that binary.
+    #
+    #  :interpolation_values -> Values to be interpolated into the arguments.
+    #
+    #  :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]
+      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
+      Terrapin::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