jr-paperclip 7.3.0 → 8.0.0.beta.1

data/lib/paperclip/version.rb

@@ -1,3 +1,3 @@
 module Paperclip
-  VERSION = "7.3.0" unless defined?(Paperclip::VERSION)
+  VERSION = "8.0.0.beta.1" unless defined?(Paperclip::VERSION)
 end

data/lib/paperclip.rb

@@ -1,5 +1,5 @@
-# Paperclip allows file attachments that are stored in the filesystem. All graphical
-# transformations are done using the Graphics/ImageMagick command line utilities and
+# Paperclip allows file attachments that are stored in the filesystem. Graphical
+# transformations are done using command line utilities (ImageMagick or libvips) and
 # are stored in Tempfiles until the record is saved. Paperclip does not require a
 # separate model for storing the attachment's information, instead adding a few simple
 # columns to your table.
@@ -77,6 +77,17 @@ module Paperclip
   extend Logger
   extend ProcessorHelpers
 
+  AVAILABLE_BACKENDS = [:image_magick, :vips].freeze
+
+  def self.resolve_backend(backend)
+    backend ||= :image_magick
+    unless AVAILABLE_BACKENDS.include?(backend)
+      log("Warning: Invalid backend: #{backend}. Falling back to :image_magick. Allowed backends: #{AVAILABLE_BACKENDS.join(', ')}")
+      backend = :image_magick
+    end
+    backend
+  end
+
   # Provides configurability to Paperclip. The options available are:
   # * whiny: Will raise an error if Paperclip cannot process thumbnails of
   #   an uploaded image. Defaults to true.
@@ -98,7 +109,8 @@ module Paperclip
       use_exif_orientation: true,
       whiny: true,
       is_windows: Gem.win_platform?,
-      add_validation_errors_to: :both
+      add_validation_errors_to: :both,
+      backend: :image_magick
     }
   end
 
@@ -155,12 +167,17 @@ module Paperclip
     # * +whiny+: Will raise an error if Paperclip cannot post_process an uploaded file due
     #   to a command line error. This will override the global setting for this attachment.
     #   Defaults to true.
-    # * +convert_options+: When creating thumbnails, use this free-form options
-    #   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)
-    #   Note that this option takes a hash of options, each of which correspond to the style
+    # * +backend+: Chooses the image processing backend. Options are :image_magick (default)
+    #   or :vips. The vips backend uses libvips which is significantly faster and uses less
+    #   memory. Can be set globally via Paperclip.options[:backend] or per-attachment.
+    #     has_attached_file :avatar, :styles => { :thumb => "100x100#" }, :backend => :vips
+    # * +convert_options+: Options passed to the image processor when creating thumbnails.
+    #   Works with both ImageMagick and libvips backends. Common cross-platform options:
+    #   "-strip" (remove metadata), "-quality N" (output quality), "-rotate N" (rotation),
+    #   "-flip"/"-flop" (mirror), "-blur 0xN" (gaussian blur), "-sharpen" (sharpen),
+    #   "-colorspace Gray" (grayscale). Some options are ImageMagick-only and will be
+    #   skipped with a warning when using the vips backend.
+    #   This option takes a hash of options, each of which correspond to the style
     #   of thumbnail being generated. You can also specify :all as a key, which will apply
     #   to all of the thumbnails being generated. If you specify options for the :original,
     #   it would be best if you did not specify destructive options, as the intent of keeping

data/paperclip.gemspec

@@ -19,11 +19,12 @@ Gem::Specification.new do |s|
 
   s.post_install_message = File.read("UPGRADING") if File.exist?("UPGRADING")
 
-  s.requirements << "ImageMagick"
-  s.required_ruby_version = ">= 3.2.0"
+  s.requirements << "ImageMagick or libvips"
+  s.required_ruby_version = ">= 3.0.0"
 
   s.add_dependency("activemodel", ">= 7.0.0")
   s.add_dependency("activesupport", ">= 7.0.0")
+  s.add_dependency("image_processing", "~> 1.14")
   s.add_dependency("marcel", ">= 1.0.1")
   s.add_dependency("mime-types")
   s.add_dependency("terrapin", ">= 0.6.0", "< 2.0")

data/spec/paperclip/attachment_definitions_spec.rb

@@ -10,4 +10,304 @@ describe "Attachment Definitions" do
 
     expect(Dummy.attachment_definitions).to eq expected
   end
