dm-paperclip 2.4.1 → 2.5.0

data/lib/dm-paperclip/callbacks.rb

@@ -0,0 +1,55 @@
+module Paperclip; module Callbacks
+  class << self
+    def define(klass, name)
+      ["before_#{name}", "after_#{name}"].each do |method|
+        klass.define_singleton_method(method) do |callback|
+          callbacks = (@_C2DE8FA4_FDA9_45A9_8952_0AEFB571DCC1_callbacks ||= {})
+          callbacks[method] ||= []
+          callbacks[method] << callback
+          nil
+        end
+      end
+    end
+
+    def run(instance, name, &block)
+      return false if run_callbacks(instance, "before_#{name}") == false
+      result = yield
+      return false if result == false
+      return false if run_callbacks(instance, "after_#{name}", true) == false
+      block_given? ? result : true
+    end
+
+  private
+    def collect_callbacks(instance)
+      instance.class.ancestors.inject({}) do |memo, ancestor|
+        callbacks = ancestor.instance_variable_get(:@_C2DE8FA4_FDA9_45A9_8952_0AEFB571DCC1_callbacks)
+        if callbacks
+          callbacks.each do |name, methods|
+            memo[name] = methods + (memo[name] || [])
+          end
+        end
+        memo
+      end
+    end
+
+    def run_callbacks(instance, name, reversed = false)
+      #return true unless callbacks = instance.class._C2DE8FA4_FDA9_45A9_8952_0AEFB571DCC1_callbacks
+      return true unless callbacks = collect_callbacks(instance)
+      return true unless callbacks = callbacks[name]
+
+      callbacks = callbacks.reverse if reversed
+      callbacks.each do |callback|
+        result =
+          case callback
+          when Symbol
+            instance.send(callback)
+          when Proc
+            callback.call(instance)
+          end
+        return false if result == false
+      end
+
+      true
+    end
+  end
+end; end

data/lib/dm-paperclip/command_line.rb

