cloudfuji_paperclip 2.4.6 → 3.0.3

data/lib/paperclip/attachment.rb

@@ -7,33 +7,32 @@ module Paperclip
   # when the model saves, deletes when the model is destroyed, and processes
   # the file upon assignment.
   class Attachment
-    include IOStream
-
     def self.default_options
       @default_options ||= {
-        :url                   => "/system/:attachment/:id/:style/:filename",
-        :path                  => ":rails_root/public:url",
-        :styles                => {},
+        :convert_options       => {},
+        :default_style         => :original,
+        :default_url           => "/:attachment/:style/missing.png",
+        :restricted_characters => /[&$+,\/:;=?@<>\[\]\{\}\|\\\^~%# ]/,
+        :hash_data             => ":class/:attachment/:id/:style/:updated_at",
+        :hash_digest           => "SHA1",
+        :interpolator          => Paperclip::Interpolations,
         :only_process          => [],
+        :path                  => ":rails_root/public:url",
+        :preserve_files        => false,
         :processors            => [:thumbnail],
-        :convert_options       => {},
         :source_file_options   => {},
-        :default_url           => "/:attachment/:style/missing.png",
-        :default_style         => :original,
         :storage               => :filesystem,
-        :use_timestamp         => true,
-        :whiny                 => Paperclip.options[:whiny] || Paperclip.options[:whiny_thumbnails],
+        :styles                => {},
+        :url                   => "/system/:class/:attachment/:id_partition/:style/:filename",
+        :url_generator         => Paperclip::UrlGenerator,
         :use_default_time_zone => true,
-        :hash_digest           => "SHA1",
-        :hash_data             => ":class/:attachment/:id/:style/:updated_at",
-        :preserve_files        => false,
-        :interpolator          => Paperclip::Interpolations,
-        :url_generator         => Paperclip::UrlGenerator
+        :use_timestamp         => true,
+        :whiny                 => Paperclip.options[:whiny] || Paperclip.options[:whiny_thumbnails]
       }
     end
 
-    attr_reader :name, :instance, :default_style, :convert_options, :queued_for_write, :whiny, :options, :interpolator
-    attr_reader :source_file_options, :whiny
+    attr_reader :name, :instance, :default_style, :convert_options, :queued_for_write, :whiny,
+                :options, :interpolator, :source_file_options, :whiny
     attr_accessor :post_processing
 
     # Creates an Attachment object. +name+ is the name of the attachment,
@@ -89,28 +88,16 @@ module Paperclip
     #   new_user.avatar = old_user.avatar
     def assign uploaded_file
       ensure_required_accessors!
+      file = Paperclip.io_adapters.for(uploaded_file)
 
-      if uploaded_file.is_a?(Paperclip::Attachment)
-        uploaded_filename = uploaded_file.original_filename
-        uploaded_file = uploaded_file.to_file(:original)
-        close_uploaded_file = uploaded_file.respond_to?(:close)
-      else
-        instance_write(:uploaded_file, uploaded_file) if uploaded_file
-      end
-
-      return nil unless valid_assignment?(uploaded_file)
+      self.clear(*@options[:only_process])
+      return nil if file.nil?
 
-      uploaded_file.binmode if uploaded_file.respond_to? :binmode
-      self.clear
-
-      return nil if uploaded_file.nil?
-
-      uploaded_filename ||= uploaded_file.original_filename
-      @queued_for_write[:original]   = to_tempfile(uploaded_file)
-      instance_write(:file_name,       uploaded_filename.strip)
-      instance_write(:content_type,    uploaded_file.content_type.to_s.strip)
-      instance_write(:file_size,       uploaded_file.size.to_i)
-      instance_write(:fingerprint,     generate_fingerprint(uploaded_file))
+      @queued_for_write[:original]   = file
+      instance_write(:file_name,       cleanup_filename(file.original_filename))
+      instance_write(:content_type,    file.content_type.to_s.strip)
+      instance_write(:file_size,       file.size)
+      instance_write(:fingerprint,     file.fingerprint) if instance_respond_to?(:fingerprint)
       instance_write(:updated_at,      Time.now)
 
       @dirty = true
@@ -118,10 +105,8 @@ module Paperclip
       post_process(*@options[:only_process]) if post_processing
 
       # Reset the file size if the original file was reprocessed.
-      instance_write(:file_size,   @queued_for_write[:original].size.to_i)
-      instance_write(:fingerprint, generate_fingerprint(@queued_for_write[:original]))
-    ensure
-      uploaded_file.close if close_uploaded_file
+      instance_write(:file_size,   @queued_for_write[:original].size)
+      instance_write(:fingerprint, @queued_for_write[:original].fingerprint) if instance_respond_to?(:fingerprint)
     end
 
     # Returns the public URL of the attachment with a given style. This does
@@ -217,10 +202,14 @@ module Paperclip
     # Clears out the attachment. Has the same effect as previously assigning
     # nil to the attachment. Does NOT save. If you wish to clear AND save,
     # use #destroy.
-    def clear
-      queue_existing_for_delete
-      @queued_for_write  = {}
-      @errors            = {}
+    def clear(*styles_to_clear)
+      if styles_to_clear.any?
+        queue_some_for_delete(*styles_to_clear)
+      else
+        queue_all_for_delete
+        @queued_for_write  = {}
+        @errors            = {}
+      end
     end
 
     # Destroys the attachment. Has the same effect as previously assigning
@@ -250,10 +239,10 @@ module Paperclip
       instance_read(:file_size) || (@queued_for_write[:original] && @queued_for_write[:original].size)
     end
 
-    # Returns the hash of the file as originally assigned, and lives in the
-    # <attachment>_fingerprint attribute of the model.
+    # Returns the fingerprint of the file, if one's defined. The fingerprint is
+    # stored in the <attachment>_fingerpring attribute of the model.
     def fingerprint
-      instance_read(:fingerprint) || (@queued_for_write[:original] && generate_fingerprint(@queued_for_write[:original]))
+      instance_read(:fingerprint)
     end
 
     # Returns the content_type of the file as originally assigned, and lives
@@ -277,60 +266,28 @@ module Paperclip
 
     # Returns a unique hash suitable for obfuscating the URL of an otherwise
     # publicly viewable attachment.
-    def hash(style_name = default_style)
+    def hash_key(style_name = default_style)
       raise ArgumentError, "Unable to generate hash without :hash_secret" unless @options[:hash_secret]
       require 'openssl' unless defined?(OpenSSL)
       data = interpolate(@options[:hash_data], style_name)
       OpenSSL::HMAC.hexdigest(OpenSSL::Digest.const_get(@options[:hash_digest]).new, @options[:hash_secret], data)
     end
 
-    def generate_fingerprint(source)
-      if source.respond_to?(:path) && source.path && !source.path.blank?
-        Digest::MD5.file(source.path).to_s
-      else
-        data = source.read
-        source.rewind if source.respond_to?(:rewind)
-        Digest::MD5.hexdigest(data)
-      end
-    end
-
-    # Paths and URLs can have a number of variables interpolated into them
-    # to vary the storage location based on name, id, style, class, etc.
-    # This method is a deprecated access into supplying and retrieving these
-    # interpolations. Future access should use either Paperclip.interpolates
-    # or extend the Paperclip::Interpolations module directly.
-    def self.interpolations
-      warn('[DEPRECATION] Paperclip::Attachment.interpolations is deprecated ' +
-           'and will be removed from future versions. ' +
-           'Use Paperclip.interpolates instead')
-      Paperclip::Interpolations
-    end
-
     # This method really shouldn't be called that often. It's expected use is
     # in the paperclip:refresh rake task and that's it. It will regenerate all
     # thumbnails forcefully, by reobtaining the original file and going through
     # the post-process again.
     def reprocess!(*style_args)
-      new_original = Tempfile.new("paperclip-reprocess")
-      new_original.binmode
-      if old_original = to_file(:original)
-        new_original.write( old_original.respond_to?(:get) ? old_original.get : old_original.read )
-        new_original.rewind
-
-        @queued_for_write = { :original => new_original }
-        instance_write(:updated_at, Time.now)
-        post_process(*style_args)
-
-        old_original.close if old_original.respond_to?(:close)
-        old_original.unlink if old_original.respond_to?(:unlink)
-
+      saved_only_process, @options[:only_process] = @options[:only_process], style_args
+      begin
+        assign(self)
         save
-      else
-        true
+      rescue Errno::EACCES => e
+        warn "#{e} - skipping file."
+        false
+      ensure
+        @options[:only_process] = saved_only_process
       end
-    rescue Errno::EACCES => e
-      warn "#{e} - skipping file"
-      false
     end
 
     # Returns true if a file has been assigned.
@@ -340,6 +297,12 @@ module Paperclip
 
     alias :present? :file?
 
+    # Determines whether the instance responds to this attribute. Used to prevent
+    # calculations on fields we won't even store.
+    def instance_respond_to?(attr)
+      instance.respond_to?(:"#{name}_#{attr}")
+    end
+
     # Writes the attachment-specific attribute on the instance. For example,
     # instance_write(:file_name, "me.jpg") will write "me.jpg" to the instance's
     # "avatar_file_name" field (assuming the attachment is called avatar).
@@ -369,7 +332,7 @@ module Paperclip
     def ensure_required_accessors! #:nodoc:
       %w(file_name).each do |field|
         unless @instance.respond_to?("#{name}_#{field}") && @instance.respond_to?("#{name}_#{field}=")
-          raise PaperclipError.new("#{@instance.class} model missing required attr_accessor for '#{name}_#{field}'")
+          raise Paperclip::Error.new("#{@instance.class} model missing required attr_accessor for '#{name}_#{field}'")
         end
       end
     end
@@ -387,7 +350,7 @@ module Paperclip
       begin
         storage_module = Paperclip::Storage.const_get(storage_class_name)
       rescue NameError
-        raise StorageMethodNotFound, "Cannot load storage module '#{storage_class_name}'"
+        raise Errors::StorageMethodNotFound, "Cannot load storage module '#{storage_class_name}'"
       end
       self.extend(storage_module)
     end
@@ -420,26 +383,40 @@ module Paperclip
     end
 
     def post_process_styles(*style_args) #:nodoc:
-      styles.each do |name, style|
-        begin
-          if style_args.empty? || style_args.include?(name)
-            raise RuntimeError.new("Style #{name} has no processors defined.") if style.processors.blank?
-            @queued_for_write[name] = style.processors.inject(@queued_for_write[:original]) do |file, processor|
-              Paperclip.processor(processor).make(file, style.processor_options, self)
-            end
-          end
-        rescue PaperclipError => e
-          log("An error was received while processing: #{e.inspect}")
-          (@errors[:processing] ||= []) << e.message if @options[:whiny]
+      post_process_style(:original, styles[:original]) if styles.include?(:original) && process_style?(:original, style_args)
+      styles.reject{ |name, style| name == :original }.each do |name, style|
+        post_process_style(name, style) if process_style?(name, style_args)
+      end
+    end
+
+    def post_process_style(name, style) #:nodoc:
+      begin
+        raise RuntimeError.new("Style #{name} has no processors defined.") if style.processors.blank?
+        @queued_for_write[name] = style.processors.inject(@queued_for_write[:original]) do |file, processor|
+          Paperclip.processor(processor).make(file, style.processor_options, self)
         end
+        @queued_for_write[name] = Paperclip.io_adapters.for(@queued_for_write[name])
+      rescue Paperclip::Error => e
+        log("An error was received while processing: #{e.inspect}")
+        (@errors[:processing] ||= []) << e.message if @options[:whiny]
       end
     end
 
+    def process_style?(style_name, style_args) #:nodoc:
+      style_args.empty? || style_args.include?(style_name)
+    end
+
     def interpolate(pattern, style_name = default_style) #:nodoc:
       interpolator.interpolate(pattern, self, style_name)
     end
 
-    def queue_existing_for_delete #:nodoc:
+    def queue_some_for_delete(*styles)
+      @queued_for_delete += styles.uniq.map do |style|
+        path(style) if exists?(style)
+      end.compact
+    end
+
+    def queue_all_for_delete #:nodoc:
       return if @options[:preserve_files] || !file?
       @queued_for_delete += [:original, *styles.keys].uniq.map do |style|
         path(style) if exists?(style)
@@ -447,6 +424,7 @@ module Paperclip
       instance_write(:file_name, nil)
       instance_write(:content_type, nil)
       instance_write(:file_size, nil)
+      instance_write(:fingerprint, nil)
       instance_write(:updated_at, nil)
     end
 
@@ -458,11 +436,12 @@ module Paperclip
 
     # called by storage after the writes are flushed and before @queued_for_writes is cleared
     def after_flush_writes
-      @queued_for_write.each do |style, file|
-        file.close unless file.closed?
-        file.unlink if file.respond_to?(:unlink) && file.path.present? && File.exist?(file.path)
-      end
     end
 
+    def cleanup_filename(filename)
+      if @options[:restricted_characters]
+        filename.gsub(@options[:restricted_characters], '_')
+      end
+    end
   end
 end

data/lib/paperclip/attachment_options.rb

@@ -0,0 +1,9 @@
+module Paperclip
+  class AttachmentOptions < Hash
+    def initialize(options)
+      options.each do |k, v|
+        self.[]=(k, v)
+      end
+    end
+  end
+end

data/lib/paperclip/callbacks.rb

@@ -0,0 +1,30 @@
+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 => "result == false"}].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
+    end
+
+    module Running
+      def run_paperclip_callbacks(callback, opts = nil, &block)
+        run_callbacks(callback, opts, &block)
+      end
+    end
+  end
+end

