paperclip 3.5.2 → 5.2.1

data/{test/paperclip_test.rb → spec/paperclip/paperclip_spec.rb}

@@ -1,39 +1,41 @@
-require './test/helper'
+require 'spec_helper'
 
-class PaperclipTest < Test::Unit::TestCase
-  context "Calling Paperclip.run" do
-    setup do
+describe Paperclip do
+  context ".run" do
+    before do
       Paperclip.options[:log_command] = false
       Cocaine::CommandLine.expects(:new).with("convert", "stuff", {}).returns(stub(:run))
       @original_command_line_path = Cocaine::CommandLine.path
     end
 
-    teardown do
+    after do
       Paperclip.options[:log_command] = true
       Cocaine::CommandLine.path = @original_command_line_path
     end
 
-    should "run the command with Cocaine" do
+    it "runs the command with Cocaine" do
       Paperclip.run("convert", "stuff")
     end
 
-    should "save Cocaine::CommandLine.path that set before" do
+    it "saves Cocaine::CommandLine.path that set before" do
       Cocaine::CommandLine.path = "/opt/my_app/bin"
       Paperclip.run("convert", "stuff")
-      assert_equal [Cocaine::CommandLine.path].flatten.include?("/opt/my_app/bin"), true
+      expect(Cocaine::CommandLine.path).to match("/opt/my_app/bin")
     end
 
-    should "not duplicate Cocaine::CommandLine.path on multiple runs" do
+    it "does not duplicate Cocaine::CommandLine.path on multiple runs" do
       Cocaine::CommandLine.expects(:new).with("convert", "more_stuff", {}).returns(stub(:run))
       Cocaine::CommandLine.path = nil
       Paperclip.options[:command_path] = "/opt/my_app/bin"
       Paperclip.run("convert", "stuff")
       Paperclip.run("convert", "more_stuff")
-      assert_equal 1, [Cocaine::CommandLine.path].flatten.size
+
+      cmd_path = Paperclip.options[:command_path]
+      assert_equal 1, Cocaine::CommandLine.path.scan(cmd_path).count
     end
   end
 
-  should 'not raise errors when doing a lot of running' do
+  it 'does not raise errors when doing a lot of running' do
     Paperclip.options[:command_path] = ["/usr/local/bin"] * 1024
     Cocaine::CommandLine.path = "/something/else"
     100.times do |x|
@@ -42,80 +44,80 @@ class PaperclipTest < Test::Unit::TestCase
   end
 
   context "Calling Paperclip.log without options[:logger] set" do
-    setup do
+    before do
       Paperclip.logger = nil
       Paperclip.options[:logger] = nil
     end
 
-    teardown do
+    after do
       Paperclip.options[:logger] = ActiveRecord::Base.logger
       Paperclip.logger = ActiveRecord::Base.logger
     end
 
-    should "not raise an error when log is called" do
+    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
-    should "pass the defined logger if :log_command is set" do
+    it "passes the defined logger if :log_command is set" do
       Paperclip.options[:log_command] = true
-      Cocaine::CommandLine.expects(:new).with("convert", "stuff", :logger => Paperclip.logger).returns(stub(:run))
+      Cocaine::CommandLine.expects(:new).with("convert", "stuff", logger: Paperclip.logger).returns(stub(:run))
       Paperclip.run("convert", "stuff")
     end
   end
 
   context "Paperclip.each_instance_with_attachment" do
-    setup do
+    before do
       @file = File.new(fixture_file("5k.png"), 'rb')
-      d1 = Dummy.create(:avatar => @file)
+      d1 = Dummy.create(avatar: @file)
       d2 = Dummy.create
-      d3 = Dummy.create(:avatar => @file)
+      d3 = Dummy.create(avatar: @file)
       @expected = [d1, d3]
     end
 
-    teardown { @file.close }
+    after { @file.close }
 
-    should "yield every instance of a model that has an attachment" do
+    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
-      assert_same_elements @expected, actual
+      expect(actual).to match_array @expected
     end
   end
 
-  should "raise when sent #processor and the name of a class that doesn't exist" do
-    assert_raises(NameError){ Paperclip.processor(:boogey_man) }
+  it "raises when sent #processor and the name of a class that doesn't exist" do
+    assert_raises(LoadError){ Paperclip.processor(:boogey_man) }
   end
 
-  should "return a class when sent #processor and the name of a class under Paperclip" do
+  it "returns a class when sent #processor and the name of a class under Paperclip" do
     assert_equal ::Paperclip::Thumbnail, Paperclip.processor(:thumbnail)
   end
 
-  should "get a class from a namespaced class name" do
+  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
 
-  should "raise when class doesn't exist in specified namespace" do
+  it "raises when class doesn't exist in specified namespace" do
     class ::Three; end
     class ::Four; end
-    assert_raise NameError do
+    assert_raises NameError do
       Paperclip.class_for("Three::Four")
     end
   end
 
   context "An ActiveRecord model with an 'avatar' attachment" do
