jr-paperclip 8.0.2 → 8.0.3

data/spec/paperclip/matchers/validate_attachment_size_matcher_spec.rb

@@ -1,88 +0,0 @@
-require "spec_helper"
-require "paperclip/matchers"
-
-describe Paperclip::Shoulda::Matchers::ValidateAttachmentSizeMatcher do
-  extend Paperclip::Shoulda::Matchers
-
-  before do
-    reset_table("dummies") do |d|
-      d.string :avatar_file_name
-      d.bigint :avatar_file_size
-    end
-    reset_class "Dummy"
-    Dummy.do_not_validate_attachment_file_type :avatar
-    Dummy.has_attached_file :avatar
-  end
-
-  context "Limiting size" do
-    it "rejects a class with no validation" do
-      expect(matcher.in(256..1024)).to_not accept(Dummy)
-    end
-
-    it "rejects a class with a validation that's too high" do
-      Dummy.validates_attachment_size :avatar, in: 256..2048
-      expect(matcher.in(256..1024)).to_not accept(Dummy)
-    end
-
-    it "accepts a class with a validation that's too low" do
-      Dummy.validates_attachment_size :avatar, in: 0..1024
-      expect(matcher.in(256..1024)).to_not accept(Dummy)
-    end
-
-    it "accepts a class with a validation that matches" do
-      Dummy.validates_attachment_size :avatar, in: 256..1024
-      expect(matcher.in(256..1024)).to accept(Dummy)
-    end
-  end
-
-  context "allowing anything" do
-    it "given a class with an upper limit" do
-      Dummy.validates_attachment_size :avatar, less_than: 1
-      expect(matcher).to accept(Dummy)
-    end
-
-    it "given a class with a lower limit" do
-      Dummy.validates_attachment_size :avatar, greater_than: 1
-      expect(matcher).to accept(Dummy)
-    end
-  end
-
-  context "using an :if to control the validation" do
-    before do
-      Dummy.class_eval do
-        validates_attachment_size :avatar, greater_than: 1024, if: :go
-        attr_accessor :go
-      end
-    end
-
-    it "run the validation if the control is true" do
-      dummy = Dummy.new
-      dummy.go = true
-      expect(matcher.greater_than(1024)).to accept(dummy)
-    end
-
-    it "not run the validation if the control is false" do
-      dummy = Dummy.new
-      dummy.go = false
-      expect(matcher.greater_than(1024)).to_not accept(dummy)
-    end
-  end
-
-  context "post processing" do
-    before do
-      Dummy.validates_attachment_size :avatar, greater_than: 1024
-    end
-
-    it "be skipped" do
-      dummy = Dummy.new
-      expect(dummy.avatar).to_not receive(:post_process)
-      expect(matcher.greater_than(1024)).to accept(dummy)
-    end
-  end
-
-  private
-
-  def matcher
-    self.class.validate_attachment_size(:avatar)
-  end
-end

data/spec/paperclip/media_type_spoof_detector_spec.rb

