jr-paperclip 8.0.1 → 8.0.3

data/spec/paperclip/io_adapters/uri_adapter_spec.rb

@@ -1,231 +0,0 @@
-require "spec_helper"
-
-describe Paperclip::UriAdapter do
-  let(:content_type) { "image/png" }
-  let(:meta) { {} }
-
-  before do
-    @open_return = StringIO.new("xxx")
-    allow(@open_return).to receive(:content_type).and_return(content_type)
-    allow(@open_return).to receive(:meta).and_return(meta)
-    Paperclip::UriAdapter.register
-  end
-
-  after do
-    Paperclip.io_adapters.unregister(described_class)
-  end
-
-  context "a new instance" do
-    let(:meta) { { "content-type" => "image/png" } }
-
-    before do
-      allow_any_instance_of(Paperclip::UriAdapter).
-        to receive(:download_content).and_return(@open_return)
-
-      @uri = URI.parse("http://thoughtbot.com/images/thoughtbot-logo.png")
-      @subject = Paperclip.io_adapters.for(@uri, hash_digest: Digest::MD5)
-    end
-
-    it "returns a file name" do
-      assert_equal "thoughtbot-logo.png", @subject.original_filename
-    end
-
-    it "closes open handle after reading" do
-      assert_equal true, @open_return.closed?
-    end
-
-    it "returns a content type" do
-      assert_equal "image/png", @subject.content_type
-    end
-
-    it "returns the size of the data" do
-      assert_equal @open_return.size, @subject.size
-    end
-
-    it "generates an MD5 hash of the contents" do
-      assert_equal Digest::MD5.hexdigest("xxx"), @subject.fingerprint
-    end
-
-    it "generates correct fingerprint after read" do
-      fingerprint = Digest::MD5.hexdigest(@subject.read)
-      assert_equal fingerprint, @subject.fingerprint
-    end
-
-    it "generates same fingerprint" do
-      assert_equal @subject.fingerprint, @subject.fingerprint
-    end
-
-    it "returns the data contained in the StringIO" do
-      assert_equal "xxx", @subject.read
-    end
-
-    it "accepts a content_type" do
-      @subject.content_type = "image/png"
-      assert_equal "image/png", @subject.content_type
-    end
-
-    it "accepts an original_filename" do
-      @subject.original_filename = "image.png"
-      assert_equal "image.png", @subject.original_filename
-    end
-  end
-
-  context "a directory index url" do
-    let(:content_type) { "text/html" }
-    let(:meta) { { "content-type" => "text/html" } }
-
-    before do
-      allow_any_instance_of(Paperclip::UriAdapter).
-        to receive(:download_content).and_return(@open_return)
-
-      @uri = URI.parse("http://thoughtbot.com")
-      @subject = Paperclip.io_adapters.for(@uri)
-    end
-
-    it "returns a file name" do
-      assert_equal "index.html", @subject.original_filename
-    end
-
-    it "returns a content type" do
-      assert_equal "text/html", @subject.content_type
-    end
-  end
-
-  context "a url with query params" do
-    before do
-      allow_any_instance_of(Paperclip::UriAdapter).
-        to receive(:download_content).and_return(@open_return)
-
-      @uri = URI.parse("https://github.com/thoughtbot/paperclip?file=test")
-      @subject = Paperclip.io_adapters.for(@uri)
-    end
-
-    it "returns a file name" do
-      assert_equal "paperclip", @subject.original_filename
-    end
-  end
-
-  context "a url with content disposition headers" do
-    let(:file_name) { "test_document.pdf" }
-    let(:filename_from_path) { "paperclip" }
-
-    before do
-      allow_any_instance_of(Paperclip::UriAdapter).
-        to receive(:download_content).and_return(@open_return)
-
-      @uri = URI.parse(
-        "https://github.com/thoughtbot/#{filename_from_path}?file=test"
-      )
-    end
-
-    it "returns file name from path" do
-      meta["content-disposition"] = "inline;"
-
-      @subject = Paperclip.io_adapters.for(@uri)
-
-      assert_equal filename_from_path, @subject.original_filename
-    end
-
-    it "returns a file name enclosed in double quotes" do
-      file_name = "john's test document.pdf"
-      meta["content-disposition"] = "attachment; filename=\"#{file_name}\";"
-
-      @subject = Paperclip.io_adapters.for(@uri)
-
-      assert_equal file_name, @subject.original_filename
-    end
-
-    it "returns a file name not enclosed in double quotes" do
-      meta["content-disposition"] = "ATTACHMENT; FILENAME=#{file_name};"
-
-      @subject = Paperclip.io_adapters.for(@uri)
-
-      assert_equal file_name, @subject.original_filename
-    end
-
-    it "does not crash when an empty filename is given" do
-      meta["content-disposition"] = "ATTACHMENT; FILENAME=\"\";"
-
-      @subject = Paperclip.io_adapters.for(@uri)
-
-      assert_equal "", @subject.original_filename
-    end
-
-    it "returns a file name ignoring RFC 5987 encoding" do
-      meta["content-disposition"] =
-        "attachment; filename=#{file_name}; filename* = utf-8''%e2%82%ac%20rates"
-
-      @subject = Paperclip.io_adapters.for(@uri)
-
-      assert_equal file_name, @subject.original_filename
-    end
-
-    context "when file name has consecutive periods" do
-      let(:file_name) { "test_document..pdf" }
-
-      it "returns a file name" do
-        @uri = URI.parse(
-          "https://github.com/thoughtbot/#{file_name}?file=test"
-        )
-        @subject = Paperclip.io_adapters.for(@uri)
-        assert_equal file_name, @subject.original_filename
-      end
-    end
-  end
-
-  context "a url with restricted characters in the filename" do
-    before do
-      allow_any_instance_of(Paperclip::UriAdapter).
-        to receive(:download_content).and_return(@open_return)
-
-      @uri = URI.parse("https://github.com/thoughtbot/paper:clip.jpg")
-      @subject = Paperclip.io_adapters.for(@uri)
-    end
-
-    it "does not generate filenames that include restricted characters" do
-      assert_equal "paper_clip.jpg", @subject.original_filename
-    end
-
-    it "does not generate paths that include restricted characters" do
-      expect(@subject.path).to_not match(/:/)
-    end
-  end
-
-  describe "#download_content" do
-    before do
-      allowed_mock =
-        if RUBY_VERSION < '2.5'
-          allow_any_instance_of(Paperclip::UriAdapter)
-        else
-          allow(URI)
-        end
-
-      allowed_mock.to receive(:open).and_return(@open_return)
-
-      @uri = URI.parse("https://github.com/thoughtbot/paper:clip.jpg")
-      @subject = Paperclip.io_adapters.for(@uri)
-      @uri_opener = RUBY_VERSION < '2.5' ? @subject : URI
-    end
-
-    after do
-      @subject.send(:download_content)
-    end
-
-    context "with default read_timeout" do
-      it "calls open without options" do
-        expect(@uri_opener).to receive(:open).with(@uri, {}).at_least(1).times
-      end
-    end
-
-    context "with custom read_timeout" do
-      before do
-        Paperclip.options[:read_timeout] = 120
-      end
-
-      it "calls open with read_timeout option" do
-        expect(@uri_opener)
-          .to receive(:open).with(@uri, { read_timeout: 120 }).at_least(1).times
-      end
-    end
-  end
-end

