jr-paperclip 8.0.2 → 8.0.3

data/spec/paperclip/style_spec.rb

@@ -1,309 +0,0 @@
-require "spec_helper"
-
-describe Paperclip::Style do
-  context "A style rule" do
-    before do
-      @attachment = attachment path: ":basename.:extension",
-                               styles: { foo: { geometry: "100x100#", format: :png } },
-                               whiny: true
-      @style = @attachment.styles[:foo]
-    end
-
-    it "is held as a Style object" do
-      expect(@style).to be_a Paperclip::Style
-    end
-
-    it "gets processors from the attachment definition" do
-      assert_equal [:thumbnail], @style.processors
-    end
-
-    it "has the right geometry" do
-      assert_equal "100x100#", @style.geometry
-    end
-
-    it "is whiny if the attachment is" do
-      assert @style.whiny?
-    end
-
-    it "responds to hash notation" do
-      assert_equal [:thumbnail], @style[:processors]
-      assert_equal "100x100#", @style[:geometry]
-    end
-
-    it "returns the name of the style in processor options" do
-      assert_equal :foo, @style.processor_options[:style]
-    end
-  end
-
-  context "A style rule with properties supplied as procs" do
-    before do
-      @attachment = attachment path: ":basename.:extension",
-                               whiny_thumbnails: true,
-                               processors: lambda { |_a| [:test] },
-                               styles: {
-                                 foo: lambda { |_a| "300x300#" },
-                                 bar: {
-                                   geometry: lambda { |_a| "300x300#" },
-                                   convert_options: lambda { |_a| "-do_stuff" },
-                                   source_file_options: lambda { |_a| "-do_extra_stuff" }
-                                 }
-                               }
-    end
-
-    it "calls procs when they are needed" do
-      assert_equal "300x300#", @attachment.styles[:foo].geometry
-      assert_equal "300x300#", @attachment.styles[:bar].geometry
-      assert_equal [:test], @attachment.styles[:foo].processors
-      assert_equal [:test], @attachment.styles[:bar].processors
-      assert_equal "-do_stuff", @attachment.styles[:bar].convert_options
-      assert_equal "-do_extra_stuff", @attachment.styles[:bar].source_file_options
-    end
-  end
-
-  context "An attachment with style rules in various forms" do
-    before do
-      styles = {}
-      styles[:aslist] = ["100x100", :png]
-      styles[:ashash] = { geometry: "100x100", format: :png }
-      styles[:asstring] = "100x100"
-      @attachment = attachment path: ":basename.:extension",
-                               styles: styles
-    end
-
-    it "has the right number of styles" do
-      expect(@attachment.styles).to be_a Hash
-      assert_equal 3, @attachment.styles.size
-    end
-
-    it "has styles as Style objects" do
-      [:aslist, :ashash, :aslist].each do |s|
-        expect(@attachment.styles[s]).to be_a Paperclip::Style
-      end
-    end
-
-    it "has the right geometries" do
-      [:aslist, :ashash, :aslist].each do |s|
-        assert_equal @attachment.styles[s].geometry, "100x100"
-      end
-    end
-
-    it "has the right formats" do
-      assert_equal @attachment.styles[:aslist].format, :png
-      assert_equal @attachment.styles[:ashash].format, :png
-      assert_nil @attachment.styles[:asstring].format
-    end
-
-    it "retains order" do
-      assert_equal [:aslist, :ashash, :asstring], @attachment.styles.keys
-    end
-  end
-
-  context "An attachment with :convert_options" do
-    it "does not have called extra_options_for(:thumb/:large) on initialization" do
-      @attachment = attachment path: ":basename.:extension",
-                               styles: { thumb: "100x100", large: "400x400" },
-                               convert_options: { all: "-do_stuff", thumb: "-thumbnailize" }
-      expect(@attachment).to_not receive(:extra_options_for)
-      @style = @attachment.styles[:thumb]
-    end
-
-    it "calls extra_options_for(:thumb/:large) when convert options are requested" do
-      @attachment = attachment path: ":basename.:extension",
-                               styles: { thumb: "100x100", large: "400x400" },
-                               convert_options: { all: "-do_stuff", thumb: "-thumbnailize" }
-      @style = @attachment.styles[:thumb]
-      @file = StringIO.new("...")
-      allow(@file).to receive(:original_filename).and_return("file.jpg")
-
-      expect(@attachment).to receive(:extra_options_for).with(:thumb)
-      @attachment.styles[:thumb].convert_options
-    end
-  end
-
-  context "An attachment with :source_file_options" do
-    it "does not have called extra_source_file_options_for(:thumb/:large) on initialization" do
-      @attachment = attachment path: ":basename.:extension",
-                               styles: { thumb: "100x100", large: "400x400" },
-                               source_file_options: { all: "-density 400", thumb: "-depth 8" }
-      expect(@attachment).to_not receive(:extra_source_file_options_for)
-      @style = @attachment.styles[:thumb]
-    end
-
-    it "calls extra_options_for(:thumb/:large) when convert options are requested" do
-      @attachment = attachment path: ":basename.:extension",
-                               styles: { thumb: "100x100", large: "400x400" },
-                               source_file_options: { all: "-density 400", thumb: "-depth 8" }
-      @style = @attachment.styles[:thumb]
-      @file = StringIO.new("...")
-      allow(@file).to receive(:original_filename).and_return("file.jpg")
-
-      expect(@attachment).to receive(:extra_source_file_options_for).with(:thumb)
-      @attachment.styles[:thumb].source_file_options
-    end
-  end
-
-  context "A style rule with its own :processors" do
-    before do
-      @attachment = attachment path: ":basename.:extension",
-                               styles: {
-                                 foo: {
-                                   geometry: "100x100#",
-                                   format: :png,
-                                   processors: [:test]
-                                 }
-                               },
-                               processors: [:thumbnail]
-      @style = @attachment.styles[:foo]
-    end
-
-    it "does not get processors from the attachment" do
-      expect(@attachment).to_not receive(:processors)
-      assert_not_equal [:thumbnail], @style.processors
-    end
-
-    it "reports its own processors" do
-      assert_equal [:test], @style.processors
-    end
-  end
-
-  context "A style rule with :processors supplied as procs" do
-    before do
-      @attachment = attachment path: ":basename.:extension",
-                               styles: {
-                                 foo: {
-                                   geometry: "100x100#",
-                                   format: :png,
-                                   processors: lambda { |_a| [:test] }
-                                 }
-                               },
-                               processors: [:thumbnail]
-    end
-
-    it "defers processing of procs until they are needed" do
-      expect(@attachment.styles[:foo].instance_variable_get("@processors")).to be_a Proc
-    end
-
-    it "calls procs when they are needed" do
-      assert_equal [:test], @attachment.styles[:foo].processors
-    end
-  end
-
-  context "An attachment with :convert_options and :source_file_options in :styles" do
-    before do
-      @attachment = attachment path: ":basename.:extension",
-                               styles: {
-                                 thumb: "100x100",
-                                 large: { geometry: "400x400",
-                                          convert_options: "-do_stuff",
-                                          source_file_options: "-do_extra_stuff" }
-                               }
-      @file = StringIO.new("...")
-      allow(@file).to receive(:original_filename).and_return("file.jpg")
-    end
-
-    it "has empty options for :thumb style" do
-      assert_equal "", @attachment.styles[:thumb].processor_options[:convert_options]
-      assert_equal "", @attachment.styles[:thumb].processor_options[:source_file_options]
-    end
-
-    it "has the right options for :large style" do
-      assert_equal "-do_stuff", @attachment.styles[:large].processor_options[:convert_options]
-      assert_equal "-do_extra_stuff", @attachment.styles[:large].processor_options[:source_file_options]
-    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,
-                               styles: {
-                                 asstring: "300x300#",
-                                 aslist: ["300x300#", :jpg],
-                                 ashash: {
-                                   geometry: "300x300#",
-                                   convert_options: "-do_stuff"
-                                 }
-                               }
-    end
-
-    it "has the right number of styles" do
-      expect(@attachment.styles).to be_a Hash
-      assert_equal 3, @attachment.styles.size
-    end
-
-    it "has styles as Style objects" do
-      [:aslist, :ashash, :aslist].each do |s|
-        expect(@attachment.styles[s]).to be_a Paperclip::Style
-      end
-    end
-
-    it "has the right geometries" do
-      [:aslist, :ashash, :aslist].each do |s|
-        assert_equal @attachment.styles[s].geometry, "300x300#"
-      end
-    end
-
-    it "has the right formats" do
-      assert_equal @attachment.styles[:aslist].format,    :jpg
-      assert_equal @attachment.styles[:ashash].format,    :png
-      assert_equal @attachment.styles[:asstring].format,  :png
-    end
-  end
-end

