kt-paperclip 4.4.0

data/lib/paperclip/interpolations.rb

@@ -0,0 +1,197 @@
+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
+
+    # 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
+      self.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.kind_of? 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(".".freeze)
+    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, ".*".freeze)
+    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\.+/, "".freeze)
+    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 = unless mime_type.empty?
+        mime_type.first.extensions
+      else
+        []
+      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
+        ("%09d".freeze % id).scan(/\d{3}/).join("/".freeze)
+      when String
+        id.scan(/.{3}/).first(3).join("/".freeze)
+      else
+        nil
+      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/io_adapters/abstract_adapter.rb

@@ -0,0 +1,47 @@
+require 'active_support/core_ext/module/delegation'
+
+module Paperclip
+  class AbstractAdapter
+    OS_RESTRICTED_CHARACTERS = %r{[/:]}
+
+    attr_reader :content_type, :original_filename, :size
+    delegate :binmode, :binmode?, :close, :close!, :closed?, :eof?, :path, :rewind, :unlink, :to => :@tempfile
+    alias :length :size
+
+    def fingerprint
+      @fingerprint ||= Digest::MD5.file(path).to_s
+    end
+
+    def read(length = nil, buffer = nil)
+      @tempfile.read(length, buffer)
+    end
+
+    def inspect
+      "#{self.class}: #{self.original_filename}"
+    end
+
+    def original_filename=(new_filename)
+      return unless new_filename
+      @original_filename = new_filename.gsub(OS_RESTRICTED_CHARACTERS, "_")
+    end
+
+    def nil?
+      false
+    end
+
+    def assignment?
+      true
+    end
+
+    private
+
+    def destination
+      @destination ||= TempfileFactory.new.generate(@original_filename.to_s)
+    end
+
+    def copy_to_tempfile(src)
+      FileUtils.cp(src.path, destination.path)
+      destination
+    end
+  end
+end

data/lib/paperclip/io_adapters/attachment_adapter.rb

@@ -0,0 +1,36 @@
+module Paperclip
+  class AttachmentAdapter < AbstractAdapter
+    def initialize(target)
+      @target, @style = case target
+      when Paperclip::Attachment
+        [target, :original]
+      when Paperclip::Style
+        [target.attachment, target.name]
+      end
+
+      cache_current_values
+    end
+
+    private
+
+    def cache_current_values
+      self.original_filename = @target.original_filename
+      @content_type = @target.content_type
+      @tempfile = copy_to_tempfile(@target)
+      @size = @tempfile.size || @target.size
+    end
+
+    def copy_to_tempfile(source)
+      if source.staged?
+        FileUtils.cp(source.staged_path(@style), destination.path)
+      else
+        source.copy_to_local_file(@style, destination.path)
+      end
+      destination
+    end
+  end
+end
+
+Paperclip.io_adapters.register Paperclip::AttachmentAdapter do |target|
+  Paperclip::Attachment === target || Paperclip::Style === target
+end

data/lib/paperclip/io_adapters/data_uri_adapter.rb

@@ -0,0 +1,22 @@
+module Paperclip
+  class DataUriAdapter < StringioAdapter
+
+    REGEXP = /\Adata:([-\w]+\/[-\w\+\.]+)?;base64,(.*)/m
+
+    def initialize(target_uri)
+      super(extract_target(target_uri))
+    end
+
+    private
+
+    def extract_target(uri)
+      data_uri_parts = uri.match(REGEXP) || []
+      StringIO.new(Base64.decode64(data_uri_parts[2] || ''))
+    end
+
+  end
+end
+
+Paperclip.io_adapters.register Paperclip::DataUriAdapter do |target|
+  String === target && target =~ Paperclip::DataUriAdapter::REGEXP
+end

data/lib/paperclip/io_adapters/empty_string_adapter.rb

@@ -0,0 +1,18 @@
+module Paperclip
+  class EmptyStringAdapter < AbstractAdapter
+    def initialize(target)
+    end
+
+    def nil?
+      false
+    end
+
+    def assignment?
+      false
+    end
+  end
+end
+
+Paperclip.io_adapters.register Paperclip::EmptyStringAdapter do |target|
+  target.is_a?(String) && target.empty?
+end

data/lib/paperclip/io_adapters/file_adapter.rb