data/spec/paperclip/lazy_thumbnail_compatibility_spec.rb

@@ -1,266 +0,0 @@
-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/matchers/have_attached_file_matcher_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-require "paperclip/matchers"
-
-describe Paperclip::Shoulda::Matchers::HaveAttachedFileMatcher do
-  extend Paperclip::Shoulda::Matchers
-
-  it "rejects the dummy class if it has no attachment" do
-    reset_table "dummies"
-    reset_class "Dummy"
-    matcher = self.class.have_attached_file(:avatar)
-    expect(matcher).to_not accept(Dummy)
-  end
-
-  it "accepts the dummy class if it has an attachment" do
-    rebuild_model
-    matcher = self.class.have_attached_file(:avatar)
-    expect(matcher).to accept(Dummy)
-  end
-end

data/spec/paperclip/matchers/validate_attachment_content_type_matcher_spec.rb

@@ -1,108 +0,0 @@
-require "spec_helper"
-require "paperclip/matchers"
-
-describe Paperclip::Shoulda::Matchers::ValidateAttachmentContentTypeMatcher do
-  extend Paperclip::Shoulda::Matchers
-
-  before do
-    reset_table("dummies") do |d|
-      d.string :title
-      d.string :avatar_file_name
-      d.string :avatar_content_type
-    end
-    reset_class "Dummy"
-    Dummy.do_not_validate_attachment_file_type :avatar
-    Dummy.has_attached_file :avatar
-  end
-
-  it "rejects a class with no validation" do
-    expect(matcher).to_not accept(Dummy)
-    expect { matcher.failure_message }.to_not raise_error
-  end
-
-  it "rejects a class when the validation fails" do
-    Dummy.validates_attachment_content_type :avatar, content_type: %r{audio/.*}
-    expect(matcher).to_not accept(Dummy)
-    expect { matcher.failure_message }.to_not raise_error
-  end
-
-  it "accepts a class with a matching validation" do
-    Dummy.validates_attachment_content_type :avatar, content_type: %r{image/.*}
-    expect(matcher).to accept(Dummy)
-    expect { matcher.failure_message }.to_not raise_error
-  end
-
-  it "accepts a class with other validations but matching types" do
-    Dummy.validates_presence_of :title
-    Dummy.validates_attachment_content_type :avatar, content_type: %r{image/.*}
-    expect(matcher).to accept(Dummy)
-    expect { matcher.failure_message }.to_not raise_error
-  end
-
-  it "accepts a class that matches and a matcher that only specifies 'allowing'" do
-    Dummy.validates_attachment_content_type :avatar, content_type: %r{image/.*}
-    matcher = plain_matcher.allowing(%w(image/png image/jpeg))
-
-    expect(matcher).to accept(Dummy)
-    expect { matcher.failure_message }.to_not raise_error
-  end
-
-  it "rejects a class that does not match and a matcher that only specifies 'allowing'" do
-    Dummy.validates_attachment_content_type :avatar, content_type: %r{audio/.*}
-    matcher = plain_matcher.allowing(%w(image/png image/jpeg))
-
-    expect(matcher).to_not accept(Dummy)
-    expect { matcher.failure_message }.to_not raise_error
-  end
-
-  it "accepts a class that matches and a matcher that only specifies 'rejecting'" do
-    Dummy.validates_attachment_content_type :avatar, content_type: %r{image/.*}
-    matcher = plain_matcher.rejecting(%w(audio/mp3 application/octet-stream))
-
-    expect(matcher).to accept(Dummy)
-    expect { matcher.failure_message }.to_not raise_error
-  end
-
-  it "rejects a class that does not match and a matcher that only specifies 'rejecting'" do
-    Dummy.validates_attachment_content_type :avatar, content_type: %r{audio/.*}
-    matcher = plain_matcher.rejecting(%w(audio/mp3 application/octet-stream))
-
-    expect(matcher).to_not accept(Dummy)
-    expect { matcher.failure_message }.to_not raise_error
-  end
-
-  context "using an :if to control the validation" do
-    before do
-      Dummy.class_eval do
-        validates_attachment_content_type :avatar, content_type: %r{image/*}, if: :go
-        attr_accessor :go
-      end
-    end
-
-    it "runs the validation if the control is true" do
-      dummy = Dummy.new
-      dummy.go = true
-      expect(matcher).to accept(dummy)
-      expect { matcher.failure_message }.to_not raise_error
-    end
-
-    it "does not run the validation if the control is false" do
-      dummy = Dummy.new
-      dummy.go = false
-      expect(matcher).to_not accept(dummy)
-      expect { matcher.failure_message }.to_not raise_error
-    end
-  end
-
-  private
-
-  def plain_matcher
-    self.class.validate_attachment_content_type(:avatar)
-  end
-
-  def matcher
-    plain_matcher.
-      allowing(%w(image/png image/jpeg)).
-      rejecting(%w(audio/mp3 application/octet-stream))
-  end
-end

data/spec/paperclip/matchers/validate_attachment_presence_matcher_spec.rb

@@ -1,69 +0,0 @@
-require "spec_helper"
-require "paperclip/matchers"
-
-describe Paperclip::Shoulda::Matchers::ValidateAttachmentPresenceMatcher do
-  extend Paperclip::Shoulda::Matchers
-
-  before do
-    reset_table("dummies") do |d|
-      d.string :avatar_file_name
-    end
-    reset_class "Dummy"
-    Dummy.has_attached_file :avatar
-    Dummy.do_not_validate_attachment_file_type :avatar
-  end
-
-  it "rejects a class with no validation" do
-    expect(matcher).to_not accept(Dummy)
-  end
-
-  it "accepts a class with a matching validation" do
-    Dummy.validates_attachment_presence :avatar
-    expect(matcher).to accept(Dummy)
-  end
-
-  it "accepts an instance with other attachment validations" do
-    reset_table("dummies") do |d|
-      d.string :avatar_file_name
-      d.string :avatar_content_type
-    end
-    Dummy.class_eval do
-      validates_attachment_presence :avatar
-      validates_attachment_content_type :avatar, content_type: "image/gif"
-    end
-    dummy = Dummy.new
-
-    dummy.avatar = File.new fixture_file("5k.png")
-
-    expect(matcher).to accept(dummy)
-  end
-
-  context "using an :if to control the validation" do
-    before do
-      Dummy.class_eval do
-        validates_attachment_presence :avatar, if: :go
-        attr_accessor :go
-      end
-    end
-
-    it "runs the validation if the control is true" do
-      dummy = Dummy.new
-      dummy.avatar = nil
-      dummy.go = true
-      expect(matcher).to accept(dummy)
-    end
-
-    it "does not run the validation if the control is false" do
-      dummy = Dummy.new
-      dummy.avatar = nil
-      dummy.go = false
-      expect(matcher).to_not accept(dummy)
-    end
-  end
-
-  private
-
-  def matcher
-    self.class.validate_attachment_presence(:avatar)
-  end
-end