+
+  describe "configuration isolation between models" do
+    # Helper method to safely remove a constant and clean up its registry entries
+    def cleanup_model(class_name)
+      return unless Object.const_defined?(class_name)
+
+      # Remove from Paperclip's AttachmentRegistry to prevent test pollution
+      Paperclip::AttachmentRegistry.clear
+      # Remove the constant
+      Object.send(:remove_const, class_name)
+    end
+
+    before do
+      # Clean up any existing class definitions before each test
+      cleanup_model(:ModelA)
+      cleanup_model(:ModelB)
+
+      # Create table for ModelA
+      ActiveRecord::Migration.create_table :model_as, force: true do |table|
+        table.column :attachment_file_name, :string
+        table.column :attachment_content_type, :string
+        table.column :attachment_file_size, :bigint
+        table.column :attachment_updated_at, :datetime
+      end
+
+      # Create table for ModelB
+      ActiveRecord::Migration.create_table :model_bs, force: true do |table|
+        table.column :attachment_file_name, :string
+        table.column :attachment_content_type, :string
+        table.column :attachment_file_size, :bigint
+        table.column :attachment_updated_at, :datetime
+      end
+    end
+
+    after do
+      # Clean up model classes to prevent test pollution
+      cleanup_model(:ModelA)
+      cleanup_model(:ModelB)
+
+      # Drop tables
+      ActiveRecord::Migration.drop_table :model_as, if_exists: true
+      ActiveRecord::Migration.drop_table :model_bs, if_exists: true
+    end
+
+    it "does not mutate default_options when configuring multiple models" do
+      # Capture original values of mutable options
+      original_path = Paperclip::Attachment.default_options[:path].dup
+      original_url = Paperclip::Attachment.default_options[:url].dup
+      original_default_url = Paperclip::Attachment.default_options[:default_url].dup
+      original_styles = Paperclip::Attachment.default_options[:styles].deep_dup
+      original_convert_options = Paperclip::Attachment.default_options[:convert_options].deep_dup
+
+      # Define ModelA with specific configuration
+      class ::ModelA < ActiveRecord::Base
+        include Paperclip::Glue
+        has_attached_file :attachment,
+                          path: "/model_a/:filename",
+                          styles: { thumb: "100x100" }
+        do_not_validate_attachment_file_type :attachment
+      end
+
+      # Define ModelB with different configuration
+      class ::ModelB < ActiveRecord::Base
+        include Paperclip::Glue
+        has_attached_file :attachment,
+                          path: "/model_b/:filename",
+                          styles: { large: "500x500" }
+        do_not_validate_attachment_file_type :attachment
+      end
+
+      # Verify default_options was not mutated
+      expect(Paperclip::Attachment.default_options[:path]).to eq original_path
+      expect(Paperclip::Attachment.default_options[:url]).to eq original_url
+      expect(Paperclip::Attachment.default_options[:default_url]).to eq original_default_url
+      expect(Paperclip::Attachment.default_options[:styles]).to eq original_styles
+      expect(Paperclip::Attachment.default_options[:convert_options]).to eq original_convert_options
+    end
+
+    it "keeps attachment configurations isolated between models" do
+      # Define ModelA with specific configuration
+      class ::ModelA < ActiveRecord::Base
+        include Paperclip::Glue
+        has_attached_file :attachment,
+                          path: "/model_a/:filename",
+                          styles: { thumb: "100x100" },
+                          default_url: "/missing_a.png"
+        do_not_validate_attachment_file_type :attachment
+      end
+
+      # Define ModelB with different configuration
+      class ::ModelB < ActiveRecord::Base
+        include Paperclip::Glue
+        has_attached_file :attachment,
+                          path: "/model_b/:filename",
+                          styles: { large: "500x500" },
+                          default_url: "/missing_b.png"
+        do_not_validate_attachment_file_type :attachment
+      end
+
+      # Create instances and access attachments
+      model_a = ModelA.new
+      model_b = ModelB.new
+
+      # Access attachment on ModelA first
+      attachment_a = model_a.attachment
+
+      # Access attachment on ModelB
+      attachment_b = model_b.attachment
+
+      # Verify configurations are isolated
+      expect(attachment_a.options[:path]).to eq "/model_a/:filename"
+      expect(attachment_a.options[:styles]).to eq({ thumb: "100x100" })
+      expect(attachment_a.options[:default_url]).to eq "/missing_a.png"
+
+      expect(attachment_b.options[:path]).to eq "/model_b/:filename"
+      expect(attachment_b.options[:styles]).to eq({ large: "500x500" })
+      expect(attachment_b.options[:default_url]).to eq "/missing_b.png"
+
+      # Verify attachment_definitions are also isolated
+      expect(ModelA.attachment_definitions[:attachment][:path]).to eq "/model_a/:filename"
+      expect(ModelB.attachment_definitions[:attachment][:path]).to eq "/model_b/:filename"
+    end
+
+    it "does not leak configuration when accessing attachments in different order" do
+      # Define ModelA with specific configuration
+      class ::ModelA < ActiveRecord::Base
+        include Paperclip::Glue
+        has_attached_file :attachment,
+                          path: "/model_a/:filename",
+                          styles: { thumb: "100x100" }
+        do_not_validate_attachment_file_type :attachment
+      end
+
+      # Define ModelB with different configuration
+      class ::ModelB < ActiveRecord::Base
+        include Paperclip::Glue
+        has_attached_file :attachment,
+                          path: "/model_b/:filename",
+                          styles: { large: "500x500" }
+        do_not_validate_attachment_file_type :attachment
+      end
+
+      # Access ModelB first, then ModelA (reverse order of definition)
+      model_b = ModelB.new
+      attachment_b = model_b.attachment
+
+      model_a = ModelA.new
+      attachment_a = model_a.attachment
+
+      # Verify configurations remain correct
+      expect(attachment_a.options[:path]).to eq "/model_a/:filename"
+      expect(attachment_a.options[:styles]).to eq({ thumb: "100x100" })
+
+      expect(attachment_b.options[:path]).to eq "/model_b/:filename"
+      expect(attachment_b.options[:styles]).to eq({ large: "500x500" })
+    end
+
+    it "does not share options between multiple instances of the same model" do
+      class ::ModelA < ActiveRecord::Base
+        include Paperclip::Glue
+        has_attached_file :attachment,
+                          path: "/model_a/:filename",
+                          styles: { thumb: "100x100" }
+        do_not_validate_attachment_file_type :attachment
+      end
+
+      instance1 = ModelA.new
+      instance2 = ModelA.new
+
+      attachment1 = instance1.attachment
+      attachment2 = instance2.attachment
+
+      # Verify they have the same configuration values
+      expect(attachment1.options[:path]).to eq attachment2.options[:path]
+      expect(attachment1.options[:styles]).to eq attachment2.options[:styles]
+
+      # Verify the values are correct for both instances
+      expect(attachment1.options[:path]).to eq "/model_a/:filename"
+      expect(attachment2.options[:path]).to eq "/model_a/:filename"
+    end
+
+    context "with global default_options configured first" do
+      let(:original_default_options) { Paperclip::Attachment.default_options.deep_dup }
+
+      before do
+        # Simulate a Rails initializer setting global defaults
+        Paperclip::Attachment.default_options[:path] = "/global/:class/:attachment/:id/:style/:filename"
+        Paperclip::Attachment.default_options[:url] = "/global/:class/:attachment/:id/:style/:filename"
+        Paperclip::Attachment.default_options[:default_url] = "/global/missing.png"
+        Paperclip::Attachment.default_options[:styles] = { global_thumb: "50x50" }
+      end
+
+      after do
+        # Restore original default_options
+        Paperclip::Attachment.instance_variable_set(:@default_options, nil)
+      end
+
+      it "keeps model configurations isolated when global defaults are set" do
+        # Define ModelA that overrides some global defaults
+        class ::ModelA < ActiveRecord::Base
+          include Paperclip::Glue
+          has_attached_file :attachment,
+                            path: "/model_a/:filename",
+                            styles: { thumb: "100x100" }
+          do_not_validate_attachment_file_type :attachment
+        end
+
+        # Define ModelB that overrides different global defaults
+        class ::ModelB < ActiveRecord::Base
+          include Paperclip::Glue
+          has_attached_file :attachment,
+                            path: "/model_b/:filename",
+                            styles: { large: "500x500" }
+          do_not_validate_attachment_file_type :attachment
+        end
+
+        model_a = ModelA.new
+        model_b = ModelB.new
+
+        attachment_a = model_a.attachment
+        attachment_b = model_b.attachment
+
+        # Verify ModelA has its own path, and styles are deep_merged with global defaults
+        expect(attachment_a.options[:path]).to eq "/model_a/:filename"
+        expect(attachment_a.options[:styles]).to include(thumb: "100x100")
+        expect(attachment_a.options[:styles]).to include(global_thumb: "50x50") # inherited from global
+        expect(attachment_a.options[:url]).to eq "/global/:class/:attachment/:id/:style/:filename"
+        expect(attachment_a.options[:default_url]).to eq "/global/missing.png"
+
+        # Verify ModelB has its own path, and styles are deep_merged with global defaults
+        expect(attachment_b.options[:path]).to eq "/model_b/:filename"
+        expect(attachment_b.options[:styles]).to include(large: "500x500")
+        expect(attachment_b.options[:styles]).to include(global_thumb: "50x50") # inherited from global
+        expect(attachment_b.options[:url]).to eq "/global/:class/:attachment/:id/:style/:filename"
+        expect(attachment_b.options[:default_url]).to eq "/global/missing.png"
+
+        # Verify ModelA's styles do NOT leak to ModelB and vice versa
+        expect(attachment_a.options[:styles]).not_to have_key(:large)
+        expect(attachment_b.options[:styles]).not_to have_key(:thumb)
+      end
+
+      it "does not mutate global defaults when models override them" do
+        # Capture global defaults before defining models
+        global_path = Paperclip::Attachment.default_options[:path]
+        global_styles = Paperclip::Attachment.default_options[:styles].deep_dup
+
+        class ::ModelA < ActiveRecord::Base
+          include Paperclip::Glue
+          has_attached_file :attachment,
+                            path: "/model_a/:filename",
+                            styles: { thumb: "100x100" }
+          do_not_validate_attachment_file_type :attachment
+        end
+
+        # Access the attachment to trigger any potential mutation
+        model_a = ModelA.new
+        _attachment_a = model_a.attachment
+
+        # Global defaults should remain unchanged
+        expect(Paperclip::Attachment.default_options[:path]).to eq global_path
+        expect(Paperclip::Attachment.default_options[:styles]).to eq global_styles
+      end
+
+      it "does not leak ModelA config to ModelB when both override global defaults" do
+        class ::ModelA < ActiveRecord::Base
+          include Paperclip::Glue
+          has_attached_file :attachment,
+                            path: "/model_a/:filename",
+                            styles: { thumb: "100x100" },
+                            convert_options: { all: "-quality 80" }
+          do_not_validate_attachment_file_type :attachment
+        end
+
+        class ::ModelB < ActiveRecord::Base
+          include Paperclip::Glue
+          has_attached_file :attachment,
+                            path: "/model_b/:filename",
+                            styles: { large: "500x500" },
+                            convert_options: { all: "-quality 90" }
+          do_not_validate_attachment_file_type :attachment
+        end
+
+        # Access ModelA first
+        model_a = ModelA.new
+        attachment_a = model_a.attachment
+
+        # Then access ModelB
+        model_b = ModelB.new
+        attachment_b = model_b.attachment
+
+        # Verify convert_options are isolated
+        expect(attachment_a.options[:convert_options]).to eq({ all: "-quality 80" })
+        expect(attachment_b.options[:convert_options]).to eq({ all: "-quality 90" })
+
+        # Verify other options remain isolated
+        expect(attachment_a.options[:path]).to eq "/model_a/:filename"
+        expect(attachment_b.options[:path]).to eq "/model_b/:filename"
+      end
+    end
+  end
 end

