kt-paperclip 6.2.0

data/lib/paperclip/style.rb

@@ -0,0 +1,106 @@
+module Paperclip
+  # The Style class holds the definition of a thumbnail style,  applying
+  # whatever processing is required to normalize the definition and delaying
+  # the evaluation of block parameters until useful context is available.
+
+  class Style
+    attr_reader :name, :attachment, :format
+
+    # Creates a Style object. +name+ is the name of the attachment,
+    # +definition+ is the style definition from has_attached_file, which
+    # can be string, array or hash
+    def initialize(name, definition, attachment)
+      @name = name
+      @attachment = attachment
+      if definition.is_a? Hash
+        @geometry = definition.delete(:geometry)
+        @format = definition.delete(:format)
+        @processors = definition.delete(:processors)
+        @convert_options = definition.delete(:convert_options)
+        @source_file_options = definition.delete(:source_file_options)
+        @other_args = definition
+      elsif definition.is_a? String
+        @geometry = definition
+        @format = nil
+        @other_args = {}
+      else
+        @geometry, @format = [definition, nil].flatten[0..1]
+        @other_args = {}
+      end
+      @format = default_format if @format.blank?
+    end
+
+    # retrieves from the attachment the processors defined in the has_attached_file call
+    # (which method (in the attachment) will call any supplied procs)
+    # There is an important change of interface here: a style rule can set its own processors
+    # by default we behave as before, though.
+    # if a proc has been supplied, we call it here
+    def processors
+      @processors.respond_to?(:call) ? @processors.call(attachment.instance) : (@processors || attachment.processors)
+    end
+
+    # retrieves from the attachment the whiny setting
+    def whiny
+      attachment.whiny
+    end
+
+    # returns true if we're inclined to grumble
+    def whiny?
+      !!whiny
+    end
+
+    def convert_options
+      @convert_options.respond_to?(:call) ? @convert_options.call(attachment.instance) :
+        (@convert_options || attachment.send(:extra_options_for, name))
+    end
+
+    def source_file_options
+      @source_file_options.respond_to?(:call) ? @source_file_options.call(attachment.instance) :
+        (@source_file_options || attachment.send(:extra_source_file_options_for, name))
+    end
+
+    # returns the geometry string for this style
+    # if a proc has been supplied, we call it here
+    def geometry
+      @geometry.respond_to?(:call) ? @geometry.call(attachment.instance) : @geometry
+    end
+
+    # Supplies the hash of options that processors expect to receive as their second argument
+    # Arguments other than the standard geometry, format etc are just passed through from
+    # initialization and any procs are called here, just before post-processing.
+    def processor_options
+      args = { style: name }
+      @other_args.each do |k, v|
+        args[k] = v.respond_to?(:call) ? v.call(attachment) : v
+      end
+      [:processors, :geometry, :format, :whiny, :convert_options, :source_file_options].each do |k|
+        (arg = send(k)) && args[k] = arg
+      end
+      args
+    end
+
+    # Supports getting and setting style properties with hash notation to ensure backwards-compatibility
+    # eg. @attachment.styles[:large][:geometry]@ will still work
+    def [](key)
+      if [:name, :convert_options, :whiny, :processors, :geometry, :format, :animated, :source_file_options].include?(key)
+        send(key)
+      elsif defined? @other_args[key]
+        @other_args[key]
+      end
+    end
+
+    def []=(key, value)
+      if [:name, :convert_options, :whiny, :processors, :geometry, :format, :animated, :source_file_options].include?(key)
+        send("#{key}=".intern, value)
+      else
+        @other_args[key] = value
+      end
+    end
+
+    # defaults to default format (nil by default)
+    def default_format
+      base = attachment.options[:default_format]
+      base.respond_to?(:call) ? base.call(attachment, name) : base
+    end
+  end
+end

data/lib/paperclip/tempfile.rb

