paperclip-cloudfiles 2.3.1.1.6 → 2.3.2

data/README.rdoc

@@ -174,6 +174,11 @@ NOTE: Post processing will not even *start* if the attachment is not valid
 according to the validations. Your callbacks and processors will *only* be
 called with valid attachments.
 
+==Testing
+
+Paperclip provides rspec-compatible matchers for testing attachments. See the
+documentation on Paperclip::Shoulda::Matchers for more information.
+
 ==Contributing
 
 If you'd like to contribute a feature or bugfix: Thanks! To make sure your

data/Rakefile

@@ -8,6 +8,11 @@ require 'paperclip'
 desc 'Default: run unit tests.'
 task :default => [:clean, :test]
 
+desc 'Test the paperclip plugin under all supported Rails versions.'
+task :all do |t|
+  exec('rake RAILS_VERSION=2.1 && rake RAILS_VERSION=2.3 && rake RAILS_VERSION=3.0')
+end
+
 desc 'Test the paperclip plugin.'
 Rake::TestTask.new(:test) do |t|
   t.libs << 'lib' << 'profile'
@@ -40,49 +45,15 @@ task :clean do |t|
   FileUtils.rm_rf "doc"
   FileUtils.rm_rf "tmp"
   FileUtils.rm_rf "pkg"
+  FileUtils.rm_rf "public"
   FileUtils.rm "test/debug.log" rescue nil
   FileUtils.rm "test/paperclip.db" rescue nil
   Dir.glob("paperclip-*.gem").each{|f| FileUtils.rm f }
 end
 
-include_file_globs = ["README*",
-                      "LICENSE",
-                      "Rakefile",
-                      "init.rb",
-                      "{generators,lib,tasks,test,shoulda_macros}/**/*"]
-exclude_file_globs = ["test/s3.yml",
-                      "test/debug.log",
-                      "test/paperclip.db",
-                      "test/doc",
-                      "test/doc/*",
-                      "test/pkg",
-                      "test/pkg/*",
-                      "test/tmp",
-                      "test/tmp/*"]
-spec = Gem::Specification.new do |s| 
-  s.name              = "paperclip-cloudfiles"
-  s.version           = Paperclip::VERSION
-  s.authors           = "Jon Yurek", "H. Wade Minter"
-  s.email             = "jyurek@thoughtbot.com", "minter@lunenburg.org"
-  s.homepage          = "http://github.com/minter/paperclip"
-  s.platform          = Gem::Platform::RUBY
-  s.description       = "A fork of the Thoughtbot Paperclip gem/plugin, adding support for Rackspace Cloud Files.  This fork is maintained by H. Wade Minter <minter@lunenburg.org>"
-  s.summary           = "File attachments as attributes for ActiveRecord with Rackspace Cloud Files support"
-  s.files             = FileList[include_file_globs].to_a - FileList[exclude_file_globs].to_a
-  s.require_path      = "lib"
-  s.test_files        = FileList["test/**/test_*.rb"].to_a
-  s.rubyforge_project = "paperclip"
-  s.has_rdoc          = true
-  s.extra_rdoc_files  = FileList["README*"].to_a
-  s.rdoc_options << '--line-numbers' << '--inline-source'
-  s.requirements << "ImageMagick"
-  s.add_development_dependency 'shoulda'
-  s.add_development_dependency 'jferris-mocha', '>= 0.9.5.0.1241126838'
-  s.add_development_dependency 'aws-s3'
-  s.add_development_dependency 'cloudfiles', '>= 1.4.4'
-  s.add_development_dependency 'sqlite3-ruby'
-  s.add_development_dependency 'activerecord'
-  s.add_development_dependency 'activesupport'
+desc 'Build the gemspec.'
+task :gemspec do |t|
+  exec 'gem build paperclip-cloudfiles.gemspec'
 end
 
 desc "Print a list of the files to be put into the gem"

data/lib/paperclip.rb

@@ -36,8 +36,9 @@ require 'paperclip/storage'
 require 'paperclip/interpolations'
 require 'paperclip/style'
 require 'paperclip/attachment'
-if defined? RAILS_ROOT
-  Dir.glob(File.join(File.expand_path(RAILS_ROOT), "lib", "paperclip_processors", "*.rb")).each do |processor|
+require 'paperclip/callback_compatability'
+if defined?(Rails.root) && Rails.root
+  Dir.glob(File.join(File.expand_path(Rails.root), "lib", "paperclip_processors", "*.rb")).each do |processor|
     require processor
   end
 end