@@ -1,126 +0,0 @@
-require "spec_helper"
-
-describe Paperclip::MediaTypeSpoofDetector do
-  it "rejects a file that is named .html and identifies as PNG" do
-    file = File.open(fixture_file("5k.png"))
-    assert Paperclip::MediaTypeSpoofDetector.using(file, "5k.html", "image/png").spoofed?
-  end
-
-  it "does not reject a file that is named .jpg and identifies as PNG" do
-    file = File.open(fixture_file("5k.png"))
-    assert !Paperclip::MediaTypeSpoofDetector.using(file, "5k.jpg", "image/png").spoofed?
-  end
-
-  it "does not reject a file that is named .html and identifies as HTML" do
-    file = File.open(fixture_file("empty.html"))
-    assert !Paperclip::MediaTypeSpoofDetector.using(file, "empty.html", "text/html").spoofed?
-  end
-
-  it "does not reject a file that does not have a name" do
-    file = File.open(fixture_file("empty.html"))
-    assert !Paperclip::MediaTypeSpoofDetector.using(file, "", "text/html").spoofed?
-  end
-
-  it "does not reject a file that does have an extension" do
-    file = File.open(fixture_file("empty.html"))
-    assert !Paperclip::MediaTypeSpoofDetector.using(file, "data", "text/html").spoofed?
-  end
-
-  it "does not reject when the supplied file is an IOAdapter" do
-    adapter = Paperclip.io_adapters.for(File.new(fixture_file("5k.png")))
-    assert !Paperclip::MediaTypeSpoofDetector.using(adapter, adapter.original_filename, adapter.content_type).spoofed?
-  end
-
-  it "does not reject when the extension => content_type is in :content_type_mappings" do
-    file = Tempfile.open(["test", ".PEM"])
-    file.puts "Certificate!"
-    file.close
-
-    adapter = Paperclip.io_adapters.for(File.new(file.path))
-
-    begin
-      Paperclip.options[:content_type_mappings] = { pem: "text/plain" }
-      assert !Paperclip::MediaTypeSpoofDetector.using(adapter, adapter.original_filename, adapter.content_type).spoofed?
-
-      # As a string.
-      Paperclip.options[:content_type_mappings] = { "pem" => "text/plain" }
-      assert !Paperclip::MediaTypeSpoofDetector.using(adapter, adapter.original_filename, adapter.content_type).spoofed?
-    ensure
-      Paperclip.options[:content_type_mappings] = {}
-    end
-  end
-
-  context "file named .html and is as HTML, but we're told JPG" do
-    let(:file) { File.open(fixture_file("empty.html")) }
-    let(:spoofed?) { Paperclip::MediaTypeSpoofDetector.using(file, "empty.html", "image/jpg").spoofed? }
-
-    it "rejects the file" do
-      assert spoofed?
-    end
-
-    it "logs info about the detected spoof" do
-      expect(Paperclip).to receive(:log).with('Content Type Spoof: Filename empty.html (image/jpg from Headers, ["text/html"] from Extension), content type discovered from file command: text/html. See documentation to allow this combination.')
-      spoofed?
-    end
-  end
-
-  context "GIF file named without extension, but we're told GIF" do
-    let(:file) { File.open(fixture_file("animated")) }
-    let(:spoofed?) do
-      Paperclip::MediaTypeSpoofDetector.
-        using(file, "animated", "image/gif").
-        spoofed?
-    end
-
-    it "accepts the file" do
-      assert !spoofed?
-    end
-  end
-
-  context "GIF file named without extension, but we're told HTML" do
-    let(:file) { File.open(fixture_file("animated")) }
-    let(:spoofed?) do
-      Paperclip::MediaTypeSpoofDetector.
-        using(file, "animated", "text/html").
-        spoofed?
-    end
-
-    it "rejects the file" do
-      assert spoofed?
-    end
-  end
-
-  it "does not reject if content_type is empty but otherwise checks out" do
-    file = File.open(fixture_file("empty.html"))
-    assert !Paperclip::MediaTypeSpoofDetector.using(file, "empty.html", "").spoofed?
-  end
-
-  it "does allow array as :content_type_mappings" do
-    begin
-      Paperclip.options[:content_type_mappings] = {
-        html: ["binary", "text/html"]
-      }
-      file = File.open(fixture_file("empty.html"))
-      spoofed = Paperclip::MediaTypeSpoofDetector.
-                using(file, "empty.html", "text/html").spoofed?
-      assert !spoofed
-    ensure
-      Paperclip.options[:content_type_mappings] = {}
-    end
-  end
-
-  context "#type_from_file_command" do
-    let(:file) { File.new(fixture_file("empty.html")) }
-    let(:detector) { Paperclip::MediaTypeSpoofDetector.new(file, "html", "") }
-
-    it "does work with the output of old versions of file" do
-      allow(Paperclip).to receive(:run).and_return("text/html charset=us-ascii")
-      expect(detector.send(:type_from_file_command)).to eq("text/html")
-    end
-
-    it "does work with the output of new versions of file" do
-      allow(Paperclip).to receive(:run).and_return("text/html; charset=us-ascii")
-      expect(detector.send(:type_from_file_command)).to eq("text/html")
-    end
-  end
-end

data/spec/paperclip/meta_class_spec.rb