@@ -0,0 +1,42 @@
+module Paperclip
+  # Overriding some implementation of Tempfile
+  class Tempfile < ::Tempfile
+    # Due to how ImageMagick handles its image format conversion and how
+    # Tempfile handles its naming scheme, it is necessary to override how
+    # Tempfile makes # its names so as to allow for file extensions. Idea
+    # taken from the comments on this blog post:
+    # http://marsorange.com/archives/of-mogrify-ruby-tempfile-dynamic-class-definitions
+    #
+    # This is Ruby 1.9.3's implementation.
+    def make_tmpname(prefix_suffix, n)
+      if RUBY_PLATFORM =~ /java/
+        case prefix_suffix
+        when String
+          prefix = prefix_suffix
+          suffix = ""
+        when Array
+          prefix, suffix = *prefix_suffix
+        else
+          raise ArgumentError, "unexpected prefix_suffix: #{prefix_suffix.inspect}"
+        end
+
+        t = Time.now.strftime("%y%m%d")
+        path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}-#{n}#{suffix}"
+      else
+        super
+      end
+    end
+  end
+
+  module TempfileEncoding
+    # This overrides Tempfile#binmode to make sure that the extenal encoding
+    # for binary mode is ASCII-8BIT. This behavior is what's in CRuby, but not
+    # in JRuby
+    def binmode
+      set_encoding("ASCII-8BIT")
+      super
+    end
+  end
+end
+
+::Tempfile.include Paperclip::TempfileEncoding if RUBY_PLATFORM =~ /java/

data/lib/paperclip/tempfile_factory.rb

@@ -0,0 +1,22 @@
+module Paperclip
+  class TempfileFactory
+    def generate(name = random_name)
+      @name = name
+      file = Tempfile.new([basename, extension])
+      file.binmode
+      file
+    end
+
+    def extension
+      File.extname(@name)
+    end
+
+    def basename
+      Digest::MD5.hexdigest(File.basename(@name, extension))
+    end
+
+    def random_name
+      SecureRandom.uuid
+    end
+  end
+end

data/lib/paperclip/thumbnail.rb

