jr-paperclip 7.3.0 → 8.0.0.beta.1

data/spec/paperclip/lazy_thumbnail_compatibility_spec.rb

@@ -0,0 +1,266 @@
+require "spec_helper"
+
+# This spec tests compatibility with Mastodon's LazyThumbnail pattern.
+# LazyThumbnail is a subclass of Paperclip::Thumbnail that conditionally
+# skips processing when the image doesn't need transformation.
+# See: https://github.com/mastodon/mastodon/blob/main/lib/paperclip/lazy_thumbnail.rb
+
+module Paperclip
+  class LazyThumbnail < Paperclip::Thumbnail
+    def make
+      return File.open(@file.path) unless needs_convert?
+
+      if options[:geometry]
+        min_side = [@current_geometry.width, @current_geometry.height].min.to_i
+        options[:geometry] = "#{min_side}x#{min_side}#" if @target_geometry.square? && min_side < @target_geometry.width
+      elsif options[:pixels]
+        width  = Math.sqrt(options[:pixels] * (@current_geometry.width.to_f / @current_geometry.height)).round.to_i
+        height = Math.sqrt(options[:pixels] * (@current_geometry.height.to_f / @current_geometry.width)).round.to_i
+        options[:geometry] = "#{width}x#{height}>"
+      end
+
+      Paperclip::Thumbnail.make(file, options, attachment)
+    end
+
+    private
+
+    def needs_convert?
+      needs_different_geometry? || needs_different_format? || needs_metadata_stripping?
+    end
+
+    def needs_different_geometry?
+      (options[:geometry] && @current_geometry.width != @target_geometry.width && @current_geometry.height != @target_geometry.height) ||
+        (options[:pixels] && @current_geometry.width * @current_geometry.height > options[:pixels])
+    end
+
+    def needs_different_format?
+      @format.present? && @current_format != @format
+    end
+
+    def needs_metadata_stripping?
+      @attachment.respond_to?(:instance) && @attachment.instance.respond_to?(:local?) && @attachment.instance.local?
+    end
+  end
+end
+
+describe Paperclip::LazyThumbnail do
+  let(:file) { File.new(fixture_file("5k.png"), "rb") }
+  let(:rotated_file) { File.new(fixture_file("rotated.jpg"), "rb") }
+  let(:attachment) { double("Attachment", options: {}, instance: double(local?: false)) }
+
+  after do
+    file.close
+    rotated_file.close rescue nil
+  end
+
+  describe "basic compatibility" do
+    it "inherits from Paperclip::Thumbnail" do
+      expect(Paperclip::LazyThumbnail.superclass).to eq(Paperclip::Thumbnail)
+    end
+
+    it "can access current_geometry" do
+      processor = described_class.new(file, { geometry: "100x100" }, attachment)
+      expect(processor.current_geometry).to be_a(Paperclip::Geometry)
+      expect(processor.current_geometry.width).to be > 0
+      expect(processor.current_geometry.height).to be > 0
+    end
+
+    it "can access target_geometry" do
+      processor = described_class.new(file, { geometry: "100x100#" }, attachment)
+      expect(processor.target_geometry).to be_a(Paperclip::Geometry)
+      expect(processor.target_geometry.width).to eq(100)
+      expect(processor.target_geometry.height).to eq(100)
+    end
+
+    it "target_geometry responds to square?" do
+      processor = described_class.new(file, { geometry: "100x100#" }, attachment)
+      expect(processor.target_geometry).to respond_to(:square?)
+      expect(processor.target_geometry.square?).to be true
+    end
+
+    it "can access format and current_format" do
+      processor = described_class.new(file, { geometry: "100x100", format: :jpg }, attachment)
+      expect(processor.format).to eq(:jpg)
+    end
+  end
+
+  describe "with ImageMagick backend" do
+    let(:attachment) { double("Attachment", options: { backend: :image_magick }, instance: double(local?: false)) }
+
+    it "processes images when geometry change is needed" do
+      processor = described_class.new(file, { geometry: "50x50#" }, attachment)
+      result = processor.make
+
+      expect(File.exist?(result.path)).to be true
+      dimensions = `identify -format "%wx%h" "#{result.path}"`.strip
+      expect(dimensions).to eq("50x50")
+    end
+
+    it "processes images when format change is needed" do
+      processor = described_class.new(file, { geometry: "100x100", format: :jpg }, attachment)
+      result = processor.make
+
+      expect(File.exist?(result.path)).to be true
+      expect(result.path).to end_with(".jpg")
+    end
+
+    it "skips processing when no changes needed" do
+      # Create a processor where geometry matches source
+      processor = described_class.new(file, { geometry: "434x66" }, attachment)
+
+      # Since the source is 434x66 (5k.png dimensions), and target is same,
+      # needs_different_geometry? returns false
+      result = processor.make
+
+      # Result should be the original file (File.open(@file.path))
+      expect(File.exist?(result.path)).to be true
+    end
+
+    it "handles square geometry optimization" do
+      # Source is 434x66, min_side is 66
+      # Requesting 100x100# square, but min_side (66) < target width (100)
+      # So geometry should be adjusted to "66x66#"
+      processor = described_class.new(file, { geometry: "100x100#" }, attachment)
+      result = processor.make
+
+      expect(File.exist?(result.path)).to be true
+      dimensions = `identify -format "%wx%h" "#{result.path}"`.strip
+      expect(dimensions).to eq("66x66")
+    end
+  end
+
+  describe "with libvips backend" do
+    let(:attachment) { double("Attachment", options: { backend: :vips }, instance: double(local?: false)) }
+
+    before do
+      begin
+        require "vips"
+      rescue LoadError
+        skip "libvips not installed"
+      end
+    end
+
+    it "processes images when geometry change is needed" do
+      processor = described_class.new(file, { geometry: "50x50#" }, attachment)
+      result = processor.make
+
+      expect(File.exist?(result.path)).to be true
+      dimensions = `identify -format "%wx%h" "#{result.path}"`.strip
+      expect(dimensions).to eq("50x50")
+    end
+
+    it "processes images when format change is needed" do
+      processor = described_class.new(file, { geometry: "100x100", format: :jpg }, attachment)
+      result = processor.make
+
+      expect(File.exist?(result.path)).to be true
+      expect(result.path).to end_with(".jpg")
+    end
+
+    it "skips processing when no changes needed" do
+      processor = described_class.new(file, { geometry: "434x66" }, attachment)
+      result = processor.make
+      expect(File.exist?(result.path)).to be true
+    end
+
+    it "handles square geometry optimization" do
+      processor = described_class.new(file, { geometry: "100x100#" }, attachment)
+      result = processor.make
+
+      expect(File.exist?(result.path)).to be true
+      dimensions = `identify -format "%wx%h" "#{result.path}"`.strip
+      expect(dimensions).to eq("66x66")
+    end
+  end
+
+  describe "pixels-based resizing (Mastodon-specific)" do
+    let(:attachment) { double("Attachment", options: {}, instance: double(local?: false)) }
+
+    context "with ImageMagick backend" do
+      let(:attachment) { double("Attachment", options: { backend: :image_magick }, instance: double(local?: false)) }
+
+      it "resizes based on maximum pixel count" do
+        # Source is 434x66 = 28,644 pixels
+        # Request max 10,000 pixels
+        processor = described_class.new(file, { pixels: 10_000 }, attachment)
+        result = processor.make
+
+        expect(File.exist?(result.path)).to be true
+        dimensions = `identify -format "%wx%h" "#{result.path}"`.strip
+        width, height = dimensions.split("x").map(&:to_i)
+        expect(width * height).to be <= 10_000
+      end
+
+      it "skips processing when image is already small enough" do
+        # Source is 434x66 = 28,644 pixels
+        # Request max 50,000 pixels - no resize needed
+        processor = described_class.new(file, { pixels: 50_000 }, attachment)
+        result = processor.make
+
+        expect(File.exist?(result.path)).to be true
+      end
+    end
+
+    context "with libvips backend" do
+      let(:attachment) { double("Attachment", options: { backend: :vips }, instance: double(local?: false)) }
+
+      before do
+        begin
+          require "vips"
+        rescue LoadError
+          skip "libvips not installed"
+        end
+      end
+
+      it "resizes based on maximum pixel count" do
+        processor = described_class.new(file, { pixels: 10_000 }, attachment)
+        result = processor.make
+
+        expect(File.exist?(result.path)).to be true
+        dimensions = `identify -format "%wx%h" "#{result.path}"`.strip
+        width, height = dimensions.split("x").map(&:to_i)
+        expect(width * height).to be <= 10_000
+      end
+    end
+  end
+
+  describe "metadata stripping trigger" do
+    it "processes when attachment instance is local" do
+      local_instance = double(local?: true)
+      local_attachment = double("Attachment", options: {}, instance: local_instance)
+
+      processor = described_class.new(file, { geometry: "434x66" }, local_attachment)
+
+      # Even with matching geometry, should process because local? is true
+      # This is verified by the fact that make doesn't just return the original file
+      result = processor.make
+      expect(File.exist?(result.path)).to be true
+    end
+  end
+
+  describe "Thumbnail.make class method" do
+    it "is available and works correctly" do
+      expect(Paperclip::Thumbnail).to respond_to(:make)
+
+      result = Paperclip::Thumbnail.make(file, { geometry: "50x50#" }, attachment)
+      expect(File.exist?(result.path)).to be true
+
+      dimensions = `identify -format "%wx%h" "#{result.path}"`.strip
+      expect(dimensions).to eq("50x50")
+    end
+
+    it "respects backend option" do
+      begin
+        require "vips"
+      rescue LoadError
+        skip "libvips not installed"
+      end
+
+      result = Paperclip::Thumbnail.make(file, { geometry: "50x50#", backend: :vips }, attachment)
+      expect(File.exist?(result.path)).to be true
+
+      dimensions = `identify -format "%wx%h" "#{result.path}"`.strip
+      expect(dimensions).to eq("50x50")
+    end
+  end
+end

