paperclip 3.5.4 → 5.3.0

data/spec/paperclip/attachment_definitions_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe "Attachment Definitions" do
+  it 'returns all of the attachments on the class' do
+    reset_class "Dummy"
+    Dummy.has_attached_file :avatar, {path: "abc"}
+    Dummy.has_attached_file :other_attachment, {url: "123"}
+    Dummy.do_not_validate_attachment_file_type :avatar
+    expected = {avatar: {path: "abc"}, other_attachment: {url: "123"}}
+
+    expect(Dummy.attachment_definitions).to eq expected
+  end
+end

data/{test/attachment_processing_test.rb → spec/paperclip/attachment_processing_spec.rb}

@@ -1,16 +1,13 @@
 # encoding: utf-8
-require './test/helper'
-require 'paperclip/attachment'
+require 'spec_helper'
 
-class AttachmentProcessingTest < Test::Unit::TestCase
-  def setup
-    rebuild_model
-  end
+describe 'Attachment Processing' do
+  before { rebuild_class }
 
   context 'using validates_attachment_content_type' do
-    should 'process attachments given a valid assignment' do
+    it 'processes attachments given a valid assignment' do
       file = File.new(fixture_file("5k.png"))
-      Dummy.validates_attachment_content_type :avatar, :content_type => "image/png"
+      Dummy.validates_attachment_content_type :avatar, content_type: "image/png"
       instance = Dummy.new
       attachment = instance.avatar
       attachment.expects(:post_process_styles)
@@ -18,9 +15,9 @@ class AttachmentProcessingTest < Test::Unit::TestCase
       attachment.assign(file)
     end
 
-    should 'not process attachments given an invalid assignment with :not' do
+    it 'does not process attachments given an invalid assignment with :not' do
       file = File.new(fixture_file("5k.png"))
-      Dummy.validates_attachment_content_type :avatar, :not => "image/png"
+      Dummy.validates_attachment_content_type :avatar, not: "image/png"
       instance = Dummy.new
       attachment = instance.avatar
       attachment.expects(:post_process_styles).never
@@ -28,9 +25,9 @@ class AttachmentProcessingTest < Test::Unit::TestCase
       attachment.assign(file)
     end
 
-    should 'not process attachments given an invalid assignment with :content_type' do
+    it 'does not process attachments given an invalid assignment with :content_type' do
       file = File.new(fixture_file("5k.png"))
-      Dummy.validates_attachment_content_type :avatar, :content_type => "image/tiff"
+      Dummy.validates_attachment_content_type :avatar, content_type: "image/tiff"
       instance = Dummy.new
       attachment = instance.avatar
       attachment.expects(:post_process_styles).never
@@ -38,9 +35,9 @@ class AttachmentProcessingTest < Test::Unit::TestCase
       attachment.assign(file)
     end
 
-    should 'when validation :if clause returns false, allow what would be an invalid assignment' do
+    it 'allows what would be an invalid assignment when validation :if clause returns false' do
       invalid_assignment = File.new(fixture_file("5k.png"))
-      Dummy.validates_attachment_content_type :avatar, :content_type => "image/tiff", :if => lambda{false}
+      Dummy.validates_attachment_content_type :avatar, content_type: "image/tiff", if: lambda{false}
       instance = Dummy.new
       attachment = instance.avatar
       attachment.expects(:post_process_styles)
@@ -50,9 +47,9 @@ class AttachmentProcessingTest < Test::Unit::TestCase
   end
 
   context 'using validates_attachment' do
-    should 'process attachments given a valid assignment' do
+    it 'processes attachments given a valid assignment' do
       file = File.new(fixture_file("5k.png"))
-      Dummy.validates_attachment :avatar, :content_type => {:content_type => "image/png"}
+      Dummy.validates_attachment :avatar, content_type: {content_type: "image/png"}
       instance = Dummy.new
       attachment = instance.avatar
       attachment.expects(:post_process_styles)
@@ -60,9 +57,9 @@ class AttachmentProcessingTest < Test::Unit::TestCase
       attachment.assign(file)
     end
 
-    should 'not process attachments given an invalid assignment with :not' do
+    it 'does not process attachments given an invalid assignment with :not' do
       file = File.new(fixture_file("5k.png"))
-      Dummy.validates_attachment :avatar, :content_type => {:not => "image/png"}
+      Dummy.validates_attachment :avatar, content_type: {not: "image/png"}
       instance = Dummy.new
       attachment = instance.avatar
       attachment.expects(:post_process_styles).never
@@ -70,9 +67,9 @@ class AttachmentProcessingTest < Test::Unit::TestCase
       attachment.assign(file)
     end
 
-    should 'not process attachments given an invalid assignment with :content_type' do
+    it 'does not process attachments given an invalid assignment with :content_type' do
       file = File.new(fixture_file("5k.png"))