@@ -46,7 +47,7 @@ end
 # documentation for Paperclip::ClassMethods for more useful information.
 module Paperclip
 
-  VERSION = "2.3.1.1.6"
+  VERSION = "2.3.2"
 
   class << self
     # Provides configurability to Paperclip. There are a number of options available, such as:
@@ -64,7 +65,7 @@ module Paperclip
         :image_magick_path => nil,
         :command_path      => nil,
         :log               => true,
-        :log_command       => false,
+        :log_command       => true,
         :swallow_stderr    => true
       }
     end
@@ -81,7 +82,7 @@ module Paperclip
       Paperclip::Interpolations[key] = block
     end
 
-    # The run method takes a command to execute and a string of parameters
+    # The run method takes a command to execute and an array of parameters
     # that get passed to it. The command is prefixed with the :command_path
     # option from Paperclip.options. If you have many commands to run and
     # they are in different paths, the suggested course of action is to
@@ -90,29 +91,49 @@ module Paperclip
     # If the command returns with a result code that is not one of the
     # expected_outcodes, a PaperclipCommandLineError will be raised. Generally
     # a code of 0 is expected, but a list of codes may be passed if necessary.
+    # These codes should be passed as a hash as the last argument, like so:
+    #
+    #   Paperclip.run("echo", "something", :expected_outcodes => [0,1,2,3])
     #
     # This method can log the command being run when 
     # Paperclip.options[:log_command] is set to true (defaults to false). This
     # will only log if logging in general is set to true as well.
