paperclip 3.5.2 → 5.2.1

data/{test/content_type_detector_test.rb → spec/paperclip/content_type_detector_spec.rb}

@@ -1,33 +1,31 @@
-require './test/helper'
+require 'spec_helper'
 
-class ContentTypeDetectorTest < Test::Unit::TestCase
-  should 'give a sensible default when the name is empty' do
+describe Paperclip::ContentTypeDetector do
+  it 'returns a meaningful content type for open xml spreadsheets' do
+    file = File.new(fixture_file("empty.xlsx"))
+    assert_equal "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                 Paperclip::ContentTypeDetector.new(file.path).detect
+  end
+
+  it 'gives a sensible default when the name is empty' do
     assert_equal "application/octet-stream", Paperclip::ContentTypeDetector.new("").detect
   end
 
-  should 'return the empty content type when the file is empty' do
+  it 'returns the empty content type when the file is empty' do
     tempfile = Tempfile.new("empty")
     assert_equal "inode/x-empty", Paperclip::ContentTypeDetector.new(tempfile.path).detect
+    tempfile.close
   end
 
-  should 'return content type of file if it is an acceptable type' do
+  it 'returns content type of file if it is an acceptable type' do
     MIME::Types.stubs(:type_for).returns([MIME::Type.new('application/mp4'), MIME::Type.new('video/mp4'), MIME::Type.new('audio/mp4')])
-    Paperclip.stubs(:run).returns("video/mp4")
+    Paperclip::ContentTypeDetector.any_instance
+      .stubs(:type_from_file_contents).returns("video/mp4")
     @filename = "my_file.mp4"
     assert_equal "video/mp4", Paperclip::ContentTypeDetector.new(@filename).detect
   end
 
-  should 'find the first result that matches from the official types' do
-    @filename = "/path/to/something.bmp"
-    assert_equal "image/bmp", Paperclip::ContentTypeDetector.new(@filename).detect
-  end
-
-  should 'find the first unofficial result for this filename if no official ones exist' do
-    @filename = "/path/to/something.aiff"
-    assert_equal "audio/x-aiff", Paperclip::ContentTypeDetector.new(@filename).detect
-  end
-
-  should 'find the right type in the list via the file command' do
+  it 'finds the right type in the list via the file command' do
     @filename = "#{Dir.tmpdir}/something.hahalolnotreal"
     File.open(@filename, "w+") do |file|
       file.puts "This is a text file."
@@ -37,12 +35,12 @@ class ContentTypeDetectorTest < Test::Unit::TestCase
     FileUtils.rm @filename
   end
 
-  should 'return a sensible default if something is wrong, like the file is gone' do
+  it 'returns a sensible default if something is wrong, like the file is gone' do
     @filename = "/path/to/nothing"
     assert_equal "application/octet-stream", Paperclip::ContentTypeDetector.new(@filename).detect
   end
 
-  should 'return a sensible default when the file command is missing' do
+  it 'returns a sensible default when the file command is missing' do
     Paperclip.stubs(:run).raises(Cocaine::CommandLineError.new)
     @filename = "/path/to/something"
     assert_equal "application/octet-stream", Paperclip::ContentTypeDetector.new(@filename).detect

data/{test/file_command_content_type_detector_test.rb → spec/paperclip/file_command_content_type_detector_spec.rb}

@@ -1,25 +1,26 @@
-require './test/helper'
+require 'spec_helper'
 
-class FileCommandContentTypeDetectorTest < Test::Unit::TestCase
-  should 'return a content type based on the content of the file' do
+describe Paperclip::FileCommandContentTypeDetector do
+  it 'returns a content type based on the content of the file' do
     tempfile = Tempfile.new("something")
     tempfile.write("This is a file.")
     tempfile.rewind
 
     assert_equal "text/plain", Paperclip::FileCommandContentTypeDetector.new(tempfile.path).detect
+
+    tempfile.close
   end
 
