paperclip-cloudfiles 2.3.8.6 → 2.3.10.1

data/README.md

@@ -25,6 +25,13 @@ on Gemcutter's gem server.
 
 The complete [RDoc](http://rdoc.info/github/minter/paperclip) is online.
 
+Changes in this repo
+------------
+
+Allowed to refresh images of classes with namespaces. For example:
+
+    rake paperclip:refresh CLASS='User::Asset'
+
 Requirements
 ------------
 
@@ -43,6 +50,10 @@ In development mode, you might add this line to `config/environments/development
 Installation
 ------------
 
+Paperclip is distributed as a gem, which is how it should be used in your app. It's
+technically still installable as a plugin, but that's discouraged, as Rails plays
+well with gems.
+
 Include the gem in your Gemfile:
 
   gem "paperclip-cloudfiles", "~> 2.3"
@@ -208,7 +219,8 @@ Testing
 -------
 
 Paperclip provides rspec-compatible matchers for testing attachments. See the
-documentation on Paperclip::Shoulda::Matchers for more information.
+documentation on [Paperclip::Shoulda::Matchers](http://rubydoc.info/gems/paperclip/Paperclip/Shoulda/Matchers)
+for more information.
 
 Contributing
 ------------

data/lib/paperclip.rb

@@ -39,8 +39,8 @@ require 'paperclip/style'
 require 'paperclip/attachment'
 require 'paperclip/storage'
 require 'paperclip/callback_compatability'
-require 'paperclip/command_line'
 require 'paperclip/railtie'
+require 'cocaine'
 if defined?(Rails.root) && Rails.root
   Dir.glob(File.join(File.expand_path(Rails.root), "lib", "paperclip_processors", "*.rb")).each do |processor|
     require processor
@@ -87,7 +87,7 @@ module Paperclip
     # symlink them so they are all in the same directory.
     #
     # If the command returns with a result code that is not one of the
-    # expected_outcodes, a PaperclipCommandLineError will be raised. Generally
+    # expected_outcodes, a Cocaine::CommandLineError 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:
     #
@@ -100,8 +100,8 @@ module Paperclip
       if options[:image_magick_path]
         Paperclip.log("[DEPRECATION] :image_magick_path is deprecated and will be removed. Use :command_path instead")
       end
-      CommandLine.path = options[:command_path] || options[:image_magick_path]
-      CommandLine.new(cmd, *params).run
+      Cocaine::CommandLine.path = options[:command_path] || options[:image_magick_path]
+      Cocaine::CommandLine.new(cmd, *params).run
     end
 
     def processor name #:nodoc:
@@ -114,7 +114,7 @@ module Paperclip
     end
 
     def each_instance_with_attachment(klass, name)
-      Object.const_get(klass).all.each do |instance|
+      class_for(klass).all.each do |instance|
         yield(instance) if instance.send(:"#{name}?")
       end
     end
@@ -132,17 +132,15 @@ module Paperclip
     def logging? #:nodoc:
       options[:log]
     end
-  end
 
-  class PaperclipError < StandardError #:nodoc:
+    def class_for(class_name)
+      class_name.split('::').inject(Object) do |klass, partial_class_name|
+        klass.const_get(partial_class_name)
+      end
+    end
   end
 
-  class PaperclipCommandLineError < PaperclipError #:nodoc:
-    attr_accessor :output
-    def initialize(msg = nil, output = nil)
-      super(msg)
-      @output = output
-    end
+  class PaperclipError < StandardError #:nodoc:
   end
 
   class StorageMethodNotFound < PaperclipError
@@ -160,6 +158,7 @@ module Paperclip
   module Glue
     def self.included base #:nodoc:
       base.extend ClassMethods
+      base.class_attribute :attachment_definitions
       if base.respond_to?("set_callback")
         base.send :include, Paperclip::CallbackCompatability::Rails3
       else
@@ -235,7 +234,14 @@ module Paperclip
     def has_attached_file name, options = {}
       include InstanceMethods
 
-      write_inheritable_attribute(:attachment_definitions, {}) if attachment_definitions.nil?
+      if attachment_definitions.nil?
+        if respond_to?(:class_attribute)
+          self.attachment_definitions = {}
+        else
+          write_inheritable_attribute(:attachment_definitions, {})
+        end
+      end
+
       attachment_definitions[name] = {:validations => []}.merge(options)
 
       after_save :save_attached_files
@@ -343,7 +349,11 @@ module Paperclip
     # Returns the attachment definitions defined by each call to
     # has_attached_file.
     def attachment_definitions
-      read_inheritable_attribute(:attachment_definitions)
+      if respond_to?(:class_attribute)
+        self.attachment_definitions
+      else
+        read_inheritable_attribute(:attachment_definitions)
+      end
     end
   end
 

data/lib/paperclip/attachment.rb

@@ -64,7 +64,7 @@ module Paperclip
     end
 
     def styles
-      unless @normalized_styles
+      if @styles.respond_to?(:call) || !@normalized_styles
         @normalized_styles = {}
         (@styles.respond_to?(:call) ? @styles.call(self) : @styles).each do |name, args|
           @normalized_styles[name] = Paperclip::Style.new(name, args.dup, self)
@@ -270,6 +270,8 @@ module Paperclip
     def file?
       !original_filename.blank?
     end
+    
+    alias :present? :file?
 
     # Writes the attachment-specific attribute on the instance. For example,
     # instance_write(:file_name, "me.jpg") will write "me.jpg" to the instance's

data/lib/paperclip/geometry.rb

@@ -17,8 +17,10 @@ module Paperclip
       file = file.path if file.respond_to? "path"
       geometry = begin
                    Paperclip.run("identify", "-format %wx%h :file", :file => "#{file}[0]")
-                 rescue PaperclipCommandLineError
+                 rescue Cocaine::ExitStatusError
                    ""
+                 rescue Cocaine::CommandNotFoundError => e
+                   raise Paperclip::CommandNotFoundError.new("Could not run the `identify` command. Please install ImageMagick.")
                  end
       parse(geometry) ||
         raise(NotIdentifiedByImageMagickError.new("#{file} is not recognized by the 'identify' command."))

data/lib/paperclip/storage.rb

@@ -1,3 +1,4 @@
 require "paperclip/storage/filesystem"
+require "paperclip/storage/fog"
 require "paperclip/storage/s3"
 require "paperclip/storage/cloud_files"

data/lib/paperclip/storage/fog.rb

@@ -0,0 +1,98 @@
+module Paperclip
+  module Storage
+
+    module Fog
+      def self.extended base
+        begin
+          require 'fog'
+        rescue LoadError => e
+          e.message << " (You may need to install the fog gem)"
+          raise e
+        end unless defined?(Fog)
+
+        base.instance_eval do
+          @fog_directory    = @options[:fog_directory]
+          @fog_credentials  = @options[:fog_credentials]
+          @fog_host         = @options[:fog_host]
+          @fog_public       = @options[:fog_public]
+
+          @url = ':fog_public_url'
+          Paperclip.interpolates(:fog_public_url) do |attachment, style|
+            attachment.public_url(style)
+          end unless Paperclip::Interpolations.respond_to? :fog_public_url
+        end
+      end
+
+      def exists?(style = default_style)
+        if original_filename
+          !!directory.files.head(path(style))
+        else
+          false
+        end
+      end
+
+      def flush_writes
+        for style, file in @queued_for_write do
+          log("saving #{path(style)}")
+          directory.files.create(
+            :body   => file,
+            :key    => path(style),
+            :public => @fog_public
+          )
+        end
+        @queued_for_write = {}
+      end
+
+      def flush_deletes
+        for path in @queued_for_delete do
+          log("deleting #{path}")
+          directory.files.new(:key => path).destroy
+        end
+        @queued_for_delete = []
+      end
+
+      # Returns representation of the data of the file assigned to the given
+      # style, in the format most representative of the current storage.
+      def to_file(style = default_style)
+        if @queued_for_write[style]
+          @queued_for_write[style]
+        else
+          body      = directory.files.get(path(style)).body
+          filename  = path(style)
+          extname   = File.extname(filename)
+          basename  = File.basename(filename, extname)
+          file      = Tempfile.new([basename, extname])
+          file.binmode
+          file.write(body)
+          file.rewind
+          file
+        end
+      end
+
+      def public_url(style = default_style)
+        if @fog_host
+          "#{@fog_host}/#{path(style)}"
+        else
+          directory.files.new(:key => path(style)).public_url
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= ::Fog::Storage.new(@fog_credentials)
+      end
+
+      def directory
+        @directory ||= begin
+          connection.directories.get(@fog_directory) || connection.directories.create(
+            :key => @fog_directory,
+            :public => @fog_public
+          )
+        end
+      end
+
+    end
+
+  end
+end

data/lib/paperclip/storage/s3.rb

@@ -25,7 +25,7 @@ module Paperclip
     #   development versus production.
     # * +s3_permissions+: This is a String that should be one of the "canned" access
     #   policies that S3 provides (more information can be found here:
-    #   http://docs.amazonwebservices.com/AmazonS3/2006-03-01/RESTAccessPolicy.html#RESTCannedAccessPolicies)
+    #   http://docs.amazonwebservices.com/AmazonS3/latest/dev/index.html?RESTAccessPolicy.html)
     #   The default for Paperclip is :public_read.
     # * +s3_protocol+: The protocol for the URLs generated to your S3 assets. Can be either
     #   'http' or 'https'. Defaults to 'http' when your :s3_permissions are :public_read (the
@@ -94,8 +94,8 @@ module Paperclip
         end unless Paperclip::Interpolations.respond_to? :s3_domain_url
       end
 
-      def expiring_url(time = 3600)
-        AWS::S3::S3Object.url_for(path, bucket_name, :expires_in => time )
+      def expiring_url(time = 3600, style_name = default_style)
+        AWS::S3::S3Object.url_for(path(style_name), bucket_name, :expires_in => time, :use_ssl => (s3_protocol == 'https'))
       end
 
       def bucket_name

data/lib/paperclip/style.rb

@@ -30,8 +30,9 @@ module Paperclip
     # (which method (in the attachment) will call any supplied procs)
     # There is an important change of interface here: a style rule can set its own processors
     # by default we behave as before, though.
+    # if a proc has been supplied, we call it here
     def processors
-      @processors || attachment.processors
+      @processors.respond_to?(:call) ? @processors.call(attachment.instance) : (@processors || attachment.processors)
     end
 
     # retrieves from the attachment the whiny setting

data/lib/paperclip/thumbnail.rb

@@ -59,8 +59,10 @@ module Paperclip
         parameters = parameters.flatten.compact.join(" ").strip.squeeze(" ")
 
         success = Paperclip.run("convert", parameters, :source => "#{File.expand_path(src.path)}[0]", :dest => File.expand_path(dst.path))
-      rescue PaperclipCommandLineError => e
+      rescue Cocaine::ExitStatusError => e
         raise PaperclipError, "There was an error processing the thumbnail for #{@basename}" if @whiny
+      rescue Cocaine::CommandNotFoundError => e
+        raise Paperclip::CommandNotFoundError.new("Could not run the `convert` command. Please install ImageMagick.")
       end
 
       dst

data/lib/paperclip/version.rb

@@ -1,3 +1,3 @@
 module Paperclip
-  VERSION = "2.3.8.6" unless defined? Paperclip::VERSION
+  VERSION = "2.3.10.1" unless defined? Paperclip::VERSION
 end

data/lib/tasks/paperclip.rake

@@ -5,7 +5,7 @@ def obtain_class
 end
 
 def obtain_attachments(klass)
-  klass = Object.const_get(klass.to_s)
+  klass = Paperclip.class_for(klass.to_s)
   name = ENV['ATTACHMENT'] || ENV['attachment']
   raise "Class #{klass.name} has no attachments specified" unless klass.respond_to?(:attachment_definitions)
   if !name.blank? && klass.attachment_definitions.keys.include?(name)

data/test/attachment_test.rb

@@ -287,6 +287,24 @@ class AttachmentTest < Test::Unit::TestCase
       assert_equal "50x50#", @attachment.styles[:thumb][:geometry]
     end
   end
+  
+  context "An attachment with conditional :styles that is a proc" do
+    setup do
+      rebuild_model :styles => lambda{ |attachment| attachment.instance.other == 'a' ? {:thumb => "50x50#"} : {:large => "400x400"} }
+
+      @dummy = Dummy.new(:other => 'a')
+    end
+
+    should "have the correct styles for the assigned instance values" do
+      assert_equal "50x50#", @dummy.avatar.styles[:thumb][:geometry]
+      assert_nil @dummy.avatar.styles[:large]
+
+      @dummy.other = 'b'
+      
+      assert_equal "400x400", @dummy.avatar.styles[:large][:geometry]
+      assert_nil @dummy.avatar.styles[:thumb]
+    end
+  end
 
   context "An attachment with :url that is a proc" do
     setup do

data/test/fog_test.rb

@@ -0,0 +1,107 @@
+require './test/helper'
+require 'fog'
+
+Fog.mock!
+
+class FogTest < Test::Unit::TestCase
+  context "" do
+
+    setup do
+      @fog_directory = 'papercliptests'
+
+      @credentials = {
+        :provider               => 'AWS',
+        :aws_access_key_id      => 'ID',
+        :aws_secret_access_key  => 'SECRET'
+      }
+
+      @connection = Fog::Storage.new(@credentials)
+
+      rebuild_model(
+        :fog_directory    => @fog_directory,
+        :fog_credentials  => @credentials,
+        :fog_host         => nil,
+        :fog_public       => true,
+        :path             => ":attachment/:basename.:extension",
+        :storage          => :fog
+      )
+    end
+
+    should "be extended by the Fog module" do
+      assert Dummy.new.avatar.is_a?(Paperclip::Storage::Fog)
+    end
+
+    context "when assigned" do
+      setup do
+        @file = File.new(File.join(File.dirname(__FILE__), 'fixtures', '5k.png'), 'rb')
+        @dummy = Dummy.new
+        @dummy.avatar = @file
+      end
+
+      teardown do
+        @file.close
+        directory = @connection.directories.new(:key => @fog_directory)
+        directory.files.each {|file| file.destroy}
+        directory.destroy
+      end
+
+      context "without a bucket" do
+        should "succeed" do
+          assert @dummy.save
+        end
+      end
+
+      context "with a bucket" do
+        setup do
+          @connection.directories.create(:key => @fog_directory)
+        end
+
+        should "succeed" do
+          assert @dummy.save
+        end
+      end
+
+      context "without a fog_host" do
+        setup do
+          rebuild_model(
+            :fog_directory    => @fog_directory,
+            :fog_credentials  => @credentials,
+            :fog_host         => nil,
+            :fog_public       => true,
+            :path             => ":attachment/:basename.:extension",
+            :storage          => :fog
+          )
+          @dummy = Dummy.new
+          @dummy.avatar = StringIO.new('.')
+          @dummy.save
+        end
+
+        should "provide a public url" do
+          assert !@dummy.avatar.url.nil?
+        end
+      end
+
+      context "with a fog_host" do
+        setup do
+          rebuild_model(
+            :fog_directory    => @fog_directory,
+            :fog_credentials  => @credentials,
+            :fog_host         => 'http://example.com',
+            :fog_public       => true,
+            :path             => ":attachment/:basename.:extension",
+            :storage          => :fog
+          )
+          @dummy = Dummy.new
+          @dummy.avatar = StringIO.new('.')
+          @dummy.save
+        end
+
+        should "provide a public url" do
+          assert @dummy.avatar.url =~ /^http:\/\/example\.com\/avatars\/stringio\.txt\?\d*$/
+        end
+      end
+
+    end
+
+  end
+end

data/test/geometry_test.rb

@@ -120,6 +120,19 @@ class GeometryTest < Test::Unit::TestCase
       assert_raise(Paperclip::NotIdentifiedByImageMagickError){ @geo = Paperclip::Geometry.from_file(file) }
     end
 
+    should "let us know when a command isn't found versus a processing error" do
+      old_path = ENV['PATH']
+      begin
+        ENV['PATH'] = ''
+        assert_raises(Paperclip::CommandNotFoundError) do
+          file = File.join(File.dirname(__FILE__), "fixtures", "5k.png")
+          @geo = Paperclip::Geometry.from_file(file)
+        end
+      ensure
+        ENV['PATH'] = old_path
+      end
+    end
+
     [['vertical',   900,  1440, true,  false, false, 1440, 900, 0.625],
      ['horizontal', 1024, 768,  false, true,  false, 1024, 768, 1.3333],
      ['square',     100,  100,  false, false, true,  100,  100, 1]].each do |args|

data/test/helper.rb

@@ -70,6 +70,7 @@ end
 
 def rebuild_model options = {}
   ActiveRecord::Base.connection.create_table :dummies, :force => true do |table|
+    table.column :title, :string
     table.column :other, :string
     table.column :avatar_file_name, :string
     table.column :avatar_content_type, :string
@@ -88,6 +89,7 @@ def rebuild_class options = {}
     include Paperclip::Glue
     has_attached_file :avatar, options
   end
+  Dummy.reset_column_information
 end
 
 class FakeModel

data/test/matchers/validate_attachment_content_type_matcher_test.rb

@@ -34,13 +34,13 @@ class ValidateAttachmentContentTypeMatcherTest < Test::Unit::TestCase
 
       should_accept_dummy_class
     end
-    
+
     context "given a class with other validations but matching types" do
       setup do
         @dummy_class.validates_presence_of :title
         @dummy_class.validates_attachment_content_type :avatar, :content_type => %r{image/.*}
       end
-      
+
       should_accept_dummy_class
     end
   end

data/test/paperclip_test.rb

@@ -2,44 +2,9 @@ require './test/helper'
 
 class PaperclipTest < Test::Unit::TestCase
   context "Calling Paperclip.run" do
-    setup do
-      Paperclip.options[:image_magick_path] = nil
-      Paperclip.options[:command_path]      = nil
-      Paperclip::CommandLine.stubs(:'`')
-    end
-
-    should "execute the right command with :image_magick_path" do
-      Paperclip.options[:image_magick_path] = "/usr/bin"
-      Paperclip.expects(:log).with(includes('[DEPRECATION]'))
-      Paperclip.expects(:log).with(regexp_matches(%r{/usr/bin/convert ['"]one.jpg['"] ['"]two.jpg['"]}))
-      Paperclip::CommandLine.expects(:"`").with(regexp_matches(%r{/usr/bin/convert ['"]one.jpg['"] ['"]two.jpg['"]}))
-      Paperclip.run("convert", ":one :two", :one => "one.jpg", :two => "two.jpg")
-    end
-
-    should "execute the right command with :command_path" do
-      Paperclip.options[:command_path] = "/usr/bin"
-      Paperclip::CommandLine.expects(:"`").with(regexp_matches(%r{/usr/bin/convert ['"]one.jpg['"] ['"]two.jpg['"]}))
-      Paperclip.run("convert", ":one :two", :one => "one.jpg", :two => "two.jpg")
-    end
-
-    should "execute the right command with no path" do
-      Paperclip::CommandLine.expects(:"`").with(regexp_matches(%r{convert ['"]one.jpg['"] ['"]two.jpg['"]}))
-      Paperclip.run("convert", ":one :two", :one => "one.jpg", :two => "two.jpg")
-    end
-
-    should "tell you the command isn't there if the shell returns 127" do
-      with_exitstatus_returning(127) do
-        assert_raises(Paperclip::CommandNotFoundError) do
-          Paperclip.run("command")
-        end
-      end
-    end
-
-    should "tell you the command isn't there if an ENOENT is raised" do
-      assert_raises(Paperclip::CommandNotFoundError) do
-        Paperclip::CommandLine.stubs(:"`").raises(Errno::ENOENT)
-        Paperclip.run("command")
-      end
+    should "run the command with Cocaine" do
+      Cocaine::CommandLine.expects(:new).with("convert", "stuff").returns(stub(:run))
+      Paperclip.run("convert", "stuff")
     end
   end
 
@@ -72,6 +37,11 @@ class PaperclipTest < Test::Unit::TestCase
     assert_equal ::Paperclip::Thumbnail, Paperclip.processor(:thumbnail)
   end
 
+  should "get a class from a namespaced class name" do
+    class ::One; class Two; end; end
+    assert_equal ::One::Two, Paperclip.class_for("One::Two")
+  end
+
   context "An ActiveRecord model with an 'avatar' attachment" do
     setup do
       rebuild_model :path => "tmp/:class/omg/:style.:extension"
@@ -223,7 +193,7 @@ class PaperclipTest < Test::Unit::TestCase
             @dummy.valid?
           end
           should "not have an error when assigned a valid file" do
-            assert_equal 0, @dummy.errors.length, @dummy.errors.full_messages.join(", ")
+            assert_equal 0, @dummy.errors.size, @dummy.errors.full_messages.join(", ")
           end
         end
         context "and assigned an invalid file" do
@@ -232,7 +202,7 @@ class PaperclipTest < Test::Unit::TestCase
             @dummy.valid?
           end
           should "have an error when assigned a valid file" do
-            assert @dummy.errors.length > 0
+            assert @dummy.errors.size > 0
           end
         end
       end

data/test/storage_test.rb

@@ -180,7 +180,7 @@ class StorageTest < Test::Unit::TestCase
     end
   end
 
-  context "Generating a url with an expiration" do
+  context "Generating a secure url with an expiration" do
     setup do
       AWS::S3::Base.stubs(:establish_connection!)
       rebuild_model :storage => :s3,
@@ -189,6 +189,7 @@ class StorageTest < Test::Unit::TestCase
                       :development  => { :bucket => "dev_bucket" }
                     },
                     :s3_host_alias => "something.something.com",
+                    :s3_permissions => "private",
                     :path => ":attachment/:basename.:extension",
                     :url => ":s3_alias_url"
 
@@ -197,7 +198,7 @@ class StorageTest < Test::Unit::TestCase
       @dummy = Dummy.new
       @dummy.avatar = StringIO.new(".")
 
-      AWS::S3::S3Object.expects(:url_for).with("avatars/stringio.txt", "prod_bucket", { :expires_in => 3600 })
+      AWS::S3::S3Object.expects(:url_for).with("avatars/stringio.txt", "prod_bucket", { :expires_in => 3600, :use_ssl => true })
 
       @dummy.avatar.expiring_url
     end
@@ -207,6 +208,35 @@ class StorageTest < Test::Unit::TestCase
     end
   end
 
+  context "Generating a url with an expiration" do
+    setup do
+      AWS::S3::Base.stubs(:establish_connection!)
+      rebuild_model :storage => :s3,
+                    :s3_credentials => {
+                      :production   => { :bucket => "prod_bucket" },
+                      :development  => { :bucket => "dev_bucket" }
+                    },
+                    :s3_host_alias => "something.something.com",
+                    :path => ":attachment/:style/:basename.:extension",
+                    :url => ":s3_alias_url"
+
+      rails_env("production")
+
+      @dummy = Dummy.new
+      @dummy.avatar = StringIO.new(".")
+
+      AWS::S3::S3Object.expects(:url_for).with("avatars/original/stringio.txt", "prod_bucket", { :expires_in => 3600, :use_ssl => false })
+      @dummy.avatar.expiring_url
+
+      AWS::S3::S3Object.expects(:url_for).with("avatars/thumb/stringio.txt", "prod_bucket", { :expires_in => 1800, :use_ssl => false })
+      @dummy.avatar.expiring_url(1800, :thumb)
+    end
+
+    should "should succeed" do
+      assert true
+    end
+  end
+
   context "Parsing S3 credentials with a bucket in them" do
     setup do
       AWS::S3::Base.stubs(:establish_connection!)

data/test/style_test.rb

@@ -138,4 +138,26 @@ class StyleTest < Test::Unit::TestCase
     end
 
   end
+  
+  context "A style rule with :processors supplied as procs" do
+    setup do
+      @attachment = attachment :path => ":basename.:extension",
+                               :styles => {
+                                 :foo => {
+                                   :geometry => "100x100#",
+                                   :format => :png,
+                                   :processors => lambda{|a| [:test]}
+                                  }
+                                },
+                               :processors => [:thumbnail]
+    end
+
+    should "defer processing of procs until they are needed" do
+      assert_kind_of Proc, @attachment.styles[:foo].instance_variable_get("@processors")
+    end
+
+    should "call procs when they are needed" do
+      assert_equal [:test], @attachment.styles[:foo].processors
+    end
+  end
 end

data/test/thumbnail_test.rb

@@ -73,6 +73,18 @@ class ThumbnailTest < Test::Unit::TestCase
         @thumb = Paperclip::Thumbnail.new(@file, :geometry => "100x50#")
       end
 
+      should "let us know when a command isn't found versus a processing error" do
+        old_path = ENV['PATH']
+        begin
+          ENV['PATH'] = ''
+          assert_raises(Paperclip::CommandNotFoundError) do
+            @thumb.make
+          end
+        ensure
+          ENV['PATH'] = old_path
+        end
+      end
+
       should "report its correct current and target geometries" do
         assert_equal "100x50#", @thumb.target_geometry.to_s
         assert_equal "434x66", @thumb.current_geometry.to_s
@@ -91,8 +103,10 @@ class ThumbnailTest < Test::Unit::TestCase
       end
 
       should "send the right command to convert when sent #make" do
-        Paperclip::CommandLine.expects(:"`").with do |arg|
-          arg.match %r{convert ["']#{File.expand_path(@thumb.file.path)}\[0\]["'] -resize ["']x50["'] -crop ["']100x50\+114\+0["'] \+repage ["'].*?["']}
+        Paperclip.expects(:run).with do |*arg|
+          arg[0] == 'convert' &&
+          arg[1] == ':source -resize "x50" -crop "100x50+114+0" +repage :dest' &&
+          arg[2][:source] == "#{File.expand_path(@thumb.file.path)}[0]"
         end
         @thumb.make
       end
@@ -115,8 +129,10 @@ class ThumbnailTest < Test::Unit::TestCase
       end
 
       should "send the right command to convert when sent #make" do
-        Paperclip::CommandLine.expects(:"`").with do |arg|
-          arg.match %r{convert -strip ["']#{File.expand_path(@thumb.file.path)}\[0\]["'] -resize ["']x50["'] -crop ["']100x50\+114\+0["'] \+repage ["'].*?["']}
+        Paperclip.expects(:run).with do |*arg|
+          arg[0] == 'convert' &&
+          arg[1] == '-strip :source -resize "x50" -crop "100x50+114+0" +repage :dest' &&
+          arg[2][:source] == "#{File.expand_path(@thumb.file.path)}[0]"
         end
         @thumb.make
       end
@@ -153,8 +169,10 @@ class ThumbnailTest < Test::Unit::TestCase
       end
 
       should "send the right command to convert when sent #make" do
-        Paperclip::CommandLine.expects(:"`").with do |arg|
-          arg.match %r{convert ["']#{File.expand_path(@thumb.file.path)}\[0\]["'] -resize ["']x50["'] -crop ["']100x50\+114\+0["'] \+repage -strip -depth 8 ["'].*?["']}
+        Paperclip.expects(:run).with do |*arg|
+          arg[0] == 'convert' &&
+          arg[1] == ':source -resize "x50" -crop "100x50+114+0" +repage -strip -depth 8 :dest' &&
+          arg[2][:source] == "#{File.expand_path(@thumb.file.path)}[0]"
         end
         @thumb.make
       end
@@ -176,6 +194,18 @@ class ThumbnailTest < Test::Unit::TestCase
             @thumb.make
           end
         end
+
+        should "let us know when a command isn't found versus a processing error" do
+          old_path = ENV['PATH']
+          begin
+            ENV['PATH'] = ''
+            assert_raises(Paperclip::CommandNotFoundError) do
+              @thumb.make
+            end
+          ensure
+            ENV['PATH'] = old_path
+          end
+        end
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: paperclip-cloudfiles
 version: !ruby/object:Gem::Version 
-  hash: 91
+  hash: 93
   prerelease: 
   segments: 
   - 2
   - 3
-  - 8
-  - 6
-  version: 2.3.8.6
+  - 10
+  - 1
+  version: 2.3.10.1
 platform: ruby
 authors: 
 - Jon Yurek
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-26 00:00:00 Z
+date: 2011-05-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   prerelease: false
@@ -153,7 +153,6 @@ files:
 - lib/generators/paperclip/USAGE
 - lib/paperclip/attachment.rb
 - lib/paperclip/callback_compatability.rb
-- lib/paperclip/command_line.rb
 - lib/paperclip/geometry.rb
 - lib/paperclip/interpolations.rb
 - lib/paperclip/iostream.rb
@@ -166,6 +165,7 @@ files:
 - lib/paperclip/railtie.rb
 - lib/paperclip/storage/cloud_files.rb
 - lib/paperclip/storage/filesystem.rb
+- lib/paperclip/storage/fog.rb
 - lib/paperclip/storage/s3.rb
 - lib/paperclip/storage.rb
 - lib/paperclip/style.rb
@@ -176,7 +176,6 @@ files:
 - lib/tasks/paperclip.rake
 - test/attachment_test.rb
 - test/cloudfiles.yml
-- test/command_line_test.rb
 - test/database.yml
 - test/fixtures/12k.png
 - test/fixtures/50x50.png
@@ -186,6 +185,7 @@ files:
 - test/fixtures/text.txt
 - test/fixtures/twopage.pdf
 - test/fixtures/uppercase.PNG
+- test/fog_test.rb
 - test/geometry_test.rb
 - test/helper.rb
 - test/integration_test.rb

data/lib/paperclip/command_line.rb

@@ -1,86 +0,0 @@
-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.blank?
-      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/test/command_line_test.rb

@@ -1,138 +0,0 @@
-require './test/helper'
-
-class CommandLineTest < Test::Unit::TestCase
-  def setup
-    Paperclip::CommandLine.path = nil
-    File.stubs(:exist?).with("/dev/null").returns(true)
-  end
-
-  should "allow colons in parameters" do
-    cmd = Paperclip::CommandLine.new("convert", "'a.jpg' -resize 175x220> -size 175x220 xc:black +swap -gravity center -composite 'b.jpg'", :swallow_stderr => false)
-    assert_equal "convert 'a.jpg' -resize 175x220> -size 175x220 xc:black +swap -gravity center -composite 'b.jpg'", cmd.command 
-  end
-
-  should "take a command and parameters and produce a shell command for bash" do
-    cmd = Paperclip::CommandLine.new("convert", "a.jpg b.png", :swallow_stderr => false)
-    assert_equal "convert a.jpg b.png", cmd.command
-  end
-
-  should "be able to set a path and produce commands with that path" do
-    Paperclip::CommandLine.path = "/opt/bin"
-    cmd = Paperclip::CommandLine.new("convert", "a.jpg b.png", :swallow_stderr => false)
-    assert_equal "/opt/bin/convert a.jpg b.png", cmd.command
-  end
-
-  should "be able to interpolate quoted variables into the parameters" do
-    cmd = Paperclip::CommandLine.new("convert",
-                                     ":one :{two}",
-                                     :one => "a.jpg",
-                                     :two => "b.png",
-                                     :swallow_stderr => false)
-    assert_equal "convert 'a.jpg' 'b.png'", cmd.command
-  end
-
-  should "quote command line options differently if we're on windows" do
-    File.stubs(:exist?).with("/dev/null").returns(false)
-    cmd = Paperclip::CommandLine.new("convert",
-                                     ":one :{two}",
-                                     :one => "a.jpg",
-                                     :two => "b.png",
-                                     :swallow_stderr => false)
-    assert_equal 'convert "a.jpg" "b.png"', cmd.command
-  end
-
-  should "be able to quote and interpolate dangerous variables" do
-    cmd = Paperclip::CommandLine.new("convert",
-                                     ":one :two",
-                                     :one => "`rm -rf`.jpg",
-                                     :two => "ha'ha.png",
-                                     :swallow_stderr => false)
-    assert_equal "convert '`rm -rf`.jpg' 'ha'\\''ha.png'", cmd.command
-  end
-
-  should "be able to quote and interpolate dangerous variables even on windows" do
-    File.stubs(:exist?).with("/dev/null").returns(false)
-    cmd = Paperclip::CommandLine.new("convert",
-                                     ":one :two",
-                                     :one => "`rm -rf`.jpg",
-                                     :two => "ha'ha.png",
-                                     :swallow_stderr => false)
-    assert_equal %{convert "`rm -rf`.jpg" "ha'ha.png"}, cmd.command
-  end
-
-  should "add redirection to get rid of stderr in bash" do
-    File.stubs(:exist?).with("/dev/null").returns(true)
-    cmd = Paperclip::CommandLine.new("convert",
-                                     "a.jpg b.png",
-                                     :swallow_stderr => true)
-
-    assert_equal "convert a.jpg b.png 2>/dev/null", cmd.command
-  end
-
-  should "add redirection to get rid of stderr in cmd.exe" do
-    File.stubs(:exist?).with("/dev/null").returns(false)
-    cmd = Paperclip::CommandLine.new("convert",
-                                     "a.jpg b.png",
-                                     :swallow_stderr => true)
-
-    assert_equal "convert a.jpg b.png 2>NUL", cmd.command
-  end
-
-  should "raise if trying to interpolate :swallow_stderr or :expected_outcodes" do
-    cmd = Paperclip::CommandLine.new("convert",
-                                     ":swallow_stderr :expected_outcodes",
-                                     :swallow_stderr => false,
-                                     :expected_outcodes => [0, 1])
-    assert_raise(Paperclip::PaperclipCommandLineError) do
-      cmd.command
-    end
-  end
-
-  should "run the #command it's given and return the output" do
-    cmd = Paperclip::CommandLine.new("convert", "a.jpg b.png", :swallow_stderr => false)
-    cmd.class.stubs(:"`").with("convert a.jpg b.png").returns(:correct_value)
-    with_exitstatus_returning(0) do
-      assert_equal :correct_value, cmd.run
-    end
-  end
-
-  should "raise a PaperclipCommandLineError if the result code isn't expected" do
-    cmd = Paperclip::CommandLine.new("convert", "a.jpg b.png", :swallow_stderr => false)
-    cmd.class.stubs(:"`").with("convert a.jpg b.png").returns(:correct_value)
-    with_exitstatus_returning(1) do
-      assert_raises(Paperclip::PaperclipCommandLineError) do
-        cmd.run
-      end
-    end
-  end
-
-  should "not raise a PaperclipCommandLineError if the result code is expected" do
-    cmd = Paperclip::CommandLine.new("convert",
-                                     "a.jpg b.png",
-                                     :expected_outcodes => [0, 1],
-                                     :swallow_stderr => false)
-    cmd.class.stubs(:"`").with("convert a.jpg b.png").returns(:correct_value)
-    with_exitstatus_returning(1) do
-      assert_nothing_raised do
-        cmd.run
-      end
-    end
-  end
-
-  should "log the command" do
-    cmd = Paperclip::CommandLine.new("convert", "a.jpg b.png", :swallow_stderr => false)
-    cmd.class.stubs(:'`')
-    Paperclip.expects(:log).with("convert a.jpg b.png")
-    cmd.run
-  end
-
-  should "detect that the system is unix or windows based on presence of /dev/null" do
-    File.stubs(:exist?).returns(true)
-    assert Paperclip::CommandLine.unix?
-  end
-
-  should "detect that the system is not unix or windows based on absence of /dev/null" do
-    File.stubs(:exist?).returns(false)
-    assert ! Paperclip::CommandLine.unix?
-  end
-end