@@ -1,30 +0,0 @@
-require "spec_helper"
-
-describe "Metaclasses" do
-  context "A meta-class of dummy" do
-    if active_support_version >= "4.1" || ruby_version < "2.1"
-      before do
-        rebuild_model
-        reset_class("Dummy")
-      end
-
-      it "is able to use Paperclip like a normal class" do
-        @dummy = Dummy.new
-
-        assert_nothing_raised do
-          rebuild_meta_class_of(@dummy)
-        end
-      end
-
-      it "works like any other instance" do
-        @dummy = Dummy.new
-        rebuild_meta_class_of(@dummy)
-
-        assert_nothing_raised do
-          @dummy.avatar = File.new(fixture_file("5k.png"), "rb")
-        end
-        assert @dummy.save
-      end
-    end
-  end
-end

data/spec/paperclip/migration_guide_example_spec.rb

@@ -1,44 +0,0 @@
-require "spec_helper"
-
-module Paperclip
-  class MyVipsProcessor < Processor
-    def make
-      basename = File.basename(file.path, File.extname(file.path))
-      dst = Paperclip::TempfileFactory.new.generate("#{basename}.png")
-
-      # Use the new vips helper instead of convert
-      vips("thumbnail :src :dst 100",
-           src: File.expand_path(file.path),
-           dst: File.expand_path(dst.path))
-      dst
-    end
-  end
-end
-
-describe Paperclip::MyVipsProcessor do
-  let(:file) { File.open(fixture_file("50x50.png")) }
-  let(:options) { {} }
-  let(:attachment) { double }
-  let(:processor) { Paperclip::MyVipsProcessor.new(file, options, attachment) }
-
-  subject { processor.make }
-
-  it "processes the image using vips helper" do
-    expect(subject).to respond_to(:path)
-    expect(File.exist?(subject.path)).to be true
-
-    # Check width using vipsheader
-    require "shellwords"
-    dimensions = `identify -format "%wx%h" "#{Shellwords.escape(subject.path)}"`.strip
-    expect(dimensions).to eq("100x100")
-  end
-
-  it "calls the vips command" do
-    expect(Paperclip).to receive(:run).with(
-      "vips",
-      "thumbnail :src :dst 100",
-      hash_including(:src, :dst),
-    )
-    processor.make
-  end
-end

data/spec/paperclip/paperclip_missing_attachment_styles_spec.rb