data/spec/paperclip/tempfile_factory_spec.rb

@@ -1,33 +0,0 @@
-require "spec_helper"
-
-describe Paperclip::TempfileFactory do
-  it "is able to generate a tempfile with the right name" do
-    file = subject.generate("omg.png")
-    assert File.extname(file.path), "png"
-  end
-
-  it "is able to generate a tempfile with the right name with a tilde at the beginning" do
-    file = subject.generate("~omg.png")
-    assert File.extname(file.path), "png"
-  end
-
-  it "is able to generate a tempfile with the right name with a tilde at the end" do
-    file = subject.generate("omg.png~")
-    assert File.extname(file.path), "png"
-  end
-
-  it "is able to generate a tempfile from a file with a really long name" do
-    filename = "#{'longfilename' * 100}.png"
-    file = subject.generate(filename)
-    assert File.extname(file.path), "png"
-  end
-
-  it "is able to take nothing as a parameter and not error" do
-    file = subject.generate
-    assert File.exist?(file.path)
-  end
-
-  it "does not throw Errno::ENAMETOOLONG when it has a really long name" do
-    expect { subject.generate("o" * 255) }.to_not raise_error
-  end
-end

data/spec/paperclip/tempfile_spec.rb

@@ -1,35 +0,0 @@
-require "spec_helper"
-
-describe Paperclip::Tempfile do
-  context "A Paperclip Tempfile" do
-    before do
-      @tempfile = described_class.new(["file", ".jpg"])
-    end
-
-    after { @tempfile.close }
-
-    it "has its path contain a real extension" do
-      assert_equal ".jpg", File.extname(@tempfile.path)
-    end
-
-    it "is a real Tempfile" do
-      assert @tempfile.is_a?(::Tempfile)
-    end
-  end
-
-  context "Another Paperclip Tempfile" do
-    before do
-      @tempfile = described_class.new("file")
-    end
-
-    after { @tempfile.close }
-
-    it "does not have an extension if not given one" do
-      assert_equal "", File.extname(@tempfile.path)
-    end
-
-    it "is a real Tempfile" do
-      assert @tempfile.is_a?(::Tempfile)
-    end
-  end
-end