data/lib/paperclip/errors.rb

@@ -0,0 +1,27 @@
+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
+
+    # Will be thrown when ImageMagic cannot determine the uploaded file's
+    # metadata, usually this would mean the file is not an image.
+    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/geometry.rb

@@ -17,16 +17,18 @@ module Paperclip
     # a Tempfile object, which would be eligible for file deletion when no longer referenced.
     def self.from_file file
       file_path = file.respond_to?(:path) ? file.path : file
-      raise(Paperclip::NotIdentifiedByImageMagickError.new("Cannot find the geometry of a file with a blank name")) if file_path.blank?
+      raise(Errors::NotIdentifiedByImageMagickError.new("Cannot find the geometry of a file with a blank name")) if file_path.blank?
       geometry = begin
-                   Paperclip.run("identify", "-format %wx%h :file", :file => "#{file_path}[0]")
+                   silence_stream(STDERR) do
+                     Paperclip.run("identify", "-format %wx%h :file", :file => "#{file_path}[0]")
+                   end
                  rescue Cocaine::ExitStatusError
                    ""
                  rescue Cocaine::CommandNotFoundError => e
-                   raise Paperclip::CommandNotFoundError.new("Could not run the `identify` command. Please install ImageMagick.")
+                   raise Errors::CommandNotFoundError.new("Could not run the `identify` command. Please install ImageMagick.")
                  end
       parse(geometry) ||