-  should 'return a sensible default when the file command is missing' do
+  it 'returns a sensible default when the file command is missing' do
     Paperclip.stubs(:run).raises(Cocaine::CommandLineError.new)
     @filename = "/path/to/something"
     assert_equal "application/octet-stream",
       Paperclip::FileCommandContentTypeDetector.new(@filename).detect
   end
 
-  should 'return a sensible default on the odd chance that run returns nil' do
+  it 'returns a sensible default on the odd chance that run returns nil' do
     Paperclip.stubs(:run).returns(nil)
     assert_equal "application/octet-stream",
       Paperclip::FileCommandContentTypeDetector.new("windows").detect
   end
 end
-

data/spec/paperclip/filename_cleaner_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Paperclip::FilenameCleaner do
+  it 'converts invalid characters to underscores' do
+    cleaner = Paperclip::FilenameCleaner.new(/[aeiou]/)
+    expect(cleaner.call("baseball")).to eq "b_s_b_ll"
+  end
+
+  it 'does not convert anything if the character regex is nil' do
+    cleaner = Paperclip::FilenameCleaner.new(nil)
+    expect(cleaner.call("baseball")).to eq "baseball"
+  end
+end

data/spec/paperclip/geometry_detector_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Paperclip::GeometryDetector do
+  it 'identifies an image and extract its dimensions' do
+    Paperclip::GeometryParser.stubs(:new).with("434x66,").returns(stub(make: :correct))
+    file = fixture_file("5k.png")
+    factory = Paperclip::GeometryDetector.new(file)
+
+    output = factory.make
+
+    expect(output).to eq :correct
+  end
+
+  it 'identifies an image and extract its dimensions and orientation' do
+    Paperclip::GeometryParser.stubs(:new).with("300x200,6").returns(stub(make: :correct))
+    file = fixture_file("rotated.jpg")
+    factory = Paperclip::GeometryDetector.new(file)
+
+    output = factory.make
+
+    expect(output).to eq :correct
+  end
+
+  it 'avoids reading EXIF orientation if so configured' do
+    begin
+      Paperclip.options[:use_exif_orientation] = false
+      Paperclip::GeometryParser.stubs(:new).with("300x200,1").returns(stub(make: :correct))
+      file = fixture_file("rotated.jpg")
+      factory = Paperclip::GeometryDetector.new(file)
+
+      output = factory.make
+
+      expect(output).to eq :correct
+    ensure
+      Paperclip.options[:use_exif_orientation] = true
+    end
+  end
+end
+

data/{test/geometry_parser_test.rb → spec/paperclip/geometry_parser_spec.rb}

@@ -1,12 +1,12 @@
-require './test/helper'
+require 'spec_helper'
 
-class GeometryParserTest < Test::Unit::TestCase
-  should 'identify an image and extract its dimensions with no orientation' do
+describe Paperclip::GeometryParser do
+  it 'identifies an image and extract its dimensions with no orientation' do
     Paperclip::Geometry.stubs(:new).with(
-      :height => '73',
-      :width => '434',
-      :modifier => nil,
-      :orientation => nil
+      height: '73',
+      width: '434',
+      modifier: nil,
+      orientation: nil
     ).returns(:correct)
     factory = Paperclip::GeometryParser.new("434x73")
 
@@ -15,12 +15,12 @@ class GeometryParserTest < Test::Unit::TestCase
     assert_equal :correct, output
   end
 
-  should 'identify an image and extract its dimensions with an empty orientation' do
+  it 'identifies an image and extract its dimensions with an empty orientation' do
     Paperclip::Geometry.stubs(:new).with(
-      :height => '73',
-      :width => '434',
-      :modifier => nil,
-      :orientation => ''
+      height: '73',
+      width: '434',
+      modifier: nil,
+      orientation: ''
     ).returns(:correct)
     factory = Paperclip::GeometryParser.new("434x73,")
 
@@ -29,12 +29,12 @@ class GeometryParserTest < Test::Unit::TestCase
     assert_equal :correct, output
   end
 