data/spec/paperclip/thumbnail_custom_options_spec.rb

@@ -1,225 +0,0 @@
-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 -quality 90 +profile "!icc,*" +set date:modify ' \
-                        "+set date:create +set date:timestamp -define jpeg:dct-method=float"
-      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_imagemagick_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_imagemagick_option).with(anything, "coalesce", nil, "-")
-      expect(thumb).to have_received(:apply_imagemagick_option).with(anything, "quality", "90", "-")
-      expect(thumb).to have_received(:apply_imagemagick_option).with(anything, "profile", "!icc,*", "+")
-      expect(thumb).to have_received(:apply_imagemagick_option).with(anything, "set", "date:modify", "+")
-      expect(thumb).to have_received(:apply_imagemagick_option).with(anything, "set", "date:create", "+")
-      expect(thumb).to have_received(:apply_imagemagick_option).with(anything, "set", "date:timestamp", "+")
-      expect(thumb).to have_received(:apply_imagemagick_option).with(anything, "define", "jpeg:dct-method=float", "-")
-    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
-
-  context "with vips-specific convert_options" do
-    before do
-      begin
-        require "vips"
-      rescue LoadError
-        skip "libvips not installed"
-      end
-      @file = File.new(fixture_file("5k.png"), "rb")
-      @attachment = double("Attachment", options: {})
-    end
-
-    after { @file.close if @file && !@file.closed? }
-
-    it "processes vips-native options correctly" do
-      convert_options = "-rot90"
-      file = File.new(fixture_file("rotated.jpg"), "rb")
-
-      thumb = Paperclip::Thumbnail.new(file, {
-                                         geometry: "100x100",
-                                         convert_options: convert_options,
-                                         backend: :vips,
-                                       }, @attachment)
-
-      # Processes without error
-      result = nil
-      expect { result = thumb.make }.not_to raise_error
-
-      require "shellwords"
-      dimensions = `identify -format "%wx%h" "#{Shellwords.escape(result.path)}"`.strip
-      width, height = dimensions.split("x").map(&:to_i)
-      # After 90 degree rotate, width should be greater than height
-      expect(width).to be > height
-      file.close
-    end
-
-    it "logs warning for unsupported vips options" do
-      convert_options = "-coalesce -unknown_vips_option foo"
-
-      thumb = Paperclip::Thumbnail.new(@file, {
-                                         geometry: "100x100",
-                                         convert_options: convert_options,
-                                         backend: :vips,
-                                       }, @attachment)
-
-      expect(Paperclip).to receive(:log).with(/Warning.*coalesce.*not supported/)
-      expect(Paperclip).to receive(:log).with(/Warning.*unknown_vips_option.*not supported/)
-      expect { thumb.make }.not_to raise_error
-    end
-  end
-end

data/spec/paperclip/thumbnail_loader_options_spec.rb

@@ -1,53 +0,0 @@
-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