kt-paperclip 6.2.0

data/spec/paperclip/paperclip_spec.rb

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

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

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

data/spec/paperclip/processor_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+describe Paperclip::Processor do
+  it "instantiates and call #make when sent #make to the class" do
+    processor = double
+    expect(processor).to receive(:make)
+    expect(Paperclip::Processor).to receive(:new).with(:one, :two, :three).and_return(processor)
+    Paperclip::Processor.make(:one, :two, :three)
+  end
+
+  context "Calling #convert" do
+    it "runs the convert command with Terrapin" do
+      Paperclip.options[:log_command] = false
+      expect(Terrapin::CommandLine).to receive(:new).with("convert", "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
+      Paperclip.options[:log_command] = false
+      expect(Terrapin::CommandLine).to receive(:new).with("identify", "stuff", {}).and_return(double(run: nil))
+      Paperclip::Processor.new("filename").identify("stuff")
+    end
+  end
+end

data/spec/paperclip/rails_environment_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Paperclip::RailsEnvironment do
+  it "returns nil when Rails isn't defined" do
+    resetting_rails_to(nil) do
+      expect(Paperclip::RailsEnvironment.get).to be_nil
+    end
+  end
+
+  it "returns nil when Rails.env isn't defined" do
+    resetting_rails_to({}) do
+      expect(Paperclip::RailsEnvironment.get).to be_nil
+    end
+  end
+
+  it "returns the value of Rails.env if it is set" do
+    resetting_rails_to(OpenStruct.new(env: "foo")) do
+      expect(Paperclip::RailsEnvironment.get).to eq "foo"
+    end
+  end
+
+  def resetting_rails_to(new_value)
+    previous_rails = Object.send(:remove_const, "Rails")
+    Object.const_set("Rails", new_value) unless new_value.nil?
+    yield
+  ensure
+    Object.send(:remove_const, "Rails") if Object.const_defined?("Rails")
+    Object.const_set("Rails", previous_rails)
+  end
+end

data/spec/paperclip/rake_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+require "rake"
+load "./lib/tasks/paperclip.rake"
+
+describe Rake do
+  context "calling `rake paperclip:refresh:thumbnails`" do
+    before do
+      rebuild_model
+      allow(Paperclip::Task).to receive(:obtain_class).and_return("Dummy")
+      @bogus_instance = Dummy.new
+      @bogus_instance.id = "some_id"
+      allow(@bogus_instance.avatar).to receive(:reprocess!)
+      @valid_instance = Dummy.new
+      allow(@valid_instance.avatar).to receive(:reprocess!)
+      allow(Paperclip::Task).to receive(:log_error)
+      allow(Paperclip).to receive(:each_instance_with_attachment).and_yield(@bogus_instance).and_yield(@valid_instance)
+    end
+    context "when there is an exception in reprocess!" do
+      before do
+        allow(@bogus_instance.avatar).to receive(:reprocess!).and_raise
+      end
+
+      it "catches the exception" do
+        assert_nothing_raised do
+          ::Rake::Task["paperclip:refresh:thumbnails"].execute
+        end
+      end
+
+      it "continues to the next instance" do
+        expect(@valid_instance.avatar).to receive(:reprocess!)
+        ::Rake::Task["paperclip:refresh:thumbnails"].execute
+      end
+
+      it "prints the exception" do
+        exception_msg = "Some Exception"
+        allow(@bogus_instance.avatar).to receive(:reprocess!).and_raise(exception_msg)
+        expect(Paperclip::Task).to receive(:log_error) do |str|
+          str.match exception_msg
+        end
+        ::Rake::Task["paperclip:refresh:thumbnails"].execute
+      end
+
+      it "prints the class name" do
+        expect(Paperclip::Task).to receive(:log_error) do |str|
+          str.match "Dummy"
+        end
+        ::Rake::Task["paperclip:refresh:thumbnails"].execute
+      end
+
+      it "prints the instance ID" do
+        expect(Paperclip::Task).to receive(:log_error) do |str|
+          str.match "ID #{@bogus_instance.id}"
+        end
+        ::Rake::Task["paperclip:refresh:thumbnails"].execute
+      end
+    end
+
+    context "when there is an error in reprocess!" do
+      before do
+        @errors = double("errors")
+        allow(@errors).to receive(:full_messages).and_return([""])
+        allow(@errors).to receive(:blank?).and_return(false)
+        allow(@bogus_instance).to receive(:errors).and_return(@errors)
+      end
+
+      it "continues to the next instance" do
+        expect(@valid_instance.avatar).to receive(:reprocess!)
+        ::Rake::Task["paperclip:refresh:thumbnails"].execute
+      end
+
+      it "prints the error" do
+        error_msg = "Some Error"
+        allow(@errors).to receive(:full_messages).and_return([error_msg])
+        expect(Paperclip::Task).to receive(:log_error) do |str|
+          str.match error_msg
+        end
+        ::Rake::Task["paperclip:refresh:thumbnails"].execute
+      end
+
+      it "prints the class name" do
+        expect(Paperclip::Task).to receive(:log_error) do |str|
+          str.match "Dummy"
+        end
+        ::Rake::Task["paperclip:refresh:thumbnails"].execute
+      end
+
+      it "prints the instance ID" do
+        expect(Paperclip::Task).to receive(:log_error) do |str|
+          str.match "ID #{@bogus_instance.id}"
+        end
+        ::Rake::Task["paperclip:refresh:thumbnails"].execute
+      end
+    end
+  end
+
+  context "Paperclip::Task.log_error method" do
+    it "prints its argument to STDERR" do
+      msg = "Some Message"
+      expect($stderr).to receive(:puts).with(msg)
+      Paperclip::Task.log_error(msg)
+    end
+  end
+end