-        raise(NotIdentifiedByImageMagickError.new("#{file_path} is not recognized by the 'identify' command."))
+        raise(Errors::NotIdentifiedByImageMagickError.new("#{file_path} is not recognized by the 'identify' command."))
     end
 
     # Parses a "WxH" formatted string, where W is the width and H is the height.

data/lib/paperclip/glue.rb

@@ -0,0 +1,23 @@
+require 'paperclip/callbacks'
+require 'paperclip/validators'
+require 'paperclip/schema'
+
+module Paperclip
+  module Glue
+    def self.included base #:nodoc:
+      base.extend ClassMethods
+      base.send :include, Callbacks
+      base.send :include, Validators
+      base.class_attribute :attachment_definitions
+
+      if defined?(ActiveRecord)
+        ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, Paperclip::Schema)
+        ActiveRecord::ConnectionAdapters::Table.send(:include, Paperclip::Schema)
+        ActiveRecord::ConnectionAdapters::TableDefinition.send(:include, Paperclip::Schema)
+      end
+
+      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/helpers.rb

@@ -0,0 +1,71 @@
+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
+    # and some options:
+    #
+    #   :command_path -> A $PATH-like variable that defines where to look for the binary
+    #                    on the filesystem. Colon-separated, just like $PATH.
+    #
+    #   :expected_outcodes -> An array of integers that defines the expected exit codes
+    #                         of the binary. Defaults to [0].
+    #
+    #   :log_command -> Log the command being run when set to true (defaults to false).
+    #                   This will only log if logging in general is set to true as well.
+    #
+    #   :swallow_stderr -> Set to true if you don't care what happens on STDERR.
+    #
+    def run(cmd, arguments = "", local_options = {})
+      command_path = options[:command_path]
+      Cocaine::CommandLine.path = ( Cocaine::CommandLine.path ? [Cocaine::CommandLine.path].flatten | [command_path] : command_path )
+      local_options = local_options.merge(:logger => logger) if logging? && (options[:log_command] || local_options[:log_command])
+      Cocaine::CommandLine.new(cmd, arguments, local_options).run
+    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)
+      unscope_method = class_for(klass).respond_to?(:unscoped) ? :unscoped : :with_exclusive_scope
+      class_for(klass).send(unscope_method) do
+        class_for(klass).find_each(:conditions => "#{name}_file_name is not null") do |instance|
+          yield(instance)
+        end
+      end
+    end
+
+    def class_for(class_name)
+      # Ruby 1.9 introduces an inherit argument for Module#const_get and
+      # #const_defined? and changes their default behavior.
+      # https://github.com/rails/rails/blob/v3.0.9/activesupport/lib/active_support/inflector/methods.rb#L89
+      if Module.method(:const_get).arity == 1
+        class_name.split('::').inject(Object) do |klass, partial_class_name|
+          klass.const_defined?(partial_class_name) ? klass.const_get(partial_class_name) : klass.const_missing(partial_class_name)
+        end
+      else
+        class_name.split('::').inject(Object) do |klass, partial_class_name|
+          klass.const_defined?(partial_class_name) ? klass.const_get(partial_class_name, false) : klass.const_missing(partial_class_name)
+        end
+      end
+    end
+
+    def check_for_url_clash(name,url,klass)
+      @names_url ||= {}
+      default_url = url || Attachment.default_options[:url]
+      if @names_url[name] && @names_url[name][:url] == default_url && @names_url[name][:class] != klass && @names_url[name][:url] !~ /:class/
+        log("Duplicate URL for #{name} with #{default_url}. This will clash with attachment defined in #{@names_url[name][:class]} class")
+      end
+      @names_url[name] = {:url => default_url, :class => klass}
+    end
+
+    def reset_duplicate_clash_check!
+      @names_url = nil
+    end
+  end
+end