data/spec/paperclip/processor_spec.rb

@@ -11,16 +11,50 @@ describe Paperclip::Processor do
   context "Calling #convert" do
     it "runs the convert command with Terrapin" do
       Paperclip.options[:log_command] = false
+      allow(Paperclip).to receive(:imagemagick7?).and_return(false)
+      Paperclip.options[:is_windows] = false
       expect(Terrapin::CommandLine).to receive(:new).with("convert", "stuff", {}).and_return(double(run: nil))
       Paperclip::Processor.new("filename").convert("stuff")
     end
+
+    it "runs the magick convert command when ImageMagick 7 is present" do
+      Paperclip.options[:log_command] = false
+      allow(Paperclip).to receive(:imagemagick7?).and_return(true)
+      expect(Terrapin::CommandLine).to receive(:new).with("magick", "stuff", {}).and_return(double(run: nil))
+      Paperclip::Processor.new("filename").convert("stuff")
+    end
   end
 
   context "Calling #identify" do
-    it "runs the identify command with Terrapin" do
+    it "runs the identify command" do
       Paperclip.options[:log_command] = false
+      allow(Paperclip).to receive(:imagemagick7?).and_return(false)
+      Paperclip.options[:is_windows] = false
       expect(Terrapin::CommandLine).to receive(:new).with("identify", "stuff", {}).and_return(double(run: nil))
       Paperclip::Processor.new("filename").identify("stuff")
     end
