kt-paperclip 6.2.0

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,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::Base
+
+      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,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.rb

@@ -0,0 +1,201 @@
+module Paperclip
+  # This module contains all the methods that are available for interpolation
+  # in paths and urls. To add your own (or override an existing one), you
+  # can either open this module and define it, or call the
+  # 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,
+    # and is not intended for normal use.
+    def self.[](name)
+      method(name)
+    end
+
+    # Returns a sorted list of all interpolations.
+    def self.all
+      instance_methods(false).sort!
+    end
+
+    # Perform the actual interpolation. Takes the pattern to interpolate
+    # and the arguments to pass, which are the attachment and style name.
+    # You can pass a method name on your record as a symbol, which should turn
+    # an interpolation pattern for Paperclip to use.
+    def self.interpolate(pattern, *args)
+      pattern = args.first.instance.send(pattern) if pattern.is_a? Symbol
+      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)].delete_if(&:empty?).join(".")
+    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{\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)
+    end
+
+    # Returns the timestamp as defined by the <attachment>_updated_at field
+    # in the server default time zone unless :use_global_time_zone is set
+    # to false.  Note that a Rails.config.time_zone change will still
+    # invalidate any path or URL that uses :timestamp.  For a
+    # time_zone-agnostic timestamp, use #updated_at.
+    def timestamp(attachment, _style_name)
+      attachment.instance_read(:updated_at).in_time_zone(attachment.time_zone).to_s
+    end
+
+    # Returns an integer timestamp that is time zone-neutral, so that paths
+    # remain valid even if a server's time zone changes.
+    def updated_at(attachment, _style_name)
+      attachment.updated_at
+    end
+
+    # Returns the Rails.root constant.
+    def rails_root(_attachment, _style_name)
+      Rails.root
+    end
+
+    # Returns the Rails.env constant.
+    def rails_env(_attachment, _style_name)
+      Rails.env
+    end
+
+    # Returns the underscored, pluralized version of the class name.
+    # e.g. "users" for the User class.
+    # NOTE: The arguments need to be optional, because some tools fetch
+    # 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?
+
+      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)
+      File.basename(attachment.original_filename, ".*")
+    end
+
+    # Returns the 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.
+    def extension(attachment, style_name)
+      ((style = attachment.styles[style_name.to_s.to_sym]) && style[:format]) ||
+        File.extname(attachment.original_filename).sub(/\A\.+/, "")
+    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
+    # "image/jpeg". If the style has a specified format, it will override the
+    # content-type detection.
+    #
+    # Each mime type generally has multiple extensions associated with it, so
+    # if the extension from the original filename is one of these extensions,
+    # that extension is used, otherwise, the first in the list is used.
+    def content_type_extension(attachment, style_name)
+      mime_type = MIME::Types[attachment.content_type]
+      extensions_for_mime_type = if mime_type.empty?
+                                   []
+                                 else
+                                   mime_type.first.extensions
+                                 end
+
+      original_extension = extension(attachment, style_name)
+      style = attachment.styles[style_name.to_s.to_sym]
+      if style && style[:format]
+        style[:format].to_s
+      elsif extensions_for_mime_type.include? original_extension
+        original_extension
+      elsif !extensions_for_mime_type.empty?
+        extensions_for_mime_type.first
+      else
+        # 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{/([^/]*)\z}.match(attachment.content_type)[1]
+      end
+    end
+
+    # Returns the id of the instance.
+    def id(attachment, _style_name)
+      attachment.instance.id
+    end
+
+    # Returns the #to_param of the instance.
+    def param(attachment, _style_name)
+      attachment.instance.to_param
+    end
+
+    # Returns the fingerprint of the instance.
+    def fingerprint(attachment, _style_name)
+      attachment.fingerprint
+    end
+
+    # Returns a the attachment hash.  See Paperclip::Attachment#hash_key for
+    # more details.
+    def hash(attachment = nil, style_name = nil)
+      if attachment && style_name
+        attachment.hash_key(style_name)
+      else
+        super()
+      end
+    end
+
+    # Returns the id of the instance in a split path form. e.g. returns
+    # 000/001/234 for an id of 1234.
+    def id_partition(attachment, _style_name)
+      case id = attachment.instance.id
+      when Integer
+        if id < ID_PARTITION_LIMIT
+          ("%09d" % id).scan(/\d{3}/).join("/")
+        else
+          ("%012d" % id).scan(/\d{3}/).join("/")
+        end
+      when String
+        id.scan(/.{3}/).first(3).join("/")
+      end
+    end
+
+    # Returns the pluralized form of the attachment name. e.g.
+    # "avatars" for an attachment of :avatar
+    def attachment(attachment, _style_name)
+      plural_cache.pluralize_symbol(attachment.name)
+    end
+
+    # Returns the style, or the default style if nil is supplied.
+    def style(attachment, style_name)
+      style_name || attachment.default_style
+    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