@@ -0,0 +1,131 @@
+module Paperclip
+  # Handles thumbnailing images that are uploaded.
+  class Thumbnail < Processor
+    attr_accessor :current_geometry, :target_geometry, :format, :whiny, :convert_options,
+                  :source_file_options, :animated, :auto_orient, :frame_index
+
+    # List of formats that we need to preserve animation
+    ANIMATED_FORMATS = %w(gif).freeze
+    MULTI_FRAME_FORMATS = %w(.mkv .avi .mp4 .mov .mpg .mpeg .gif).freeze
+
+    # Creates a Thumbnail object set to work on the +file+ given. It
+    # will attempt to transform the image into one defined by +target_geometry+
+    # which is a "WxH"-style string. +format+ will be inferred from the +file+
+    # unless specified. Thumbnail creation will raise no errors unless
+    # +whiny+ is true (which it is, by default. If +convert_options+ is
+    # set, the options will be appended to the convert command upon image conversion
+    #
+    # Options include:
+    #
+    #   +geometry+ - the desired width and height of the thumbnail (required)
+    #   +file_geometry_parser+ - an object with a method named +from_file+ that takes an image file and produces its geometry and a +transformation_to+. Defaults to Paperclip::Geometry
+    #   +string_geometry_parser+ - an object with a method named +parse+ that takes a string and produces an object with +width+, +height+, and +to_s+ accessors. Defaults to Paperclip::Geometry
+    #   +source_file_options+ - flags passed to the +convert+ command that influence how the source file is read
+    #   +convert_options+ - flags passed to the +convert+ command that influence how the image is processed
+    #   +whiny+ - whether to raise an error when processing fails. Defaults to true
+    #   +format+ - the desired filename extension
+    #   +animated+ - whether to merge all the layers in the image. Defaults to true
+    #   +frame_index+ - the frame index of the source file to render as the thumbnail
+    def initialize(file, options = {}, attachment = nil)
+      super
+
+      geometry             = options[:geometry].to_s
+      @crop                = geometry[-1, 1] == "#"
+      @target_geometry     = options.fetch(:string_geometry_parser, Geometry).parse(geometry)
+      @current_geometry    = options.fetch(:file_geometry_parser, Geometry).from_file(@file)
+      @source_file_options = options[:source_file_options]
+      @convert_options     = options[:convert_options]
+      @whiny               = options.fetch(:whiny, true)
+      @format              = options[:format]
+      @animated            = options.fetch(:animated, true)
+      @auto_orient         = options.fetch(:auto_orient, true)
+      @current_geometry.auto_orient if @auto_orient && @current_geometry.respond_to?(:auto_orient)
+      @source_file_options = @source_file_options.split(/\s+/) if @source_file_options.respond_to?(:split)
+      @convert_options     = @convert_options.split(/\s+/)     if @convert_options.respond_to?(:split)
+
+      @current_format      = File.extname(@file.path)
+      @basename            = File.basename(@file.path, @current_format)
+      @frame_index         = multi_frame_format? ? options.fetch(:frame_index, 0) : 0
+    end
+
+    # Returns true if the +target_geometry+ is meant to crop.
+    def crop?
+      @crop
+    end
+
+    # Returns true if the image is meant to make use of additional convert options.
+    def convert_options?
+      !@convert_options.nil? && !@convert_options.empty?
+    end
+
+    # Performs the conversion of the +file+ into a thumbnail. Returns the Tempfile
+    # that contains the new image.
+    def make
+      src = @file
+      filename = [@basename, @format ? ".#{@format}" : ""].join
+      dst = TempfileFactory.new.generate(filename)
+
+      begin
+        parameters = []
+        parameters << source_file_options
+        parameters << ":source"
+        parameters << transformation_command
+        parameters << convert_options
+        parameters << ":dest"
+
+        parameters = parameters.flatten.compact.join(" ").strip.squeeze(" ")
+
+        frame = animated? ? "" : "[#{@frame_index}]"
+        convert(
+          parameters,
+          source: "#{File.expand_path(src.path)}#{frame}",
+          dest: File.expand_path(dst.path)
+        )
+      rescue Terrapin::ExitStatusError => e
+        if @whiny
+          message = "There was an error processing the thumbnail for #{@basename}:\n" + e.message
+          raise Paperclip::Error, message
+        end
+      rescue Terrapin::CommandNotFoundError => e
+        raise Paperclip::Errors::CommandNotFoundError.new("Could not run the `convert` command. Please install ImageMagick.")
+      end
+
+      dst
+    end
+
+    # Returns the command ImageMagick's +convert+ needs to transform the image
+    # into the thumbnail.
+    def transformation_command
+      scale, crop = @current_geometry.transformation_to(@target_geometry, crop?)
+      trans = []
+      trans << "-coalesce" if animated?
+      trans << "-auto-orient" if auto_orient
+      trans << "-resize" << %["#{scale}"] unless scale.nil? || scale.empty?
+      trans << "-crop" << %["#{crop}"] << "+repage" if crop
+      trans << '-layers "optimize"' if animated?
+      trans
+    end
+
+    protected
+
+    def multi_frame_format?
+      MULTI_FRAME_FORMATS.include? @current_format
+    end
+
+    def animated?
+      @animated && (ANIMATED_FORMATS.include?(@format.to_s) || @format.blank?) && identified_as_animated?
+    end
+
+    # Return true if ImageMagick's +identify+ returns an animated format
+    def identified_as_animated?
+      if @identified_as_animated.nil?
+        @identified_as_animated = ANIMATED_FORMATS.include? identify("-format %m :file", file: "#{@file.path}[0]").to_s.downcase.strip
+      end
+      @identified_as_animated
+    rescue Terrapin::ExitStatusError => e
+      raise Paperclip::Error, "There was an error running `identify` for #{@basename}" if @whiny
+    rescue Terrapin::CommandNotFoundError => e
+      raise Paperclip::Errors::CommandNotFoundError.new("Could not run the `identify` command. Please install ImageMagick.")
+    end
+  end
+end

data/lib/paperclip/url_generator.rb