data/spec/paperclip/attachment_spec.rb

@@ -670,7 +670,7 @@ describe Paperclip::Attachment do
     context "when error is meaningful for the end user" do
       before do
         expect(Paperclip::Thumbnail).to receive(:make).and_raise(
-          Paperclip::Errors::NotIdentifiedByImageMagickError,
+          Paperclip::Errors::NotIdentifiedByBackendError,
           "cannot be processed."
         )
       end

data/spec/paperclip/geometry_detector_spec.rb

@@ -1,47 +1,96 @@
 require "spec_helper"
 
 describe Paperclip::GeometryDetector do
-  it "identifies an image and extract its dimensions" do
-    allow_any_instance_of(Paperclip::GeometryParser).to receive(:make).and_return(:correct)
-    file = fixture_file("5k.png")
-    factory = Paperclip::GeometryDetector.new(file)
+  [:image_magick, :vips].each do |backend|
+    context "when configured to use #{backend}" do
+      let(:original_backend) { Paperclip.options[:backend] }
 
-    output = factory.make
+      before do
+        Paperclip.options[:backend] = backend
+      end
 
-    expect(output).to eq :correct
-  end
+      after do
+        Paperclip.options[:backend] = original_backend
+      end
 
-  it "identifies an image and extract its dimensions and orientation" do
-    allow_any_instance_of(Paperclip::GeometryParser).to receive(:make).and_return(:correct)
-    file = fixture_file("rotated.jpg")
-    factory = Paperclip::GeometryDetector.new(file)
+      it "identifies an image and extract its dimensions" do
+        allow_any_instance_of(Paperclip::GeometryParser).to receive(:make).and_return(:correct)
+        file = fixture_file("5k.png")
+        factory = Paperclip::GeometryDetector.new(file)
 