@@ -0,0 +1,22 @@
+module Paperclip
+  class FileAdapter < AbstractAdapter
+    def initialize(target)
+      @target = target
+      cache_current_values
+    end
+
+    private
+
+    def cache_current_values
+      self.original_filename = @target.original_filename if @target.respond_to?(:original_filename)
+      self.original_filename ||= File.basename(@target.path)
+      @tempfile = copy_to_tempfile(@target)
+      @content_type = ContentTypeDetector.new(@target.path).detect
+      @size = File.size(@target)
+    end
+  end
+end
+
+Paperclip.io_adapters.register Paperclip::FileAdapter do |target|
+  File === target || Tempfile === target
+end

data/lib/paperclip/io_adapters/http_url_proxy_adapter.rb

@@ -0,0 +1,16 @@
+module Paperclip
+  class HttpUrlProxyAdapter < UriAdapter
+
+    REGEXP = /\Ahttps?:\/\//
+
+    def initialize(target)
+      escaped = Paperclip::UrlGenerator.escape(target)
+      super(URI(target == Paperclip::UrlGenerator.unescape(target) ? escaped : target))
+    end
+
+  end
+end
+
+Paperclip.io_adapters.register Paperclip::HttpUrlProxyAdapter do |target|
+  String === target && target =~ Paperclip::HttpUrlProxyAdapter::REGEXP
+end

data/lib/paperclip/io_adapters/identity_adapter.rb

@@ -0,0 +1,12 @@
+module Paperclip
+  class IdentityAdapter < AbstractAdapter
+    def new(adapter)
+      adapter
+    end
+  end
+end
+
+Paperclip.io_adapters.register Paperclip::IdentityAdapter.new do |target|
+  Paperclip.io_adapters.registered?(target)
+end
+

data/lib/paperclip/io_adapters/nil_adapter.rb

@@ -0,0 +1,34 @@
+module Paperclip
+  class NilAdapter < AbstractAdapter
+    def initialize(target)
+    end
+
+    def original_filename
+      ""
+    end
+
+    def content_type
+      ""
+    end
+
+    def size
+      0
+    end
+
+    def nil?
+      true
+    end
+
+    def read(*args)
+      nil
+    end
+
+    def eof?
+      true
+    end
+  end
+end
+
+Paperclip.io_adapters.register Paperclip::NilAdapter do |target|
+  target.nil? || ( (Paperclip::Attachment === target) && !target.present? )
+end

data/lib/paperclip/io_adapters/registry.rb

@@ -0,0 +1,32 @@
+module Paperclip
+  class AdapterRegistry
+    class NoHandlerError < Paperclip::Error; end
+
+    attr_reader :registered_handlers
+
+    def initialize
+      @registered_handlers = []
+    end
+
+    def register(handler_class, &block)
+      @registered_handlers << [block, handler_class]
+    end
+
+    def handler_for(target)
+      @registered_handlers.each do |tester, handler|
+        return handler if tester.call(target)
+      end
+      raise NoHandlerError.new("No handler found for #{target.inspect}")
+    end
+
+    def registered?(target)
+      @registered_handlers.any? do |tester, handler|
+        handler === target
+      end
+    end
+
+    def for(target)
+      handler_for(target).new(target)
+    end
+  end
+end

data/lib/paperclip/io_adapters/stringio_adapter.rb

@@ -0,0 +1,33 @@
+module Paperclip
+  class StringioAdapter < AbstractAdapter
+    def initialize(target)
+      @target = target
+      cache_current_values
+    end
+
+    attr_writer :content_type
+
+    private
+
+    def cache_current_values
+      self.original_filename = @target.original_filename if @target.respond_to?(:original_filename)
+      self.original_filename ||= "data"
+      @tempfile = copy_to_tempfile(@target)
+      @content_type = ContentTypeDetector.new(@tempfile.path).detect
+      @size = @target.size
+    end
+
+    def copy_to_tempfile(source)
+      while data = source.read(16*1024)
+        destination.write(data)
+      end
+      destination.rewind
+      destination
+    end
+
+  end
+end
+
+Paperclip.io_adapters.register Paperclip::StringioAdapter do |target|
+  StringIO === target
+end

data/lib/paperclip/io_adapters/uploaded_file_adapter.rb

@@ -0,0 +1,42 @@
+module Paperclip
+  class UploadedFileAdapter < AbstractAdapter
+    def initialize(target)
+      @target = target
+      cache_current_values
+
+      if @target.respond_to?(:tempfile)
+        @tempfile = copy_to_tempfile(@target.tempfile)
+      else
+        @tempfile = copy_to_tempfile(@target)
+      end
+    end
+
+    class << self
+      attr_accessor :content_type_detector
+    end
+
+    private
+
+    def cache_current_values
+      self.original_filename = @target.original_filename
+      @content_type = determine_content_type
+      @size = File.size(@target.path)
+    end
+
+    def content_type_detector
+      self.class.content_type_detector
+    end
+
+    def determine_content_type
+      content_type = @target.content_type.to_s.strip
+      if content_type_detector
+        content_type = content_type_detector.new(@target.path).detect
+      end
+      content_type
+    end
+  end
+end
+
+Paperclip.io_adapters.register Paperclip::UploadedFileAdapter do |target|
+  target.class.name.include?("UploadedFile")
+end