+
+    it "runs the magick identify command when ImageMagick 7 is present" do
+      Paperclip.options[:log_command] = false
+      allow(Paperclip).to receive(:imagemagick7?).and_return(true)
+      expect(Terrapin::CommandLine).to receive(:new).with("magick identify", "stuff", {}).and_return(double(run: nil))
+      Paperclip::Processor.new("filename").identify("stuff")
+    end
+  end
+
+  context "Calling #vips" do
+    it "runs the vips command with Paperclip.run" do
+      Paperclip.options[:log_command] = false
+      expect(Paperclip).to receive(:run).with("vips", "stuff", { :some => "args" })
+      Paperclip::Processor.new("filename").vips("stuff", { :some => "args" })
+    end
+  end
+
+  context "Calling #vipsheader" do
+    it "runs the vipsheader command with Paperclip.run" do
+      Paperclip.options[:log_command] = false
+      expect(Paperclip).to receive(:run).with("vipsheader", "stuff", { :some => "args" })
+      Paperclip::Processor.new("filename").vipsheader("stuff", { :some => "args" })
+    end
   end
 end

data/spec/paperclip/style_spec.rb

@@ -212,6 +212,64 @@ describe Paperclip::Style do
     end
   end
 
+  context "A style rule with per-style backend selection" do
+    before do
+      @attachment = attachment path: ":basename.:extension",
+                               styles: {
+                                 vips_style: {
+                                   geometry: "800x800>",
+                                   backend: :vips
+                                 },
+                                 magick_style: {
+                                   geometry: "100x100#",
+                                   backend: :image_magick
+                                 },
+                                 default_style: {
+                                   geometry: "200x200"
+                                 }
+                               }
+    end
+
+    it "passes backend option through to processor_options for vips style" do
+      assert_equal :vips, @attachment.styles[:vips_style].processor_options[:backend]
+    end
+
+    it "passes backend option through to processor_options for image_magick style" do
+      assert_equal :image_magick, @attachment.styles[:magick_style].processor_options[:backend]
+    end
+
+    it "does not include backend in processor_options when not specified" do
+      expect(@attachment.styles[:default_style].processor_options).not_to have_key(:backend)
+    end
+
+    it "includes geometry correctly for each style" do
+      assert_equal "800x800>", @attachment.styles[:vips_style].geometry
+      assert_equal "100x100#", @attachment.styles[:magick_style].geometry
+      assert_equal "200x200", @attachment.styles[:default_style].geometry
+    end
+
+    it "allows accessing backend via hash notation" do
+      assert_equal :vips, @attachment.styles[:vips_style][:backend]
+      assert_equal :image_magick, @attachment.styles[:magick_style][:backend]
+    end
+  end
+
+  context "A style rule with backend as a proc" do
+    before do
+      @attachment = attachment path: ":basename.:extension",
+                               styles: {
+                                 dynamic_backend: {
+                                   geometry: "500x500",
+                                   backend: lambda { |_a| :vips }
+                                 }
+                               }
+    end
+
+    it "evaluates proc when processor_options are requested" do
+      assert_equal :vips, @attachment.styles[:dynamic_backend].processor_options[:backend]
+    end
+  end
+
   context "A style rule supplied with default format" do
     before do
       @attachment = attachment default_format: :png,