-    output = factory.make
+        output = factory.make
 
-    expect(output).to eq :correct
-  end
+        expect(output).to eq :correct
+      end
 
-  it "avoids reading EXIF orientation if so configured" do
-    begin
-      Paperclip.options[:use_exif_orientation] = false
-      allow_any_instance_of(Paperclip::GeometryParser).to receive(:make).and_return(:correct)
-      file = fixture_file("rotated.jpg")
-      factory = Paperclip::GeometryDetector.new(file)
+      it "identifies an image and extract its dimensions and orientation" do
+        allow_any_instance_of(Paperclip::GeometryParser).to receive(:make).and_return(:correct)
+        file = fixture_file("rotated.jpg")
+        factory = Paperclip::GeometryDetector.new(file)
 
-      output = factory.make
+        output = factory.make
 
-      expect(output).to eq :correct
-    ensure
-      Paperclip.options[:use_exif_orientation] = true
-    end
-  end
+        expect(output).to eq :correct
+      end
+
+      it "avoids reading EXIF orientation if so configured" do
+        begin
+          Paperclip.options[:use_exif_orientation] = false
+          allow_any_instance_of(Paperclip::GeometryParser).to receive(:make).and_return(:correct)
+          file = fixture_file("rotated.jpg")
+          factory = Paperclip::GeometryDetector.new(file)
+
+          output = factory.make
+
+          expect(output).to eq :correct
+        ensure
+          Paperclip.options[:use_exif_orientation] = true
+        end
+      end
 