data/lib/paperclip/io_adapters/uri_adapter.rb

@@ -0,0 +1,63 @@
+require 'open-uri'
+
+module Paperclip
+  class UriAdapter < AbstractAdapter
+    attr_writer :content_type
+
+    def initialize(target)
+      @target = target
+      @content = download_content
+      cache_current_values
+      @tempfile = copy_to_tempfile(@content)
+    end
+
+    private
+
+    def cache_current_values
+      self.content_type = content_type_from_content || "text/html"
+
+      self.original_filename = filename_from_content_disposition ||
+                               filename_from_path ||
+                               default_filename
+      @size = @content.size
+    end
+
+    def content_type_from_content
+      if @content.respond_to?(:content_type)
+        @content.content_type
+      end
+    end
+
+    def filename_from_content_disposition
+      if @content.meta.has_key?("content-disposition")
+        @content.meta["content-disposition"].
+          match(/filename="([^"]*)"/)[1]
+      end
+    end
+
+    def filename_from_path
+      @target.path.split("/").last
+    end
+
+    def default_filename
+      "index.html"
+    end
+
+    def download_content
+      open(@target)
+    end
+
+    def copy_to_tempfile(src)
+      while data = src.read(16*1024)
+        destination.write(data)
+      end
+      src.close
+      destination.rewind
+      destination
+    end
+  end
+end
+
+Paperclip.io_adapters.register Paperclip::UriAdapter do |target|
+  target.kind_of?(URI)
+end

data/lib/paperclip/locales/de.yml

@@ -0,0 +1,18 @@
+de:
+  errors:
+    messages:
+      in_between: "muss zwischen %{min} und %{max} sein"
+      spoofed_media_type: "trägt eine Dateiendung, die nicht mit dem Inhalt der Datei übereinstimmt"
+
+  number:
+    human:
+      storage_units:
+        format: "%n %u"
+        units:
+          byte:
+            one:   "Byte"
+            other: "Bytes"
+          kb: "KB"
+          mb: "MB"
+          gb: "GB"
+          tb: "TB"

data/lib/paperclip/locales/en.yml

@@ -0,0 +1,18 @@
+en:
+  errors:
+    messages:
+      in_between: "must be in between %{min} and %{max}"
+      spoofed_media_type: "has contents that are not what they are reported to be"
+
+  number:
+    human:
+      storage_units:
+        format: "%n %u"
+        units:
+          byte:
+            one:   "Byte"
+            other: "Bytes"
+          kb: "KB"
+          mb: "MB"
+          gb: "GB"
+          tb: "TB"

data/lib/paperclip/locales/es.yml

@@ -0,0 +1,18 @@
+es:
+  errors:
+    messages:
+      in_between: "debe estar entre %{min} y %{max}"
+      spoofed_media_type: "tiene una extensión que no coincide con su contenido"
+
+  number:
+    human:
+      storage_units:
+        format: "%n %u"
+        units:
+          byte:
+            one:   "Byte"
+            other: "Bytes"
+          kb: "KB"
+          mb: "MB"
+          gb: "GB"
+          tb: "TB"

data/lib/paperclip/locales/ja.yml

@@ -0,0 +1,18 @@
+ja:
+  errors:
+    messages:
+      in_between: "の容量は%{min}以上%{max}以下にしてください。"
+      spoofed_media_type: "の拡張子と内容が一致していません。"
+
+  number:
+    human:
+      storage_units:
+        format: "%n %u"
+        units:
+          byte:
+            one:   "Byte"
+            other: "Bytes"
+          kb: "KB"
+          mb: "MB"
+          gb: "GB"
+          tb: "TB"

data/lib/paperclip/locales/pt-BR.yml

@@ -0,0 +1,18 @@
+pt-BR:
+  errors:
+    messages:
+      in_between: "deve ter entre %{min} e %{max}"
+      spoofed_media_type: "tem uma extensão que não corresponde ao seu conteúdo"
+
+  number:
+    human:
+      storage_units:
+        format: "%n %u"
+        units:
+          byte:
+            one:   "Byte"
+            other: "Bytes"
+          kb: "KB"
+          mb: "MB"
+          gb: "GB"
+          tb: "TB"