data/spec/paperclip/thumbnail_custom_options_spec.rb

@@ -0,0 +1,173 @@
+require "spec_helper"
+
+describe Paperclip::Thumbnail do
+  context "with ImageMagick specific + options" do
+    before do
+      @file = File.new(fixture_file("5k.png"), "rb")
+      @attachment = double("Attachment", options: {})
+    end
+
+    after { @file.close }
+
+    it "correctly applies options starting with +" do
+      # The user's specific options - with Shellwords, quoted values are parsed correctly
+      convert_options = '-coalesce +profile "!icc,*" +set date:modify +set date:create +set date:timestamp'
+
+      thumb = Paperclip::Thumbnail.new(@file, {
+                                         geometry: "100x100",
+                                         convert_options: convert_options,
+                                         backend: :image_magick,
+                                       }, @attachment)
+
+      # Spy on the pipeline to verify the correct methods/arguments are called on it.
+      allow(thumb).to receive(:apply_single_option).and_call_original
+      expect { thumb.make }.not_to raise_error
+
+      # With Shellwords parsing, the outer quotes are stripped from "!icc,*" -> !icc,*
+      expect(thumb).to have_received(:apply_single_option).with(anything, "coalesce", nil, "-")
+      expect(thumb).to have_received(:apply_single_option).with(anything, "profile", "!icc,*", "+")
+      expect(thumb).to have_received(:apply_single_option).with(anything, "set", "date:modify", "+")
+      expect(thumb).to have_received(:apply_single_option).with(anything, "set", "date:create", "+")
+      expect(thumb).to have_received(:apply_single_option).with(anything, "set", "date:timestamp", "+")
+    end
+  end
+
+  context "with convert_options having multiple arguments for a flag" do
+    before do
+      @file = File.new(fixture_file("5k.png"), "rb")
+      @attachment = double("Attachment", options: {})
+    end
+
+    after { @file.close }
+
+    it "handles -set with two arguments correctly" do
+      # User provided example
+      convert_options = "-coalesce -set my_prop 123123"
+
+      thumb = Paperclip::Thumbnail.new(@file, {
+                                         geometry: "100x100",
+                                         convert_options: convert_options,
+                                         backend: :image_magick,
+                                       }, @attachment)
+
+      result = nil
+      expect { result = thumb.make }.not_to raise_error
+
+      # Verify property is set
+      require "shellwords"
+      output = `identify -verbose #{Shellwords.escape(result.path)}`
+      expect(output).to include("my_prop: 123123")
+    end
+  end
+
+  context "with convert_options having multiple arguments followed by other options" do
+    before do
+      @file = File.new(fixture_file("5k.png"), "rb")
+      @attachment = double("Attachment", options: {})
+    end
+
+    after { @file.close }
+
+    it "handles -set with two arguments followed by another option" do
+      # User provided example scenario
+      convert_options = "-set my_prop 123123 -auto-orient"
+
+      thumb = Paperclip::Thumbnail.new(@file, {
+                                         geometry: "100x100",
+                                         convert_options: convert_options,
+                                         backend: :image_magick,
+                                       }, @attachment)
+
+      result = nil
+      expect { result = thumb.make }.not_to raise_error
+
+      require "shellwords"
+      output = `identify -verbose #{Shellwords.escape(result.path)}`
+      expect(output).to include("my_prop: 123123")
+    end
+  end
+
+  context "with quoted values in convert_options (Shellwords parsing)" do
+    before do
+      @file = File.new(fixture_file("5k.png"), "rb")
+      @attachment = double("Attachment", options: {})
+    end
+
+    after { @file.close }
+
+    it "handles single-quoted values correctly" do
+      # Shellwords should parse 'Hello World' as a single token
+      convert_options = "-set my_comment 'Hello World'"
+
+      thumb = Paperclip::Thumbnail.new(@file, {
+                                         geometry: "100x100",
+                                         convert_options: convert_options,
+                                         backend: :image_magick,
+                                       }, @attachment)
+
+      allow(thumb).to receive(:apply_single_option).and_call_original
+      result = nil
+      expect { result = thumb.make }.not_to raise_error
+
+      # Verify that 'Hello World' was passed as a single value (without quotes)
+      expect(thumb).to have_received(:apply_single_option).with(anything, "set", "my_comment", "-")
+
+      # Check output includes the set property
+      require "shellwords"
+      output = `identify -verbose #{Shellwords.escape(result.path)}`
+      expect(output).to include("my_comment: Hello World")
+    end
+
+    it "handles double-quoted values correctly" do
+      convert_options = '-set my_comment "Hello World"'
+
+      thumb = Paperclip::Thumbnail.new(@file, {
+                                         geometry: "100x100",
+                                         convert_options: convert_options,
+                                         backend: :image_magick,
+                                       }, @attachment)
+
+      result = nil
+      expect { result = thumb.make }.not_to raise_error
+
+      require "shellwords"
+      output = `identify -verbose #{Shellwords.escape(result.path)}`
+      expect(output).to include("my_comment: Hello World")
+    end
+
+    it "handles escaped spaces correctly" do
+      convert_options = '-set my_comment Hello\ World'
+
+      thumb = Paperclip::Thumbnail.new(@file, {
+                                         geometry: "100x100",
+                                         convert_options: convert_options,
+                                         backend: :image_magick,
+                                       }, @attachment)
+
+      result = nil
+      expect { result = thumb.make }.not_to raise_error
+
+      require "shellwords"
+      output = `identify -verbose #{Shellwords.escape(result.path)}`
+      expect(output).to include("my_comment: Hello World")
+    end
+
+    it "handles multiple quoted options correctly" do
+      convert_options = "-set first_prop 'First Value' -set second_prop 'Second Value'"
+
+      thumb = Paperclip::Thumbnail.new(@file, {
+                                         geometry: "100x100",
+                                         convert_options: convert_options,
+                                         backend: :image_magick,
+                                       }, @attachment)
+
+      result = nil
+      expect { result = thumb.make }.not_to raise_error
+
+      require "shellwords"
+      output = `identify -verbose #{Shellwords.escape(result.path)}`
+      expect(output).to include("first_prop: First Value")
+      expect(output).to include("second_prop: Second Value")
+    end
+  end
+end