-      Dummy.validates_attachment :avatar, :content_type => {:content_type => "image/tiff"}
+      Dummy.validates_attachment :avatar, content_type: {content_type: "image/tiff"}
       instance = Dummy.new
       attachment = instance.avatar
       attachment.expects(:post_process_styles).never

data/spec/paperclip/attachment_registry_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+describe 'Attachment Registry' do
+  before do
+    Paperclip::AttachmentRegistry.clear
+  end
+
+  context '.names_for' do
+    it 'includes attachment names for the given class' do
+      foo = Class.new
+      Paperclip::AttachmentRegistry.register(foo, :avatar, {})
+
+      assert_equal [:avatar], Paperclip::AttachmentRegistry.names_for(foo)
+    end
+
+    it 'does not include attachment names for other classes' do
+      foo = Class.new
+      bar = Class.new
+      Paperclip::AttachmentRegistry.register(foo, :avatar, {})
+      Paperclip::AttachmentRegistry.register(bar, :lover, {})
+
+      assert_equal [:lover], Paperclip::AttachmentRegistry.names_for(bar)
+    end
+
+    it 'produces the empty array for a missing key' do
+      assert_empty Paperclip::AttachmentRegistry.names_for(Class.new)
+    end
+  end
+
+  context '.each_definition' do
+    it 'calls the block with the class, attachment name, and options' do
+      foo = Class.new
+      expected_accumulations = [
+        [foo, :avatar, { yo: "greeting" }],
+        [foo, :greeter, { ciao: "greeting" }]
+      ]
+      expected_accumulations.each do |args|
+        Paperclip::AttachmentRegistry.register(*args)
+      end
+      accumulations = []
+
+      Paperclip::AttachmentRegistry.each_definition do |*args|
+        accumulations << args
+      end
+
+      assert_equal expected_accumulations, accumulations
+    end
+  end
+
+  context '.definitions_for' do
+    it 'produces the attachment name and options' do
+      expected_definitions = {
+        avatar: { yo: "greeting" },
+        greeter: { ciao: "greeting" }
+      }
+      foo = Class.new
+      Paperclip::AttachmentRegistry.register(
+        foo,
+        :avatar,
+        yo: "greeting"
+      )
+      Paperclip::AttachmentRegistry.register(
+        foo,
+        :greeter,
+        ciao: "greeting"
+      )
+
+      definitions = Paperclip::AttachmentRegistry.definitions_for(foo)
+
+      assert_equal expected_definitions, definitions
+    end
+
+    it 'produces defintions for subclasses' do
+      expected_definitions = { avatar: { yo: "greeting" } }
+      foo = Class.new
+      bar = Class.new(foo)
+      Paperclip::AttachmentRegistry.register(
+        foo,
+        :avatar,
+        expected_definitions[:avatar]
+      )
+
+      definitions = Paperclip::AttachmentRegistry.definitions_for(bar)
+
+      assert_equal expected_definitions, definitions
+    end
+
+    it 'produces defintions for subclasses but deep merging them' do
+      foo_definitions = { avatar: { yo: "greeting" } }
+      bar_definitions = { avatar: { ciao: "greeting" } }
+      expected_definitions = {
+        avatar: {
+          yo: "greeting",
+          ciao: "greeting"
+        }
+      }
+      foo = Class.new
+      bar = Class.new(foo)
+      Paperclip::AttachmentRegistry.register(
+        foo,
+        :avatar,
+        foo_definitions[:avatar]
+      )
+      Paperclip::AttachmentRegistry.register(
+        bar,
+        :avatar,
+        bar_definitions[:avatar]
+      )
+
+      definitions = Paperclip::AttachmentRegistry.definitions_for(bar)
+
+      assert_equal expected_definitions, definitions
+    end
+
+    it 'allows subclasses to override attachment defitions' do
+      foo_definitions = { avatar: { yo: "greeting" } }
+      bar_definitions = { avatar: { yo: "hello" } }
+
+      expected_definitions = {
+        avatar: {
+          yo: "hello"
+        }
+      }
+
+      foo = Class.new
+      bar = Class.new(foo)
+      Paperclip::AttachmentRegistry.register(
+        foo,
+        :avatar,
+        foo_definitions[:avatar]
+      )
+      Paperclip::AttachmentRegistry.register(
+        bar,
+        :avatar,
+        bar_definitions[:avatar]
+      )
+
+      definitions = Paperclip::AttachmentRegistry.definitions_for(bar)
+
+      assert_equal expected_definitions, definitions
+    end
+  end
+
+  context '.clear' do
+    it 'removes all of the existing attachment definitions' do
+      foo = Class.new
+      Paperclip::AttachmentRegistry.register(
+        foo,
+        :greeter,
+        ciao: "greeting"
+      )
+
+      Paperclip::AttachmentRegistry.clear
+
+      assert_empty Paperclip::AttachmentRegistry.names_for(foo)
+    end
+  end
+end