-    setup do
-      rebuild_model :path => "tmp/:class/omg/:style.:extension"
+    before do
+      rebuild_model path: "tmp/:class/omg/:style.:extension"
       @file = File.new(fixture_file("5k.png"), 'rb')
     end
 
-    teardown { @file.close }
+    after { @file.close }
 
-    should "not error when trying to also create a 'blah' attachment" do
+    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
@@ -123,70 +125,43 @@ class PaperclipTest < Test::Unit::TestCase
       end
     end
 
-    if using_protected_attributes?
-      context "that is attr_protected" do
-        setup do
-          Dummy.class_eval do
-            attr_protected :avatar
-          end
-          @dummy = Dummy.new
-        end
-
-        should "not assign the avatar on mass-set" do
-          @dummy.attributes = { :other => "I'm set!",
-                                :avatar => @file }
-
-          assert_equal "I'm set!", @dummy.other
-          assert ! @dummy.avatar?
-        end
-
-        should "still allow assigment on normal set" do
-          @dummy.other  = "I'm set!"
-          @dummy.avatar = @file
-
-          assert_equal "I'm set!", @dummy.other
-          assert @dummy.avatar?
-        end
-      end
-    end
-
     context "with a subclass" do
-      setup do
+      before do
         class ::SubDummy < Dummy; end
       end
 
-      should "be able to use the attachment from the subclass" do
+      it "is able to use the attachment from the subclass" do
         assert_nothing_raised do
-          @subdummy = SubDummy.create(:avatar => @file)
+          @subdummy = SubDummy.create(avatar: @file)
         end
       end
 
-      teardown do
+      after do
         SubDummy.delete_all
         Object.send(:remove_const, "SubDummy") rescue nil
       end
     end
 
-    should "have an #avatar method" do
+    it "has an avatar getter method" do
       assert Dummy.new.respond_to?(:avatar)
     end
 
-    should "have an #avatar= method" do
+    it "has an avatar setter method" do
       assert Dummy.new.respond_to?(:avatar=)
     end
 
     context "that is valid" do
-      setup do
+      before do
         @dummy = Dummy.new
         @dummy.avatar = @file
       end
 
-      should "be valid" do
+      it "is valid" do
         assert @dummy.valid?
       end
     end
 
-    should "not have Attachment in the ActiveRecord::Base namespace" do
+    it "does not have Attachment in the ActiveRecord::Base namespace" do
       assert_raises(NameError) do
         ActiveRecord::Base::Attachment
       end
@@ -194,7 +169,7 @@ class PaperclipTest < Test::Unit::TestCase
   end
 
   context "configuring a custom processor" do
-    setup do
+    before do
       @freedom_processor = Class.new do
         def make(file, options = {}, attachment = nil)
           file
@@ -206,11 +181,11 @@ class PaperclipTest < Test::Unit::TestCase
       end
     end
 
-    should "be able to find the custom processor" do
+    it "is able to find the custom processor" do
       assert_equal @freedom_processor, Paperclip.processor(:freedom)
     end
 
-    teardown do
+    after do
       Paperclip.clear_processors!
     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'