data/spec/paperclip/thumbnail_loader_options_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe Paperclip::Thumbnail do
+  describe "#parse_loader_options" do
+    let(:file) { File.new(fixture_file("5k.png"), "rb") }
+    let(:thumb) { Paperclip::Thumbnail.new(file, geometry: "50x50") }
+
+    after { file.close }
+
+    it "correctly parses positive numeric values" do
+      options = "-density 300"
+      result = thumb.send(:parse_loader_options, options)
+      expect(result).to eq({ density: "300" })
+    end
+
+    it "correctly parses negative numeric values" do
+      # Some hypothetical loader option that might take a negative value
+      options = "-something -90"
+      result = thumb.send(:parse_loader_options, options)
+      expect(result).to eq({ something: "-90" })
+    end
+
+    it "still treats non-numeric tokens starting with - as new options" do
+      options = "-density 300 -strip"
+      result = thumb.send(:parse_loader_options, options)
+      expect(result).to eq({ density: "300", strip: true })
+    end
+
+    it "handles single-quoted values correctly" do
+      options = "-comment 'Hello World'"
+      result = thumb.send(:parse_loader_options, options)
+      expect(result).to eq({ comment: "Hello World" })
+    end
+
+    it "handles double-quoted values correctly" do
+      options = '-path "/some/path with spaces"'
+      result = thumb.send(:parse_loader_options, options)
+      expect(result).to eq({ path: "/some/path with spaces" })
+    end
+
+    it "handles escaped spaces correctly" do
+      options = '-label Hello\ World'
+      result = thumb.send(:parse_loader_options, options)
+      expect(result).to eq({ label: "Hello World" })
+    end
+
+    it "handles multiple options with quoted values" do
+      options = "-first 'Value One' -second 'Value Two'"
+      result = thumb.send(:parse_loader_options, options)
+      expect(result).to eq({ first: "Value One", second: "Value Two" })
+    end
+  end
+end