-  should 'identify an image and extract its dimensions and orientation' do
+  it 'identifies an image and extract its dimensions and orientation' do
     Paperclip::Geometry.stubs(:new).with(
-      :height => '200',
-      :width => '300',
-      :modifier => nil,
-      :orientation => '6'
+      height: '200',
+      width: '300',
+      modifier: nil,
+      orientation: '6'
     ).returns(:correct)
     factory = Paperclip::GeometryParser.new("300x200,6")
 
@@ -43,12 +43,12 @@ class GeometryParserTest < Test::Unit::TestCase
     assert_equal :correct, output
   end
 
-  should 'identify an image and extract its dimensions and modifier' do
+  it 'identifies an image and extract its dimensions and modifier' do
     Paperclip::Geometry.stubs(:new).with(
-      :height => '64',
-      :width => '64',
-      :modifier => '#',
-      :orientation => nil
+      height: '64',
+      width: '64',
+      modifier: '#',
+      orientation: nil
     ).returns(:correct)
     factory = Paperclip::GeometryParser.new("64x64#")
 
@@ -57,12 +57,12 @@ class GeometryParserTest < Test::Unit::TestCase
     assert_equal :correct, output
   end
 
-  should 'identify an image and extract its dimensions, orientation, and modifier' do
+  it 'identifies an image and extract its dimensions, orientation, and modifier' do
     Paperclip::Geometry.stubs(:new).with(
-      :height => '50',
-      :width => '100',
-      :modifier => '>',
-      :orientation => '7'
+      height: '50',
+      width: '100',
+      modifier: '>',
+      orientation: '7'
     ).returns(:correct)
     factory = Paperclip::GeometryParser.new("100x50,7>")
 

data/{test/geometry_test.rb → spec/paperclip/geometry_spec.rb}

@@ -1,56 +1,56 @@
-require './test/helper'
+require 'spec_helper'
 
-class GeometryTest < Test::Unit::TestCase
+describe Paperclip::Geometry do
   context "Paperclip::Geometry" do
-    should "correctly report its given dimensions" do
+    it "correctly reports its given dimensions" do
       assert @geo = Paperclip::Geometry.new(1024, 768)
       assert_equal 1024, @geo.width
       assert_equal 768, @geo.height
     end
 
-    should "set height to 0 if height dimension is missing" do
+    it "sets height to 0 if height dimension is missing" do
       assert @geo = Paperclip::Geometry.new(1024)
       assert_equal 1024, @geo.width
       assert_equal 0, @geo.height
     end
 
-    should "set width to 0 if width dimension is missing" do
+    it "sets width to 0 if width dimension is missing" do
       assert @geo = Paperclip::Geometry.new(nil, 768)
       assert_equal 0, @geo.width
       assert_equal 768, @geo.height
     end
 
-    should "be generated from a WxH-formatted string" do
+    it "is generated from a WxH-formatted string" do
       assert @geo = Paperclip::Geometry.parse("800x600")
       assert_equal 800, @geo.width
       assert_equal 600, @geo.height
     end
 
-    should "be generated from a xH-formatted string" do
+    it "is generated from a xH-formatted string" do
       assert @geo = Paperclip::Geometry.parse("x600")
       assert_equal 0, @geo.width
       assert_equal 600, @geo.height
     end
 
-    should "be generated from a Wx-formatted string" do
+    it "is generated from a Wx-formatted string" do
       assert @geo = Paperclip::Geometry.parse("800x")
       assert_equal 800, @geo.width
       assert_equal 0, @geo.height
     end
 
-    should "be generated from a W-formatted string" do
+    it "is generated from a W-formatted string" do
       assert @geo = Paperclip::Geometry.parse("800")
       assert_equal 800, @geo.width
       assert_equal 0, @geo.height
     end
 
-    should "ensure the modifier is nil if not present" do
+    it "ensures the modifier is nil if not present" do
       assert @geo = Paperclip::Geometry.parse("123x456")
       assert_nil @geo.modifier
     end
 