@@ -1,88 +0,0 @@
-require "spec_helper"
-
-describe "Missing Attachment Styles" do
-  before do
-    Paperclip::AttachmentRegistry.clear
-  end
-
-  after do
-    begin
-      File.unlink(Paperclip.registered_attachments_styles_path)
-    rescue StandardError
-      nil
-    end
-  end
-
-  it "enables to get and set path to registered styles file" do
-    assert_equal ROOT.join("tmp/public/system/paperclip_attachments.yml").to_s, Paperclip.registered_attachments_styles_path
-    Paperclip.registered_attachments_styles_path = "/tmp/config/paperclip_attachments.yml"
-    assert_equal "/tmp/config/paperclip_attachments.yml", Paperclip.registered_attachments_styles_path
-    Paperclip.registered_attachments_styles_path = nil
-    assert_equal ROOT.join("tmp/public/system/paperclip_attachments.yml").to_s, Paperclip.registered_attachments_styles_path
-  end
-
-  it "is able to get current attachment styles" do
-    assert_equal Hash.new, Paperclip.send(:current_attachments_styles)
-    rebuild_model styles: { croppable: "600x600>", big: "1000x1000>" }
-    expected_hash = { Dummy: { avatar: [:big, :croppable] } }
-    assert_equal expected_hash, Paperclip.send(:current_attachments_styles)
-  end
-
-  it "is able to save current attachment styles for further comparison" do
-    rebuild_model styles: { croppable: "600x600>", big: "1000x1000>" }
-    Paperclip.save_current_attachments_styles!
-    expected_hash = { Dummy: { avatar: [:big, :croppable] } }
-    assert_equal expected_hash, YAML.load_file(Paperclip.registered_attachments_styles_path)
-  end
-
-  it "is able to read registered attachment styles from file" do
-    rebuild_model styles: { croppable: "600x600>", big: "1000x1000>" }
-    Paperclip.save_current_attachments_styles!
-    expected_hash = { Dummy: { avatar: [:big, :croppable] } }
-    assert_equal expected_hash, Paperclip.send(:get_registered_attachments_styles)
-  end
-
-  it "is able to calculate differences between registered styles and current styles" do
-    rebuild_model styles: { croppable: "600x600>", big: "1000x1000>" }
-    Paperclip.save_current_attachments_styles!
-    rebuild_model styles: { thumb: "x100", export: "x400>", croppable: "600x600>", big: "1000x1000>" }
-    expected_hash = { Dummy: { avatar: [:export, :thumb] } }
-    assert_equal expected_hash, Paperclip.missing_attachments_styles
-
-    ActiveRecord::Migration.create_table :books, force: true
-    class ::Book < ActiveRecord::Base
-      has_attached_file :cover, styles: { small: "x100", large: "1000x1000>" }
-      has_attached_file :sample, styles: { thumb: "x100" }
-    end
-
-    expected_hash = {
-      Dummy: { avatar: [:export, :thumb] },
-      Book: { sample: [:thumb], cover: [:large, :small] }
-    }
-    assert_equal expected_hash, Paperclip.missing_attachments_styles
-    Paperclip.save_current_attachments_styles!
-    assert_equal Hash.new, Paperclip.missing_attachments_styles
-  end
-
-  it "is able to calculate differences when a new attachment is added to a model" do
-    rebuild_model styles: { croppable: "600x600>", big: "1000x1000>" }
-    Paperclip.save_current_attachments_styles!
-
-    class ::Dummy
-      has_attached_file :photo, styles: { small: "x100", large: "1000x1000>" }
-    end
-
-    expected_hash = {
-      Dummy: { photo: [:large, :small] }
-    }
-    assert_equal expected_hash, Paperclip.missing_attachments_styles
-    Paperclip.save_current_attachments_styles!
-    assert_equal Hash.new, Paperclip.missing_attachments_styles
-  end
-
-  # It's impossible to build styles hash without loading from database whole bunch of records
-  it "skips lambda-styles" do
-    rebuild_model styles: lambda { |attachment| attachment.instance.other == "a" ? { thumb: "50x50#" } : { large: "400x400" } }
-    assert_equal Hash.new, Paperclip.send(:current_attachments_styles)
-  end
-end

data/spec/paperclip/paperclip_spec.rb