-  it "raises an exception with a message when the file is not an image" do
-    file = fixture_file("text.txt")
-    factory = Paperclip::GeometryDetector.new(file)
+      it "raises an exception with a message when the file is not an image" do
+        file = fixture_file("text.txt")
+        factory = Paperclip::GeometryDetector.new(file)
 
-    expect do
-      factory.make
-    end.to raise_error(Paperclip::Errors::NotIdentifiedByImageMagickError, "Could not identify image size")
+        expect do
+          factory.make
+        end.to raise_error(Paperclip::Errors::NotIdentifiedByBackendError, "Could not identify image size")
+      end
+
+      it "uses the correct backend to identify the image" do
+        if backend == :vips
+          begin
+            require "vips"
+          rescue LoadError
+            skip "ruby-vips gem not available"
+          end
+          expect(Vips::Image).to receive(:new_from_file).and_call_original
+          expect(Paperclip).not_to receive(:run).with(include("identify"), any_args)
+        else
+          expect(Paperclip).to receive(:run).with(include("identify"), any_args).and_call_original
+        end
+
+        file = fixture_file("5k.png")
+        factory = Paperclip::GeometryDetector.new(file)
+
+        geometry = factory.make
+        expect(geometry.width).to eq(434)
+        expect(geometry.height).to eq(66)
+      end
+
+      if backend == :vips
+        it "raises CommandNotFoundError (and not NameError) when vips is missing" do
+          hide_const("Vips")
+          allow_any_instance_of(Paperclip::GeometryDetector).to receive(:require).with("vips").and_raise(LoadError)
+
+          file = fixture_file("5k.png")
+          factory = Paperclip::GeometryDetector.new(file)
+
+          expect {
+            factory.make
+          }.to raise_error(Paperclip::Errors::CommandNotFoundError, /Could not load ruby-vips/)
+        end
+      end
+    end
   end
 end