data/spec/paperclip/thumbnail_security_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Paperclip::Thumbnail do
+  context "Security" do
+    old_backend = Paperclip.options[:backend]
+
+    before do
+      @file = File.new(fixture_file("5k.png"), "rb")
+      @attachment = double("Attachment", options: {})
+      Paperclip.options[:backend] = :image_magick
+    end
+
+    after do
+      @file.close
+      Paperclip.options[:backend] = old_backend
+    end
+
+    it "allows safe convert options" do
+      thumb = Paperclip::Thumbnail.new(@file, { geometry: "100x100", convert_options: "-strip" }, @attachment)
+
+      expect(Paperclip).to_not receive(:log).with(/Warning: Option strip is not allowed/)
+      thumb.make
+    end
+
+    it "blocks unsafe convert options" do
+      # -write is not in the ALLOWED_IMAGEMAGICK_OPTIONS list
+      thumb = Paperclip::Thumbnail.new(@file, { geometry: "100x100", convert_options: "-write /tmp/hacked.png" },
+                                       @attachment)
+
+      expect(Paperclip).to receive(:log).with("Warning: Option write is not allowed.")
+      thumb.make
+    end
+
+    it "allows options with underscores in the whitelist when passed with hyphens" do
+      # 'auto_orient' is in the list. User passes '-auto-orient'.
+      thumb = Paperclip::Thumbnail.new(@file, { geometry: "100x100", convert_options: "-auto-orient" }, @attachment)
+
+      expect(Paperclip).to_not receive(:log).with(/Warning: Option auto-orient is not allowed/)
+      thumb.make
+    end
+  end
+end