-    should "recognize an EXIF orientation and not rotate with auto_orient if not necessary" do
-      geo = Paperclip::Geometry.new(:width => 1024, :height => 768, :orientation => 1)
+    it "recognizes an EXIF orientation and not rotate with auto_orient if not necessary" do
+      geo = Paperclip::Geometry.new(width: 1024, height: 768, orientation: 1)
       assert geo
       assert_equal 1024, geo.width
       assert_equal 768, geo.height
@@ -61,8 +61,8 @@ class GeometryTest < Test::Unit::TestCase
       assert_equal 768, geo.height
     end
 
-    should "recognize an EXIF orientation and rotate with auto_orient if necessary" do
-      geo = Paperclip::Geometry.new(:width => 1024, :height => 768, :orientation => 6)
+    it "recognizes an EXIF orientation and rotate with auto_orient if necessary" do
+      geo = Paperclip::Geometry.new(width: 1024, height: 768, orientation: 6)
       assert geo
       assert_equal 1024, geo.width
       assert_equal 768, geo.height
@@ -73,7 +73,7 @@ class GeometryTest < Test::Unit::TestCase
       assert_equal 1024, geo.height
     end
 
-    should "treat x and X the same in geometries" do
+    it "treats x and X the same in geometries" do
       @lower = Paperclip::Geometry.parse("123x456")
       @upper = Paperclip::Geometry.parse("123X456")
       assert_equal 123, @lower.width
@@ -82,49 +82,47 @@ class GeometryTest < Test::Unit::TestCase
       assert_equal 456, @upper.height
     end
 
-    ['>', '<', '#', '@', '%', '^', '!', nil].each do |mod|
-      should "ensure the modifier #{mod.inspect} is preserved" do
+    ['>', '<', '#', '@', '@>', '>@', '%', '^', '!', nil].each do |mod|
+      it "ensures the modifier #{description} is preserved" do
         assert @geo = Paperclip::Geometry.parse("123x456#{mod}")
         assert_equal mod, @geo.modifier
         assert_equal "123x456#{mod}", @geo.to_s
       end
-    end
 
-    ['>', '<', '#', '@', '%', '^', '!', nil].each do |mod|
-      should "ensure the modifier #{mod.inspect} is preserved with no height" do
+      it "ensures the modifier #{description} is preserved with no height" do
         assert @geo = Paperclip::Geometry.parse("123x#{mod}")
         assert_equal mod, @geo.modifier
         assert_equal "123#{mod}", @geo.to_s
       end
     end
 
-    should "make sure the modifier gets passed during transformation_to" do
+    it "makes sure the modifier gets passed during transformation_to" do
       assert @src = Paperclip::Geometry.parse("123x456")
       assert @dst = Paperclip::Geometry.parse("123x456>")
       assert_equal ["123x456>", nil], @src.transformation_to(@dst)
     end
 
-    should "generate correct ImageMagick formatting string for W-formatted string" do
+    it "generates correct ImageMagick formatting string for W-formatted string" do
       assert @geo = Paperclip::Geometry.parse("800")
       assert_equal "800", @geo.to_s
     end
 
-    should "generate correct ImageMagick formatting string for Wx-formatted string" do
+    it "generates correct ImageMagick formatting string for Wx-formatted string" do
       assert @geo = Paperclip::Geometry.parse("800x")
       assert_equal "800", @geo.to_s
     end
 
-    should "generate correct ImageMagick formatting string for xH-formatted string" do
+    it "generates correct ImageMagick formatting string for xH-formatted string" do
       assert @geo = Paperclip::Geometry.parse("x600")
       assert_equal "x600", @geo.to_s
     end
 
-    should "generate correct ImageMagick formatting string for WxH-formatted string" do
+    it "generates correct ImageMagick formatting string for WxH-formatted string" do
       assert @geo = Paperclip::Geometry.parse("800x600")
       assert_equal "800x600", @geo.to_s
     end
 