-    def run cmd, params = "", expected_outcodes = 0
-      command = %Q[#{path_for_command(cmd)} #{params}].gsub(/\s+/, " ")
+    def run cmd, *params
+      options           = params.last.is_a?(Hash) ? params.pop : {}
+      expected_outcodes = options[:expected_outcodes] || [0]
+      params            = quote_command_options(*params).join(" ")
+
+      command = %Q[#{path_for_command(cmd)} #{params}]
       command = "#{command} 2>#{bit_bucket}" if Paperclip.options[:swallow_stderr]
       Paperclip.log(command) if Paperclip.options[:log_command]
+
       output = `#{command}`
-      unless [expected_outcodes].flatten.include?($?.exitstatus)
-        raise PaperclipCommandLineError, "Error while running #{cmd}"
+      unless expected_outcodes.include?($?.exitstatus)
+        raise PaperclipCommandLineError,
+          "Error while running #{cmd}. Expected return code to be #{expected_outcodes.join(", ")} but was #{$?.exitstatus}",
+          output
       end
       output
     end
 
+    def quote_command_options(*options)
+      options.map do |option|
+        option.split("'").map{|m| "'#{m}'" }.join("\\'")
+      end
+    end
+
     def bit_bucket #:nodoc:
       File.exists?("/dev/null") ? "/dev/null" : "NUL"
     end
 
     def included base #:nodoc:
       base.extend ClassMethods
-      unless base.respond_to?(:define_callbacks)
-        base.send(:include, Paperclip::CallbackCompatability)
+      if base.respond_to?("set_callback")
+        base.send :include, Paperclip::CallbackCompatability::Rails3
+      elsif !base.respond_to?("define_callbacks")
+        base.send :include, Paperclip::CallbackCompatability::Rails20
+      else
+        base.send :include, Paperclip::CallbackCompatability::Rails21
       end
     end
 
@@ -144,6 +165,11 @@ module Paperclip
   end
 
   class PaperclipCommandLineError < StandardError #:nodoc:
+    attr_accessor :output
+    def initialize(msg = nil, output = nil)
+      super(msg)
+      @output = output
+    end
   end
 
   class NotIdentifiedByImageMagickError < PaperclipError #:nodoc:
@@ -192,7 +218,7 @@ module Paperclip
     #   Defaults to true. This option used to be called :whiny_thumbanils, but this is
     #   deprecated.
     # * +convert_options+: When creating thumbnails, use this free-form options
-    #   field to pass in various convert command options.  Typical options are "-strip" to
+    #   array to pass in various convert command options.  Typical options are "-strip" to
     #   remove all Exif data from the image (save space for thumbnails and avatars) or
     #   "-depth 8" to specify the bit depth of the resulting conversion.  See ImageMagick
     #   convert documentation for more options: (http://www.imagemagick.org/script/convert.php)
@@ -209,6 +235,9 @@ module Paperclip
     #   NOTE: While not deprecated yet, it is not recommended to specify options this way.
     #   It is recommended that :convert_options option be included in the hash passed to each
     #   :styles for compatability with future versions.
+    #   NOTE: Strings supplied to :convert_options are split on space in order to undergo
+    #   shell quoting for safety. If your options require a space, please pre-split them
+    #   and pass an array to :convert_options instead.
     # * +storage+: Chooses the storage backend where the files will be stored. The current
     #   choices are :filesystem and :s3. The default is :filesystem. Make sure you read the
     #   documentation for Paperclip::Storage::Filesystem and Paperclip::Storage::S3
@@ -222,9 +251,8 @@ module Paperclip
       after_save :save_attached_files
       before_destroy :destroy_attached_files
 
-      define_callbacks :before_post_process, :after_post_process
-      define_callbacks :"before_#{name}_post_process", :"after_#{name}_post_process"
-     
+      define_paperclip_callbacks :post_process, :"#{name}_post_process"
+
       define_method name do |*args|
         a = attachment_for(name)
         (args.length > 0) ? a.to_s(args.first) : a
@@ -308,7 +336,12 @@ module Paperclip
       types = [options.delete(:content_type)].flatten
       validates_each(:"#{name}_content_type", options) do |record, attr, value|
         unless types.any?{|t| t === value }
-          record.errors.add(:"#{name}_content_type", :inclusion, :default => options[:message], :value => value)
+          if record.errors.method(:add).arity == -2
+            message = options[:message] || "is not one of #{types.join(", ")}"
+            record.errors.add(:"#{name}_content_type", message)
+          else
+            record.errors.add(:"#{name}_content_type", :inclusion, :default => options[:message], :value => value)
+          end
         end
       end
     end
@@ -333,14 +366,14 @@ module Paperclip
     end
 
     def save_attached_files
-      logger.info("[paperclip] Saving attachments.")
+      Paperclip.log("Saving attachments.")
       each_attachment do |name, attachment|
         attachment.send(:save)
       end
     end
 
     def destroy_attached_files
-      logger.info("[paperclip] Deleting attachments.")
+      Paperclip.log("Deleting attachments.")
       each_attachment do |name, attachment|
         attachment.send(:queue_existing_for_delete)
         attachment.send(:flush_deletes)

data/lib/paperclip/attachment.rb

@@ -92,7 +92,7 @@ module Paperclip
       return nil if uploaded_file.nil?
 
       @queued_for_write[:original]   = uploaded_file.to_tempfile
-      instance_write(:file_name,       uploaded_file.original_filename.strip.gsub(/[^A-Za-z\d\.\-_]+/, '_'))
+      instance_write(:file_name,       uploaded_file.original_filename.strip)
       instance_write(:content_type,    uploaded_file.content_type.to_s.strip)
       instance_write(:file_size,       uploaded_file.size.to_i)
       instance_write(:updated_at,      Time.now)
@@ -345,18 +345,11 @@ module Paperclip
 
     def post_process #:nodoc:
       return if @queued_for_write[:original].nil?
-      return if fire_events(:before)
-      post_process_styles
-      return if fire_events(:after)
-    end
-
-    def fire_events(which) #:nodoc:
-      return true if callback(:"#{which}_post_process") == false
-      return true if callback(:"#{which}_#{name}_post_process") == false
-    end
-
-    def callback which #:nodoc:
-      instance.run_callbacks(which, @queued_for_write){|result, obj| result == false }
+      instance.run_paperclip_callbacks(:post_process) do
+        instance.run_paperclip_callbacks(:"#{name}_post_process") do
+          post_process_styles
+        end
+      end
     end
 
     def post_process_styles #:nodoc:

data/lib/paperclip/callback_compatability.rb

@@ -1,33 +1,61 @@
 module Paperclip
-  # This module is intended as a compatability shim for the differences in
-  # callbacks between Rails 2.0 and Rails 2.1.
   module CallbackCompatability
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.send(:include, InstanceMethods)
-    end
+    module Rails21
+      def self.included(base)
+        base.extend(Defining)
+        base.send(:include, Running)
+      end
 
-    module ClassMethods
-      # The implementation of this method is taken from the Rails 1.2.6 source,
-      # from rails/activerecord/lib/active_record/callbacks.rb, line 192.
-      def define_callbacks(*args)
-        args.each do |method|
-          self.class_eval <<-"end_eval"
-            def self.#{method}(*callbacks, &block)
-              callbacks << block if block_given?
-              write_inheritable_array(#{method.to_sym.inspect}, callbacks)
-            end
-          end_eval
+      module Defining
+        def define_paperclip_callbacks(*args)
+          args.each do |callback|
+            define_callbacks("before_#{callback}")
+            define_callbacks("after_#{callback}")
+          end
+        end
+      end
+
+      module Running
+        def run_paperclip_callbacks(callback, opts = nil, &blk)
+          # The overall structure of this isn't ideal since after callbacks run even if
+          # befores return false. But this is how rails 3's callbacks work, unfortunately.
+          if run_callbacks(:"before_#{callback}"){ |result, object| result == false } != false
+            blk.call
+          end
+          run_callbacks(:"after_#{callback}"){ |result, object| result == false }
         end
       end
     end
 
-    module InstanceMethods
-      # The callbacks in < 2.1 don't worry about the extra options or the
-      # block, so just run what we have available.
-      def run_callbacks(meth, opts = nil, &blk)
-        callback(meth)
+    module Rails3
+      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
 end

data/lib/paperclip/geometry.rb

@@ -16,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}[0]")
                  rescue PaperclipCommandLineError
                    ""
                  end

data/lib/paperclip/interpolations.rb

@@ -51,14 +51,14 @@ module Paperclip
       attachment.instance_read(:updated_at).to_s
     end
 
-    # Returns the RAILS_ROOT constant.
+    # Returns the Rails.root constant.
     def rails_root attachment, style_name
-      RAILS_ROOT
+      Rails.root
     end
 
-    # Returns the RAILS_ENV constant.
+    # Returns the Rails.env constant.
     def rails_env attachment, style_name
-      RAILS_ENV
+      Rails.env
     end
 
     # Returns the underscored, pluralized version of the class name.

data/lib/paperclip/iostream.rb

@@ -5,7 +5,7 @@ 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))
+    tempfile = Paperclip::Tempfile.new("stream" + File.extname(name))
     tempfile.binmode
     self.stream_to(tempfile)
   end