@@ -1,196 +0,0 @@
-require "spec_helper"
-
-describe Paperclip do
-  context ".run" do
-    before do
-      Paperclip.options[:log_command] = false
-      expect(Terrapin::CommandLine).to receive(:new).with("convert", "stuff", {}).and_return(double(run: nil))
-      @original_command_line_path = Terrapin::CommandLine.path
-    end
-
-    after do
-      Paperclip.options[:log_command] = true
-      Terrapin::CommandLine.path = @original_command_line_path
-    end
-
-    it "runs the command with Terrapin" do
-      Paperclip.run("convert", "stuff")
-    end
-
-    it "saves Terrapin::CommandLine.path that set before" do
-      Terrapin::CommandLine.path = "/opt/my_app/bin"
-      Paperclip.run("convert", "stuff")
-      expect(Terrapin::CommandLine.path).to match("/opt/my_app/bin")
-    end
-
-    it "does not duplicate Terrapin::CommandLine.path on multiple runs" do
-      expect(Terrapin::CommandLine).to receive(:new).with("convert", "more_stuff", {}).and_return(double(run: nil))
-      Terrapin::CommandLine.path = nil
-      Paperclip.options[:command_path] = "/opt/my_app/bin"
-      Paperclip.run("convert", "stuff")
-      Paperclip.run("convert", "more_stuff")
-
-      cmd_path = Paperclip.options[:command_path]
-      assert_equal 1, Terrapin::CommandLine.path.scan(cmd_path).count
-    end
-  end
-
-  it "does not raise errors when doing a lot of running" do
-    Paperclip.options[:command_path] = ["/usr/local/bin"] * 1024
-    Terrapin::CommandLine.path = "/something/else"
-    100.times do |x|
-      Paperclip.run("echo", x.to_s)
-    end
-  end
-
-  context "Calling Paperclip.log without options[:logger] set" do
-    before do
-      Paperclip.logger = nil
-      Paperclip.options[:logger] = nil
-    end
-
-    after do
-      Paperclip.options[:logger] = ActiveRecord::Base.logger
-      Paperclip.logger = ActiveRecord::Base.logger
-    end
-
-    it "does not raise an error when log is called" do
-      silence_stream(STDOUT) do
-        Paperclip.log("something")
-      end
-    end
-  end
-  context "Calling Paperclip.run with a logger" do
-    it "passes the defined logger if :log_command is set" do
-      Paperclip.options[:log_command] = true
-      expect(Terrapin::CommandLine).to receive(:new).with("convert", "stuff", { logger: Paperclip.logger }).and_return(double(run: nil))
-      Paperclip.run("convert", "stuff")
-    end
-  end
-
-  context "Paperclip.each_instance_with_attachment" do
-    before do
-      @file = File.new(fixture_file("5k.png"), "rb")
-      d1 = Dummy.create(avatar: @file)
-      d2 = Dummy.create
-      d3 = Dummy.create(avatar: @file)
-      @expected = [d1, d3]
-    end
-
-    after { @file.close }
-
-    it "yields every instance of a model that has an attachment" do
-      actual = []
-      Paperclip.each_instance_with_attachment("Dummy", "avatar") do |instance|
-        actual << instance
-      end
-      expect(actual).to match_array @expected
-    end
-  end
-
-  it "raises when sent #processor and the name of a class that doesn't exist" do
-    assert_raises(LoadError) { Paperclip.processor(:boogey_man) }
-  end
-
-  it "returns a class when sent #processor and the name of a class under Paperclip" do
-    assert_equal ::Paperclip::Thumbnail, Paperclip.processor(:thumbnail)
-  end
-
-  it "gets a class from a namespaced class name" do
-    class ::One; class Two; end; end
-    assert_equal ::One::Two, Paperclip.class_for("One::Two")
-  end
-
-  it "raises when class doesn't exist in specified namespace" do
-    class ::Three; end
-    class ::Four; end
-    assert_raises NameError do
-      Paperclip.class_for("Three::Four")
-    end
-  end
-
-  context "An ActiveRecord model with an 'avatar' attachment" do
-    before do
-      rebuild_model path: "tmp/:class/omg/:style.:extension"
-      @file = File.new(fixture_file("5k.png"), "rb")
-    end
-
-    after { @file.close }
-
-    it "does not error when trying to also create a 'blah' attachment" do
-      assert_nothing_raised do
-        Dummy.class_eval do
-          has_attached_file :blah
-        end
-      end
-    end
-
-    context "with a subclass" do
-      before do
-        class ::SubDummy < Dummy; end
-      end
-
-      it "is able to use the attachment from the subclass" do
-        assert_nothing_raised do
-          @subdummy = SubDummy.create(avatar: @file)
-        end
-      end
-
-      after do
-        SubDummy.delete_all
-        begin
-          Object.send(:remove_const, "SubDummy")
-        rescue StandardError
-          nil
-        end
-      end
-    end
-
-    it "has an avatar getter method" do
-      assert Dummy.new.respond_to?(:avatar)
-    end
-
-    it "has an avatar setter method" do
-      assert Dummy.new.respond_to?(:avatar=)
-    end
-
-    context "that is valid" do
-      before do
-        @dummy = Dummy.new
-        @dummy.avatar = @file
-      end
-
-      it "is valid" do
-        assert @dummy.valid?
-      end
-    end
-
-    it "does not have Attachment in the ActiveRecord::Base namespace" do
-      assert_raises(NameError) do
-        ActiveRecord::Base::Attachment
-      end
-    end
-  end
-
-  context "configuring a custom processor" do
-    before do
-      @freedom_processor = Class.new do
-        def make(file, _options = {}, _attachment = nil)
-          file
-        end
-      end.new
-
-      Paperclip.configure do |config|
-        config.register_processor(:freedom, @freedom_processor)
-      end
-    end
-
-    it "is able to find the custom processor" do
-      assert_equal @freedom_processor, Paperclip.processor(:freedom)
-    end
-
-    after do
-      Paperclip.clear_processors!
-    end
-  end
-end