-    should "be generated from a file" do
+    it "is generated from a file" do
       file = fixture_file("5k.png")
       file = File.new(file, 'rb')
       assert_nothing_raised{ @geo = Paperclip::Geometry.from_file(file) }
@@ -132,14 +130,14 @@ class GeometryTest < Test::Unit::TestCase
       assert_equal 434, @geo.width
     end
 
-    should "be generated from a file path" do
+    it "is generated from a file path" do
       file = fixture_file("5k.png")
       assert_nothing_raised{ @geo = Paperclip::Geometry.from_file(file) }
       assert_equal 66, @geo.height
       assert_equal 434, @geo.width
     end
 
-    should 'calculate an EXIF-rotated image dimensions from a path' do
+    it 'calculates an EXIF-rotated image dimensions from a path' do
       file = fixture_file("rotated.jpg")
       assert_nothing_raised{ @geo = Paperclip::Geometry.from_file(file) }
       @geo.auto_orient
@@ -147,28 +145,28 @@ class GeometryTest < Test::Unit::TestCase
       assert_equal 200, @geo.width
     end
 
-    should "not generate from a bad file" do
+    it "does not generate from a bad file" do
       file = "/home/This File Does Not Exist.omg"
-      assert_raise(Paperclip::Errors::NotIdentifiedByImageMagickError){ @geo = Paperclip::Geometry.from_file(file) }
+      expect { @geo = Paperclip::Geometry.from_file(file) }.to raise_error(Paperclip::Errors::NotIdentifiedByImageMagickError)
     end
 
-    should "not generate from a blank filename" do
+    it "does not generate from a blank filename" do
       file = ""
-      assert_raise(Paperclip::Errors::NotIdentifiedByImageMagickError){ @geo = Paperclip::Geometry.from_file(file) }
+      expect { @geo = Paperclip::Geometry.from_file(file) }.to raise_error(Paperclip::Errors::NotIdentifiedByImageMagickError)
     end
 
-    should "not generate from a nil file" do
+    it "does not generate from a nil file" do
       file = nil
-      assert_raise(Paperclip::Errors::NotIdentifiedByImageMagickError){ @geo = Paperclip::Geometry.from_file(file) }
+      expect { @geo = Paperclip::Geometry.from_file(file) }.to raise_error(Paperclip::Errors::NotIdentifiedByImageMagickError)
     end
 
-    should "not generate from a file with no path" do
-      file = mock("file", :path => "")
+    it "does not generate from a file with no path" do
+      file = mock("file", path: "")
       file.stubs(:respond_to?).with(:path).returns(true)
-      assert_raise(Paperclip::Errors::NotIdentifiedByImageMagickError){ @geo = Paperclip::Geometry.from_file(file) }
+      expect { @geo = Paperclip::Geometry.from_file(file) }.to raise_error(Paperclip::Errors::NotIdentifiedByImageMagickError)
     end
 
-    should "let us know when a command isn't found versus a processing error" do
+    it "lets us know when a command isn't found versus a processing error" do
       old_path = ENV['PATH']
       begin
         ENV['PATH'] = ''
@@ -185,32 +183,32 @@ class GeometryTest < Test::Unit::TestCase
      ['horizontal', 1024, 768,  false, true,  false, 1024, 768, 1.3333],
      ['square',     100,  100,  false, false, true,  100,  100, 1]].each do |args|
       context "performing calculations on a #{args[0]} viewport" do
-        setup do
+        before do
           @geo = Paperclip::Geometry.new(args[1], args[2])
         end
 
-        should "#{args[3] ? "" : "not"} be vertical" do
+        it "is #{args[3] ? "" : "not"} vertical" do
           assert_equal args[3], @geo.vertical?
         end
 
-        should "#{args[4] ? "" : "not"} be horizontal" do
+        it "is #{args[4] ? "" : "not"} horizontal" do
           assert_equal args[4], @geo.horizontal?
         end
 