data/lib/paperclip/matchers.rb

@@ -2,3 +2,32 @@ require 'paperclip/matchers/have_attached_file_matcher'
 require 'paperclip/matchers/validate_attachment_presence_matcher'
 require 'paperclip/matchers/validate_attachment_content_type_matcher'
 require 'paperclip/matchers/validate_attachment_size_matcher'
+
+module Paperclip
+  module Shoulda
+    # Provides rspec-compatible matchers for testing Paperclip attachments.
+    #
+    # In spec_helper.rb, you'll need to require the matchers:
+    #
+    #   require "paperclip/matchers"
+    #
+    # And include the module:
+    #
+    #   Spec::Runner.configure do |config|
+    #     config.include Paperclip::Shoulda::Matchers
+    #   end
+    #
+    # Example:
+    #   describe User do
+    #     it { should have_attached_file(:avatar) }
+    #     it { should validate_attachment_presence(:avatar) }
+    #     it { should validate_attachment_content_type(:avatar).
+    #                   allowing('image/png', 'image/gif').
+    #                   rejecting('text/plain', 'text/xml') }
+    #     it { should validate_attachment_size(:avatar).
+    #                   less_than(2.megabytes) }
+    #   end
+    module Matchers
+    end
+  end
+end

data/lib/paperclip/matchers/have_attached_file_matcher.rb

@@ -1,6 +1,13 @@
 module Paperclip
   module Shoulda
     module Matchers
+      # Ensures that the given instance or class has an attachment with the
+      # given name.
+      #
+      # Example:
+      #   describe User do
+      #     it { should have_attached_file(:avatar) }
+      #   end
       def have_attached_file name
         HaveAttachedFileMatcher.new(name)
       end
@@ -12,6 +19,7 @@ module Paperclip
 
         def matches? subject
           @subject = subject
+          @subject = @subject.class unless Class === @subject
           responds? && has_column? && included?
         end