@@ -0,0 +1,76 @@
+require "uri"
+require "active_support/core_ext/module/delegation"
+
+module Paperclip
+  class UrlGenerator
+    def initialize(attachment)
+      @attachment = attachment
+    end
+
+    def for(style_name, options)
+      interpolated = attachment_options[:interpolator].interpolate(
+        most_appropriate_url, @attachment, style_name
+      )
+
+      escaped = escape_url_as_needed(interpolated, options)
+      timestamp_as_needed(escaped, options)
+    end
+
+    private
+
+    attr_reader :attachment
+    delegate :options, to: :attachment, prefix: true
+
+    # This method is all over the place.
+    def default_url
+      if attachment_options[:default_url].respond_to?(:call)
+        attachment_options[:default_url].call(@attachment)
+      elsif attachment_options[:default_url].is_a?(Symbol)
+        @attachment.instance.send(attachment_options[:default_url])
+      else
+        attachment_options[:default_url]
+      end
+    end
+
+    def most_appropriate_url
+      if @attachment.original_filename.nil?
+        default_url
+      else
+        attachment_options[:url]
+      end
+    end
+
+    def timestamp_as_needed(url, options)
+      if options[:timestamp] && timestamp_possible?
+        delimiter_char = url.match(/\?.+=/) ? "&" : "?"
+        "#{url}#{delimiter_char}#{@attachment.updated_at}"
+      else
+        url
+      end
+    end
+
+    def timestamp_possible?
+      @attachment.respond_to?(:updated_at) && @attachment.updated_at.present?
+    end
+
+    def escape_url_as_needed(url, options)
+      if options[:escape]
+        escape_url(url)
+      else
+        url
+      end
+    end
+
+    def escape_url(url)
+      if url.respond_to?(:escape)
+        url.escape
+      else
+        URI.escape(url).gsub(escape_regex) { |m| "%#{m.ord.to_s(16).upcase}" }
+      end
+    end
+
+    def escape_regex
+      /[\?\(\)\[\]\+]/
+    end
+  end
+end

data/lib/paperclip/validators.rb

@@ -0,0 +1,73 @@
+require "active_model"
+require "active_support/concern"
+require "active_support/core_ext/array/wrap"
+require "paperclip/validators/attachment_content_type_validator"
+require "paperclip/validators/attachment_file_name_validator"
+require "paperclip/validators/attachment_presence_validator"
+require "paperclip/validators/attachment_size_validator"
+require "paperclip/validators/media_type_spoof_detection_validator"
+require "paperclip/validators/attachment_file_type_ignorance_validator"
+
+module Paperclip
+  module Validators
+    extend ActiveSupport::Concern
+
+    included do
+      extend  HelperMethods
+      include HelperMethods
+    end
+
+    ::Paperclip::REQUIRED_VALIDATORS = [AttachmentFileNameValidator, AttachmentContentTypeValidator, AttachmentFileTypeIgnoranceValidator].freeze
+
+    module ClassMethods
+      # This method is a shortcut to validator classes that is in
+      # "Attachment...Validator" format. It is almost the same thing as the
+      # +validates+ method that shipped with Rails, but this is customized to
+      # be using with attachment validators. This is helpful when you're using
+      # multiple attachment validators on a single attachment.
+      #
+      # Example of using the validator:
+      #
+      #   validates_attachment :avatar, :presence => true,
+      #      :content_type => { :content_type => "image/jpg" },
+      #      :size => { :in => 0..10.kilobytes }
+      #
+      def validates_attachment(*attributes)
+        options = attributes.extract_options!.dup
+
+        Paperclip::Validators.constants.each do |constant|
+          if constant.to_s =~ /\AAttachment(.+)Validator\z/
+            validator_kind = $1.underscore.to_sym
+
+            if options.key?(validator_kind)
+              validator_options = options.delete(validator_kind)
+              validator_options = {} if validator_options == true
+              conditional_options = options.slice(:if, :unless)
+              Array.wrap(validator_options).each do |local_options|
+                method_name = Paperclip::Validators.const_get(constant.to_s).helper_method_name
+                send(method_name, attributes, local_options.merge(conditional_options))
+              end
+            end
+          end
+        end
+      end
+
+      def validate_before_processing(validator_class, options)
+        options = options.dup
+        attributes = options.delete(:attributes)
+        attributes.each do |attribute|
+          options[:attributes] = [attribute]
+          create_validating_before_filter(attribute, validator_class, options)
+        end
+      end
+
+      def create_validating_before_filter(attribute, validator_class, options)
+        if_clause = options.delete(:if)
+        unless_clause = options.delete(:unless)
+        send(:"before_#{attribute}_validate", if: if_clause, unless: unless_clause) do |*_args|
+          validator_class.new(options.dup).validate(self)
+        end
+      end
+    end
+  end
+end