+
+        Rails.stubs(:root).returns(pathname)
+        File.expects(:expand_path).with(pathname.join('lib/paperclip', 'custom.rb')).returns(main_path)
+        File.expects(:expand_path).with(pathname.join('lib/paperclip_processors', 'custom.rb')).returns(alternate_path)
+        File.expects(:exist?).with(main_path).returns(true)
+        File.expects(:exist?).with(alternate_path).returns(false)
+
+        Paperclip.expects(: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'
+
+        Rails.stubs(:root).returns(pathname)
+        File.expects(:expand_path).with(pathname.join('lib/paperclip', 'custom.rb')).returns(main_path)
+        File.expects(:expand_path).with(pathname.join('lib/paperclip_processors', 'custom.rb')).returns(alternate_path)
+        File.expects(:exist?).with(main_path).returns(false)
+        File.expects(:exist?).with(alternate_path).returns(true)
+
+        Paperclip.expects(: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'
+
+        Rails.stubs(:root).returns(pathname)
+        File.stubs(:expand_path).with(pathname.join('lib/paperclip', 'custom.rb')).returns(main_path)
+        File.stubs(:expand_path).with(pathname.join('lib/paperclip_processors', 'custom.rb')).returns(alternate_path)
+        File.stubs(:exist?).with(main_path).returns(false)
+        File.stubs(:exist?).with(alternate_path).returns(false)
+
+        assert_raises(LoadError) { Paperclip.processor(:custom) }
+      end
+    end
+  end
+end

data/{test/processor_test.rb → spec/paperclip/processor_spec.rb}

@@ -1,7 +1,7 @@
-require './test/helper'
+require 'spec_helper'
 
-class ProcessorTest < Test::Unit::TestCase
-  should "instantiate and call #make when sent #make to the class" do
+describe Paperclip::Processor do
+  it "instantiates and call #make when sent #make to the class" do
     processor = mock
     processor.expects(:make).with()
     Paperclip::Processor.expects(:new).with(:one, :two, :three).returns(processor)
@@ -9,7 +9,7 @@ class ProcessorTest < Test::Unit::TestCase
   end
 
   context "Calling #convert" do
-    should "run the convert command with Cocaine" do
+    it "runs the convert command with Cocaine" do
       Paperclip.options[:log_command] = false
       Cocaine::CommandLine.expects(:new).with("convert", "stuff", {}).returns(stub(:run))
       Paperclip::Processor.new('filename').convert("stuff")
@@ -17,7 +17,7 @@ class ProcessorTest < Test::Unit::TestCase
   end
 
   context "Calling #identify" do
-    should "run the identify command with Cocaine" do
+    it "runs the identify command with Cocaine" do
       Paperclip.options[:log_command] = false
       Cocaine::CommandLine.expects(:new).with("identify", "stuff", {}).returns(stub(:run))
       Paperclip::Processor.new('filename').identify("stuff")

data/spec/paperclip/rails_environment_spec.rb

@@ -0,0 +1,33 @@
+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)
+    begin
+      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
+end

data/{test/rake_test.rb → spec/paperclip/rake_spec.rb}

@@ -1,10 +1,10 @@
-require './test/helper'
+require 'spec_helper'
 require 'rake'
 load './lib/tasks/paperclip.rake'
 
-class RakeTest < Test::Unit::TestCase
+describe Rake do
   context "calling `rake paperclip:refresh:thumbnails`" do
-    setup do
+    before do
       rebuild_model
       Paperclip::Task.stubs(:obtain_class).returns('Dummy')
       @bogus_instance = Dummy.new
@@ -16,22 +16,22 @@ class RakeTest < Test::Unit::TestCase
       Paperclip.stubs(:each_instance_with_attachment).multiple_yields @bogus_instance, @valid_instance
     end
     context "when there is an exception in reprocess!" do
-      setup do
+      before do
         @bogus_instance.avatar.stubs(:reprocess!).raises
       end
 
-      should "catch the exception" do
+      it "catches the exception" do
         assert_nothing_raised do
           ::Rake::Task['paperclip:refresh:thumbnails'].execute
         end
       end
 
-      should "continue to the next instance" do
+      it "continues to the next instance" do
         @valid_instance.avatar.expects(:reprocess!)
         ::Rake::Task['paperclip:refresh:thumbnails'].execute
       end
 
-      should "print the exception" do
+      it "prints the exception" do
         exception_msg = 'Some Exception'
         @bogus_instance.avatar.stubs(:reprocess!).raises(exception_msg)
         Paperclip::Task.expects(:log_error).with do |str|
@@ -40,14 +40,14 @@ class RakeTest < Test::Unit::TestCase
         ::Rake::Task['paperclip:refresh:thumbnails'].execute
       end
 
-      should "print the class name" do
+      it "prints the class name" do
         Paperclip::Task.expects(:log_error).with do |str|
           str.match 'Dummy'
         end
         ::Rake::Task['paperclip:refresh:thumbnails'].execute
       end
 
-      should "print the instance ID" do
+      it "prints the instance ID" do
         Paperclip::Task.expects(:log_error).with do |str|
           str.match "ID #{@bogus_instance.id}"
         end
@@ -56,19 +56,19 @@ class RakeTest < Test::Unit::TestCase
     end
 
     context "when there is an error in reprocess!" do
-      setup do
+      before do
         @errors = mock('errors')
         @errors.stubs(:full_messages).returns([''])
         @errors.stubs(:blank?).returns(false)
         @bogus_instance.stubs(:errors).returns(@errors)
       end
 
-      should "continue to the next instance" do
+      it "continues to the next instance" do
         @valid_instance.avatar.expects(:reprocess!)
         ::Rake::Task['paperclip:refresh:thumbnails'].execute
       end
 
-      should "print the error" do
+      it "prints the error" do
         error_msg = 'Some Error'
         @errors.stubs(:full_messages).returns([error_msg])
         Paperclip::Task.expects(:log_error).with do |str|
@@ -77,14 +77,14 @@ class RakeTest < Test::Unit::TestCase
         ::Rake::Task['paperclip:refresh:thumbnails'].execute
       end
 
-      should "print the class name" do
+      it "prints the class name" do
         Paperclip::Task.expects(:log_error).with do |str|
           str.match 'Dummy'
         end
         ::Rake::Task['paperclip:refresh:thumbnails'].execute
       end
 
-      should "print the instance ID" do
+      it "prints the instance ID" do
         Paperclip::Task.expects(:log_error).with do |str|
           str.match "ID #{@bogus_instance.id}"
         end
@@ -94,7 +94,7 @@ class RakeTest < Test::Unit::TestCase
   end
 
   context "Paperclip::Task.log_error method" do
-    should "print its argument to STDERR" do
+    it "prints its argument to STDERR" do
       msg = 'Some Message'
       $stderr.expects(:puts).with(msg)
       Paperclip::Task.log_error(msg)