data/spec/paperclip/geometry_spec.rb

@@ -149,7 +149,7 @@ describe Paperclip::Geometry do
       file = "/home/This File Does Not Exist.omg"
       expect do
         @geo = Paperclip::Geometry.from_file(file)
-      end.to raise_error(Paperclip::Errors::NotIdentifiedByImageMagickError,
+      end.to raise_error(Paperclip::Errors::NotIdentifiedByBackendError,
                          "Could not identify image size")
     end
 
@@ -157,7 +157,7 @@ describe Paperclip::Geometry do
       file = ""
       expect do
         @geo = Paperclip::Geometry.from_file(file)
-      end.to raise_error(Paperclip::Errors::NotIdentifiedByImageMagickError,
+      end.to raise_error(Paperclip::Errors::NotIdentifiedByBackendError,
                          "Cannot find the geometry of a file with a blank name")
     end
 
@@ -165,7 +165,7 @@ describe Paperclip::Geometry do
       file = nil
       expect do
         @geo = Paperclip::Geometry.from_file(file)
-      end.to raise_error(Paperclip::Errors::NotIdentifiedByImageMagickError,
+      end.to raise_error(Paperclip::Errors::NotIdentifiedByBackendError,
                          "Cannot find the geometry of a file with a blank name")
     end
 
@@ -174,13 +174,15 @@ describe Paperclip::Geometry do
       allow(file).to receive(:respond_to?).with(:path).and_return(true)
       expect do
         @geo = Paperclip::Geometry.from_file(file)
-      end.to raise_error(Paperclip::Errors::NotIdentifiedByImageMagickError,
+      end.to raise_error(Paperclip::Errors::NotIdentifiedByBackendError,
                          "Cannot find the geometry of a file with a blank name")
     end
 
-    it "lets us know when a command isn't found versus a processing error" do
+    it "lets us know when a command isn't found versus a processing error when using imagemagick" do
       old_path = ENV["PATH"]
+      old_backend = Paperclip.options[:backend]
       begin
+        Paperclip.options[:backend] = :image_magick
         ENV["PATH"] = ""
         assert_raises(Paperclip::Errors::CommandNotFoundError) do
           file = fixture_file("5k.png")
@@ -188,6 +190,7 @@ describe Paperclip::Geometry do
         end
       ensure
         ENV["PATH"] = old_path
+        Paperclip.options[:backend] = old_backend
       end
     end
 

data/spec/paperclip/helpers_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe Paperclip::Helpers do
+  describe ".imagemagick7?" do
+    before do
+      if Paperclip.instance_variable_defined?(:@imagemagick7)
+        Paperclip.send(:remove_instance_variable, :@imagemagick7)
+      end
+    end
+
+    after do
+      if Paperclip.instance_variable_defined?(:@imagemagick7)
+        Paperclip.send(:remove_instance_variable, :@imagemagick7)
+      end
+    end
+
+    it "returns true if magick command is found" do
+      allow(Paperclip).to receive(:which).with("magick").and_return("/usr/bin/magick")
+      expect(Paperclip.imagemagick7?).to be true
+    end
+
+    it "returns false if magick command is not found" do
+      allow(Paperclip).to receive(:which).with("magick").and_return(nil)
+      expect(Paperclip.imagemagick7?).to be false
+    end
+
+    it "caches the result" do
+      expect(Paperclip).to receive(:which).with("magick").once.and_return("/usr/bin/magick")
+      Paperclip.imagemagick7?
+      Paperclip.imagemagick7?
+    end
+  end
+
+  describe ".which" do
+    it "finds an executable in the PATH" do
+      allow(ENV).to receive(:[]).with("PATH").and_return("/usr/bin:/bin")
+      allow(ENV).to receive(:[]).with("PATHEXT").and_return(nil)
+      allow(File).to receive(:executable?).with("/usr/bin/ruby").and_return(true)
+      expect(Paperclip.which("ruby")).to eq("/usr/bin/ruby")
+    end
+
+    it "returns nil if executable is not found" do
+      allow(ENV).to receive(:[]).with("PATH").and_return("/usr/bin:/bin")
+      allow(ENV).to receive(:[]).with("PATHEXT").and_return(nil)
+      allow(File).to receive(:executable?).and_return(false)
+      expect(Paperclip.which("nonexistent")).to be_nil
+    end
+  end
+end