-        should "#{args[5] ? "" : "not"} be square" do
+        it "is #{args[5] ? "" : "not"} square" do
           assert_equal args[5], @geo.square?
         end
 
-        should "report that #{args[6]} is the larger dimension" do
+        it "reports that #{args[6]} is the larger dimension" do
           assert_equal args[6], @geo.larger
         end
 
-        should "report that #{args[7]} is the smaller dimension" do
+        it "reports that #{args[7]} is the smaller dimension" do
           assert_equal args[7], @geo.smaller
         end
 
-        should "have an aspect ratio of #{args[8]}" do
-          assert_in_delta args[8], @geo.aspect, 0.0001
+        it "has an aspect ratio of #{args[8]}" do
+          expect(@geo.aspect).to be_within(0.0001).of(args[8])
         end
       end
     end
@@ -219,17 +217,17 @@ class GeometryTest < Test::Unit::TestCase
      [ [100, 1000], [50, 950], "x950", "50x950+22+0" ],
      [ [100, 1000], [50, 25],  "50x", "50x25+0+237" ]]. each do |args|
       context "of #{args[0].inspect} and given a Geometry #{args[1].inspect} and sent transform_to" do
-        setup do
+        before do
           @geo = Paperclip::Geometry.new(*args[0])
           @dst = Paperclip::Geometry.new(*args[1])
           @scale, @crop = @geo.transformation_to @dst, true
         end
 
-        should "be able to return the correct scaling transformation geometry #{args[2]}" do
+        it "is able to return the correct scaling transformation geometry #{args[2]}" do
           assert_equal args[2], @scale
         end
 
-        should "be able to return the correct crop transformation geometry #{args[3]}" do
+        it "is able to return the correct crop transformation geometry #{args[3]}" do
           assert_equal args[3], @crop
         end
       end
@@ -240,14 +238,14 @@ class GeometryTest < Test::Unit::TestCase
      ['600x400', {'512x512!' => [512, 512], '512x512#' => [512, 512], '512x512>' => [512, 341], '512x512<' => [600, 400], '512x512' => [512, 341]}]].each do |original_size, options|
       options.each_pair do |size, dimensions|
         context "#{original_size} resize_to #{size}" do
-          setup do
+          before do
             @source = Paperclip::Geometry.parse original_size
             @new_geometry = @source.resize_to size
           end
-          should "have #{dimensions.first} width" do
+          it "has #{dimensions.first} width" do
             assert_equal dimensions.first, @new_geometry.width
           end
-          should "have #{dimensions.last} height" do
+          it "has #{dimensions.last} height" do
             assert_equal dimensions.last, @new_geometry.height
           end
         end

data/spec/paperclip/glue_spec.rb

@@ -0,0 +1,44 @@
+# require "spec_helper"
+
+describe Paperclip::Glue do
+  describe "when ActiveRecord does not exist" do
+    before do
+      ActiveRecordSaved = ActiveRecord
+      Object.send :remove_const, "ActiveRecord"
+    end
+
+    after do
+      ActiveRecord = ActiveRecordSaved
+      Object.send :remove_const, "ActiveRecordSaved"
+    end
+
+    it "does not fail" do
+      NonActiveRecordModel = Class.new
+      NonActiveRecordModel.send :include, Paperclip::Glue
+      Object.send :remove_const, "NonActiveRecordModel"
+    end
+  end
+
+  describe "when ActiveRecord does exist" do
+    before do
+      if Object.const_defined?("ActiveRecord")
+        @defined_active_record = false
+      else
+        ActiveRecord = :defined
+        @defined_active_record = true
+      end
+    end
+
+    after do
+      if @defined_active_record
+        Object.send :remove_const, "ActiveRecord"
+      end
+    end
+
+    it "does not fail" do
+      NonActiveRecordModel = Class.new
+      NonActiveRecordModel.send :include, Paperclip::Glue
+      Object.send :remove_const, "NonActiveRecordModel"
+    end
+  end
+end