@@ -0,0 +1,86 @@
+module Paperclip
+  class CommandLine
+    class << self
+      attr_accessor :path
+    end
+
+    def initialize(binary, params = "", options = {})
+      @binary            = binary.dup
+      @params            = params.dup
+      @options           = options.dup
+      @swallow_stderr    = @options.has_key?(:swallow_stderr) ? @options.delete(:swallow_stderr) : Paperclip.options[:swallow_stderr]
+      @expected_outcodes = @options.delete(:expected_outcodes)
+      @expected_outcodes ||= [0]
+    end
+
+    def command
+      cmd = []
+      cmd << full_path(@binary)
+      cmd << interpolate(@params, @options)
+      cmd << bit_bucket if @swallow_stderr
+      cmd.join(" ")
+    end
+
+    def run
+      Paperclip.log(command)
+      begin
+        output = self.class.send(:'`', command)
+      rescue Errno::ENOENT
+        raise Paperclip::CommandNotFoundError
+      end
+      if $?.exitstatus == 127
+        raise Paperclip::CommandNotFoundError
+      end
+      unless @expected_outcodes.include?($?.exitstatus)
+        raise Paperclip::PaperclipCommandLineError, "Command '#{command}' returned #{$?.exitstatus}. Expected #{@expected_outcodes.join(", ")}"
+      end
+      output
+    end
+
+    private
+
+    def full_path(binary)
+      [self.class.path, binary].compact.join("/")
+    end
+
+    def interpolate(pattern, vars)
+      # interpolates :variables and :{variables}
+      pattern.gsub(%r#:(?:\w+|\{\w+\})#) do |match|
+        key = match[1..-1]
+        key = key[1..-2] if key[0,1] == '{'
+        if invalid_variables.include?(key)
+          raise PaperclipCommandLineError,
+            "Interpolation of #{key} isn't allowed."
+        end
+        interpolation(vars, key) || match
+      end
+    end
+
+    def invalid_variables
+      %w(expected_outcodes swallow_stderr)
+    end
+
+    def interpolation(vars, key)
+      if vars.key?(key.to_sym)
+        shell_quote(vars[key.to_sym])
+      end
+    end
+
+    def shell_quote(string)
+      return "" if string.nil? or string !~ /\S/
+      if self.class.unix?
+        string.split("'").map{|m| "'#{m}'" }.join("\\'")
+      else
+        %{"#{string}"}
+      end
+    end
+
+    def bit_bucket
+      self.class.unix? ? "2>/dev/null" : "2>NUL"
+    end
+
+    def self.unix?
+      File.exist?("/dev/null")
+    end
+  end
+end

data/lib/dm-paperclip/ext/blank.rb

@@ -0,0 +1,24 @@
+module Paperclip
+  module Ext
+    # Determines whether the specified +value+ is blank.
+    #
+    # An object is blank if it's false, empty, or a whitespace string.
+    # For example, "", "   ", +nil+, [], and {} are blank.
+    #
+    # @api semipublic
+    def self.blank?(value)
+      case value
+      when ::NilClass, ::FalseClass
+        true
+      when ::TrueClass, ::Numeric
+        false
+      when ::Array, ::Hash
+        value.empty?
+      when ::String
+        value !~ /\S/
+      else
+        value.nil? || (value.respond_to?(:empty?) && value.empty?)
+      end
+    end
+  end
+end

data/lib/dm-paperclip/ext/class.rb

@@ -0,0 +1,50 @@
+module Paperclip; module Ext
+  module Class
+    def self.inheritable_attributes(klass)
+      unless klass.instance_variable_defined?(IVar)
+        klass.instance_variable_set(IVar, EMPTY_INHERITABLE_ATTRIBUTES)
+      end
+      klass.instance_variable_get(IVar)
+    end
+
+    def self.write_inheritable_attribute(klass, key, value)
+      if inheritable_attributes(klass).equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+        klass.instance_variable_set(IVar, {})
+      end
+      inheritable_attributes(klass)[key] = value
+    end
+
+    def self.read_inheritable_attribute(klass, key)
+      inheritable_attributes(klass)[key]
+    end
+
+    def self.reset_inheritable_attributes(klass)
+      klass.instance_variable_set(IVar, EMPTY_INHERITABLE_ATTRIBUTES)
+    end
+
+    module Hook
+      def inherited(base)
+        super
+
+        attributes = ::Paperclip::Ext::Class.inheritable_attributes(self)
+        new_attributes =
+          if attributes.equal?(::Paperclip::Ext::Class::EMPTY_INHERITABLE_ATTRIBUTES)
+            ::Paperclip::Ext::Class::EMPTY_INHERITABLE_ATTRIBUTES
+          else
+            attributes.inject({}) do |memo, (key, value)|
+              memo[key] = ::Paperclip::Ext.try_dup(value.dup)
+              memo
+            end
+          end
+
+        base.instance_variable_set(::Paperclip::Ext::Class::IVar, new_attributes)
+      end
+    end
+
+  private
+    IVar = "@_C2DE8FA4_FDA9_45A9_8952_0AEFB571DCC1_inheritable_attributes"
+
+    # Prevent this constant from being created multiple times
+    EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze
+  end
+end; end

data/lib/dm-paperclip/ext/compatibility.rb

@@ -0,0 +1,11 @@
+module Kernel
+  def singleton_class
+    (class << self; self; end)
+  end unless method_defined?(:singleton_class)
+end
+
+class Class
+  def define_singleton_method(*args, &block)
+    singleton_class.module_eval { define_method(*args, &block) }
+  end unless method_defined?(:define_singleton_method)
+end

data/lib/dm-paperclip/ext/try_dup.rb

@@ -0,0 +1,12 @@
+module Paperclip
+  module Ext
+    def self.try_dup(value)
+      case value
+      when ::TrueClass, ::FalseClass, ::NilClass, ::Module, ::Numeric, ::Symbol
+        value
+      else
+        value.dup
+      end
+    end
+  end
+end

data/lib/dm-paperclip/geometry.rb

@@ -6,10 +6,8 @@ module Paperclip
 
     # Gives a Geometry representing the given height and width
     def initialize width = nil, height = nil, modifier = nil
-      height = nil if height == ''
-      width  = nil if width  == ''
-      @height = (height || width).to_f
-      @width  = (width  || height).to_f
+      @height = height.to_f
+      @width  = width.to_f
       @modifier = modifier
     end
 
@@ -18,7 +16,7 @@ module Paperclip
     def self.from_file file
       file = file.path if file.respond_to? "path"
       geometry = begin
-                   Paperclip.run("identify", %Q[-format "%wx%h" "#{file}"[0]])
+                   Paperclip.run("identify", "-format %wx%h :file", :file => "#{file}[0]")
                  rescue PaperclipCommandLineError
                    ""
                  end

data/lib/dm-paperclip/interpolations.rb

@@ -27,6 +27,7 @@ module Paperclip
     # and the arguments to pass, which are the attachment and style name.
     def self.interpolate pattern, *args
       all.reverse.inject( pattern.dup ) do |result, tag|
+
         result.gsub(/:#{tag}/) do |match|
           send( tag, *args )
         end
@@ -34,41 +35,45 @@ module Paperclip
     end
 
     # Returns the filename, the same way as ":basename.:extension" would.
-    def filename attachment, style
-      "#{basename(attachment, style)}.#{extension(attachment, style)}"
+    def filename attachment, style_name
+      "#{basename(attachment, style_name)}.#{extension(attachment, style_name)}"
     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.
-    def url attachment, style
-      raise InfiniteInterpolationError if attachment.options[:url].include?(":url")
-      attachment.url(style, false)
+    RIGHT_HERE = "#{__FILE__.gsub(%r{^\./}, "")}:#{__LINE__ + 3}"
+    def url attachment, style_name
+      raise InfiniteInterpolationError if caller.any?{|b| b.index(RIGHT_HERE) }
+      attachment.url(style_name, false)
     end
 
     # Returns the timestamp as defined by the <attachment>_updated_at field
-    def timestamp attachment, style
+    def timestamp attachment, style_name
       attachment.instance_read(:updated_at).to_s
     end
 
-    def web_root attachment, style
-      if Object.const_defined?('Merb')
-        merb_root(attachment, style)
-      elsif Object.const_defined("RAILS_ROOT")
-        rails_root(attachment, style)
-      else
-        ""
-      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
-      Object.const_defined?('RAILS_ROOT') ? RAILS_ROOT : nil
+    def web_root attachment, style
+     Paperclip.config.root ||
+     merb_root(attachment, style) ||
+     rails_root(attachment, style) ||
+     ""
+     end
+
+    # Returns the Rails.root constant.
+    def rails_root attachment, style_name
+      Object.const_defined?('Rails') ? Rails.root : nil
     end
 
-    # Returns the RAILS_ENV constant.
-    def rails_env attachment, style
-      Object.const_defined?('RAILS_ENV') ? RAILS_ENV : nil
+    # Returns the Rails.env constant.
+    def rails_env attachment, style_name
+      Object.const_defined?('Rails') ? Rails.env : nil
     end
 
     def merb_root attachment, style
@@ -79,45 +84,65 @@ module Paperclip
       Object.const_defined?('Merb') ? Merb.env : nil
     end
 
-    # Returns the snake cased, pluralized version of the class name.
+    # Returns the underscored, pluralized version of the class name.
     # e.g. "users" for the User class.
-    def class attachment, style
-      attachment.instance.class.to_s.snake_case.pluralize
+    # 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?
+      name = DataMapper::Inflector.underscore(attachment.instance.class.to_s)
+      DataMapper::Inflector.pluralize(name)
     end
 
     # Returns the basename of the file. e.g. "file" for "file.jpg"
-    def basename attachment, style
+    def basename attachment, style_name
       attachment.original_filename.gsub(/#{File.extname(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
-      ((style = attachment.styles[style]) && style[:format]) ||
+    def extension attachment, style_name
+      ((style = attachment.styles[style_name]) && style[:format]) ||
         File.extname(attachment.original_filename).gsub(/^\.+/, "")
     end
 
     # Returns the id of the instance.
-    def id attachment, style
+    def id attachment, style_name
       attachment.instance.id
     end
 
+    # Returns the fingerprint of the instance.
+    def fingerprint attachment, style_name
+      attachment.fingerprint
+    end
+
+    # Returns a the attachment hash.  See Paperclip::Attachment#hash for
+    # more details.
+    def hash attachment, style_name
+      attachment.hash(style_name)
+    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
+    def id_partition attachment, style_name
       ("%09d" % attachment.instance.id).scan(/\d{3}/).join("/")
     end
 
     # Returns the pluralized form of the attachment name. e.g.
     # "avatars" for an attachment of :avatar
-    def attachment attachment, style
-      attachment.name.to_s.downcase.pluralize
+    def attachment attachment, style_name
+      DataMapper::Inflector.pluralize(attachment.name.to_s.downcase)
     end
 
     # Returns the style, or the default style if nil is supplied.
-    def style attachment, style
-      style || attachment.default_style
+    def style attachment, style_name
+      style_name || attachment.default_style
+    end
+
+    # Returns the uuid of the instance.
+    def uuid attachment, style_name
+      attachment.instance.uuid
     end
   end
 end

data/lib/dm-paperclip/iostream.rb

@@ -1,48 +1,34 @@
 # Provides method that can be included on File-type objects (IO, StringIO, Tempfile, etc) to allow stream copying
 # and Tempfile conversion.
 module IOStream
-
   # Returns a Tempfile containing the contents of the readable object.
-  def to_tempfile
-    name = respond_to?(:original_filename) ? original_filename : (respond_to?(:path) ? path : "stream")
-    tempfile = Paperclip::Tempfile.new(File.basename(name))
+  def to_tempfile(object)
+    return object.to_tempfile if object.respond_to?(:to_tempfile)
+    name = object.respond_to?(:original_filename) ? object.original_filename : (object.respond_to?(:path) ? object.path : "stream")
+    tempfile = Paperclip::Tempfile.new(["stream", File.extname(name)])
     tempfile.binmode
-    self.stream_to(tempfile)
+    stream_to(object, tempfile)
   end
 
   # Copies one read-able object from one place to another in blocks, obviating the need to load
-  # the whole thing into memory. Defaults to 8k blocks. If this module is included in both
-  # StringIO and Tempfile, then either can have its data copied anywhere else without typing
-  # worries or memory overhead worries. Returns a File if a String is passed in as the destination
-  # and returns the IO or Tempfile as passed in if one is sent as the destination.
-  def stream_to path_or_file, in_blocks_of = 8192
+  # the whole thing into memory. Defaults to 8k blocks. Returns a File if a String is passed
+  # in as the destination and returns the IO or Tempfile as passed in if one is sent as the destination.
+  def stream_to object, path_or_file, in_blocks_of = 8192
     dstio = case path_or_file
             when String   then File.new(path_or_file, "wb+")
             when IO       then path_or_file
             when Tempfile then path_or_file
             end
     buffer = ""
-    self.rewind
-    while self.read(in_blocks_of, buffer) do
+    object.rewind
+    while object.read(in_blocks_of, buffer) do
       dstio.write(buffer)
     end
-    dstio.rewind    
+    dstio.rewind
     dstio
   end
 end
 
-class IO #:nodoc:
-  include IOStream
-end
-
-%w( Tempfile StringIO ).each do |klass|
-  if Object.const_defined? klass
-    Object.const_get(klass).class_eval do
-      include IOStream
-    end
-  end
-end
-
 # Corrects a bug in Windows when asking for Tempfile size.
 if defined? Tempfile
   class Tempfile
@@ -56,4 +42,4 @@ if defined? Tempfile
       end
     end
   end
-end
+end