data/spec/paperclip/plural_cache_spec.rb

@@ -1,37 +0,0 @@
-require "spec_helper"
-
-describe "Plural cache" do
-  it "caches pluralizations" do
-    cache = Paperclip::Interpolations::PluralCache.new
-    symbol = :box
-
-    first = cache.pluralize_symbol(symbol)
-    second = cache.pluralize_symbol(symbol)
-    expect(first).to equal(second)
-  end
-
-  it "caches pluralizations and underscores" do
-    class BigBox; end
-    cache = Paperclip::Interpolations::PluralCache.new
-    klass = BigBox
-
-    first = cache.underscore_and_pluralize_class(klass)
-    second = cache.underscore_and_pluralize_class(klass)
-    expect(first).to equal(second)
-  end
-
-  it "pluralizes words" do
-    cache = Paperclip::Interpolations::PluralCache.new
-    symbol = :box
-
-    expect(cache.pluralize_symbol(symbol)).to eq("boxes")
-  end
-
-  it "pluralizes and underscore class names" do
-    class BigBox; end
-    cache = Paperclip::Interpolations::PluralCache.new
-    klass = BigBox
-
-    expect(cache.underscore_and_pluralize_class(klass)).to eq("big_boxes")
-  end
-end

data/spec/paperclip/processor_helpers_spec.rb

@@ -1,57 +0,0 @@
-require "spec_helper"
-
-describe Paperclip::ProcessorHelpers do
-  describe ".load_processor" do
-    context "when the file exists in lib/paperclip" do
-      it "loads it correctly" do
-        pathname = Pathname.new("my_app")
-        main_path = "main_path"
-        alternate_path = "alternate_path"
-
-        allow(Rails).to receive(:root).and_return(pathname)
-        expect(File).to receive(:expand_path).with(pathname.join("lib/paperclip", "custom.rb")).and_return(main_path)
-        expect(File).to receive(:expand_path).with(pathname.join("lib/paperclip_processors", "custom.rb")).and_return(alternate_path)
-        expect(File).to receive(:exist?).with(main_path).and_return(true)
-        expect(File).to receive(:exist?).with(alternate_path).and_return(false)
-
-        expect(Paperclip).to receive(:require).with(main_path)
-
-        Paperclip.load_processor(:custom)
-      end
-    end
-
-    context "when the file exists in lib/paperclip_processors" do
-      it "loads it correctly" do
-        pathname = Pathname.new("my_app")
-        main_path = "main_path"
-        alternate_path = "alternate_path"
-
-        allow(Rails).to receive(:root).and_return(pathname)
-        expect(File).to receive(:expand_path).with(pathname.join("lib/paperclip", "custom.rb")).and_return(main_path)
-        expect(File).to receive(:expand_path).with(pathname.join("lib/paperclip_processors", "custom.rb")).and_return(alternate_path)
-        expect(File).to receive(:exist?).with(main_path).and_return(false)
-        expect(File).to receive(:exist?).with(alternate_path).and_return(true)
-
-        expect(Paperclip).to receive(:require).with(alternate_path)
-
-        Paperclip.load_processor(:custom)
-      end
-    end
-
-    context "when the file does not exist in lib/paperclip_processors" do
-      it "raises an error" do
-        pathname = Pathname.new("my_app")
-        main_path = "main_path"
-        alternate_path = "alternate_path"
-
-        allow(Rails).to receive(:root).and_return(pathname)
-        allow(File).to receive(:expand_path).with(pathname.join("lib/paperclip", "custom.rb")).and_return(main_path)
-        allow(File).to receive(:expand_path).with(pathname.join("lib/paperclip_processors", "custom.rb")).and_return(alternate_path)
-        allow(File).to receive(:exist?).with(main_path).and_return(false)
-        allow(File).to receive(:exist?).with(alternate_path).and_return(false)
-
-        assert_raises(LoadError) { Paperclip.processor(:custom) }
-      end
-    end
-  end
-end