bookis-paperclip 2.3.3

data/lib/paperclip/matchers/have_attached_file_matcher.rb

@@ -0,0 +1,57 @@
+module Paperclip
+  module Shoulda
+    module Matchers
+      # Ensures that the given instance or class has an attachment with the
+      # given name.
+      #
+      # Example:
+      #   describe User do
+      #     it { should have_attached_file(:avatar) }
+      #   end
+      def have_attached_file name
+        HaveAttachedFileMatcher.new(name)
+      end
+
+      class HaveAttachedFileMatcher
+        def initialize attachment_name
+          @attachment_name = attachment_name
+        end
+
+        def matches? subject
+          @subject = subject
+          @subject = @subject.class unless Class === @subject
+          responds? && has_column? && included?
+        end
+
+        def failure_message
+          "Should have an attachment named #{@attachment_name}"
+        end
+
+        def negative_failure_message
+          "Should not have an attachment named #{@attachment_name}"
+        end
+
+        def description
+          "have an attachment named #{@attachment_name}"
+        end
+
+        protected
+
+        def responds?
+          methods = @subject.instance_methods.map(&:to_s)
+          methods.include?("#{@attachment_name}") &&
+            methods.include?("#{@attachment_name}=") &&
+            methods.include?("#{@attachment_name}?")
+        end
+
+        def has_column?
+          @subject.column_names.include?("#{@attachment_name}_file_name")
+        end
+
+        def included?
+          @subject.ancestors.include?(Paperclip::InstanceMethods)
+        end
+      end
+    end
+  end
+end

data/lib/paperclip/matchers/validate_attachment_content_type_matcher.rb

@@ -0,0 +1,74 @@
+module Paperclip
+  module Shoulda
+    module Matchers
+      # Ensures that the given instance or class validates the content type of
+      # the given attachment as specified.
+      #
+      # Example:
+      #   describe User do
+      #     it { should validate_attachment_content_type(:icon).
+      #                   allowing('image/png', 'image/gif').
+      #                   rejecting('text/plain', 'text/xml') }
+      #   end
+      def validate_attachment_content_type name
+        ValidateAttachmentContentTypeMatcher.new(name)
+      end
+
+      class ValidateAttachmentContentTypeMatcher
+        def initialize attachment_name
+          @attachment_name = attachment_name
+        end
+
+        def allowing *types
+          @allowed_types = types.flatten
+          self
+        end
+
+        def rejecting *types
+          @rejected_types = types.flatten
+          self
+        end
+
+        def matches? subject
+          @subject = subject
+          @subject = @subject.class unless Class === @subject
+          @allowed_types && @rejected_types &&
+          allowed_types_allowed? && rejected_types_rejected?
+        end
+
+        def failure_message
+          "Content types #{@allowed_types.join(", ")} should be accepted" +
+          " and #{@rejected_types.join(", ")} rejected by #{@attachment_name}"
+        end
+
+        def negative_failure_message
+          "Content types #{@allowed_types.join(", ")} should be rejected" +
+          " and #{@rejected_types.join(", ")} accepted by #{@attachment_name}"
+        end
+
+        def description
+          "validate the content types allowed on attachment #{@attachment_name}"
+        end
+
+        protected
+
+        def allow_types?(types)
+          types.all? do |type|
+            file = StringIO.new(".")
+            file.content_type = type
+            (subject = @subject.new).attachment_for(@attachment_name).assign(file)
+            subject.valid? && subject.errors[:"#{@attachment_name}_content_type"].blank?
+          end
+        end
+
+        def allowed_types_allowed?
+          allow_types?(@allowed_types)
+        end
+
+        def rejected_types_rejected?
+          not allow_types?(@rejected_types)
+        end
+      end
+    end
+  end
+end

data/lib/paperclip/matchers/validate_attachment_presence_matcher.rb

@@ -0,0 +1,54 @@
+module Paperclip
+  module Shoulda
+    module Matchers
+      # Ensures that the given instance or class validates the presence of the
+      # given attachment.
+      #
+      # describe User do
+      #   it { should validate_attachment_presence(:avatar) }
+      # end
+      def validate_attachment_presence name
+        ValidateAttachmentPresenceMatcher.new(name)
+      end
+
+      class ValidateAttachmentPresenceMatcher
+        def initialize attachment_name
+          @attachment_name = attachment_name
+        end
+
+        def matches? subject
+          @subject = subject
+          @subject = @subject.class unless Class === @subject
+          error_when_not_valid? && no_error_when_valid?
+        end
+
+        def failure_message
+          "Attachment #{@attachment_name} should be required"
+        end
+
+        def negative_failure_message
+          "Attachment #{@attachment_name} should not be required"
+        end
+
+        def description
+          "require presence of attachment #{@attachment_name}"
+        end
+
+        protected
+
+        def error_when_not_valid?
+          (subject = @subject.new).send(@attachment_name).assign(nil)
+          subject.valid?
+          not subject.errors[:"#{@attachment_name}_file_name"].blank?
+        end
+
+        def no_error_when_valid?
+          @file = StringIO.new(".")
+          (subject = @subject.new).send(@attachment_name).assign(@file)
+          subject.valid?
+          subject.errors[:"#{@attachment_name}_file_name"].blank?
+        end
+      end
+    end
+  end
+end

data/lib/paperclip/matchers/validate_attachment_size_matcher.rb

@@ -0,0 +1,95 @@
+module Paperclip
+  module Shoulda
+    module Matchers
+      # Ensures that the given instance or class validates the size of the
+      # given attachment as specified.
+      #
+      # Examples:
+      #   it { should validate_attachment_size(:avatar).
+      #                 less_than(2.megabytes) }
+      #   it { should validate_attachment_size(:icon).
+      #                 greater_than(1024) }
+      #   it { should validate_attachment_size(:icon).
+      #                 in(0..100) }
+      def validate_attachment_size name
+        ValidateAttachmentSizeMatcher.new(name)
+      end
+
+      class ValidateAttachmentSizeMatcher
+        def initialize attachment_name
+          @attachment_name = attachment_name
+          @low, @high = 0, (1.0/0)
+        end
+
+        def less_than size
+          @high = size
+          self
+        end
+
+        def greater_than size
+          @low = size
+          self
+        end
+
+        def in range
+          @low, @high = range.first, range.last
+          self
+        end
+
+        def matches? subject
+          @subject = subject
+          @subject = @subject.class unless Class === @subject
+          lower_than_low? && higher_than_low? && lower_than_high? && higher_than_high?
+        end
+
+        def failure_message
+          "Attachment #{@attachment_name} must be between #{@low} and #{@high} bytes"
+        end
+
+        def negative_failure_message
+          "Attachment #{@attachment_name} cannot be between #{@low} and #{@high} bytes"
+        end
+
+        def description
+          "validate the size of attachment #{@attachment_name}"
+        end
+
+        protected
+
+        def override_method object, method, &replacement
+          (class << object; self; end).class_eval do
+            define_method(method, &replacement)
+          end
+        end
+
+        def passes_validation_with_size(new_size)
+          file = StringIO.new(".")
+          override_method(file, :size){ new_size }
+          override_method(file, :to_tempfile){ file }
+
+          (subject = @subject.new).send(@attachment_name).assign(file)
+          subject.valid?
+          subject.errors[:"#{@attachment_name}_file_size"].blank?
+        end
+
+        def lower_than_low?
+          not passes_validation_with_size(@low - 1)
+        end
+
+        def higher_than_low?
+          passes_validation_with_size(@low + 1)
+        end
+
+        def lower_than_high?
+          return true if @high == (1.0/0)
+          passes_validation_with_size(@high - 1)
+        end
+
+        def higher_than_high?
+          return true if @high == (1.0/0)
+          not passes_validation_with_size(@high + 1)
+        end
+      end
+    end
+  end
+end

data/lib/paperclip/matchers.rb

@@ -0,0 +1,33 @@
+require 'paperclip/matchers/have_attached_file_matcher'
+require 'paperclip/matchers/validate_attachment_presence_matcher'
+require 'paperclip/matchers/validate_attachment_content_type_matcher'
+require 'paperclip/matchers/validate_attachment_size_matcher'
+
+module Paperclip
+  module Shoulda
+    # Provides rspec-compatible matchers for testing Paperclip attachments.
+    #
+    # In spec_helper.rb, you'll need to require the matchers:
+    #
+    #   require "paperclip/matchers"
+    #
+    # And include the module:
+    #
+    #   Spec::Runner.configure do |config|
+    #     config.include Paperclip::Shoulda::Matchers
+    #   end
+    #
+    # Example:
+    #   describe User do
+    #     it { should have_attached_file(:avatar) }
+    #     it { should validate_attachment_presence(:avatar) }
+    #     it { should validate_attachment_content_type(:avatar).
+    #                   allowing('image/png', 'image/gif').
+    #                   rejecting('text/plain', 'text/xml') }
+    #     it { should validate_attachment_size(:avatar).
+    #                   less_than(2.megabytes) }
+    #   end
+    module Matchers
+    end
+  end
+end

data/lib/paperclip/processor.rb

@@ -0,0 +1,49 @@
+module Paperclip
+  # Paperclip processors allow you to modify attached files when they are
+  # attached in any way you are able. Paperclip itself uses command-line
+  # programs for its included Thumbnail processor, but custom processors
+  # are not required to follow suit.
+  #
+  # Processors are required to be defined inside the Paperclip module and
+  # are also required to be a subclass of Paperclip::Processor. There is
+  # only one method you *must* implement to properly be a subclass:
+  # #make, but #initialize may also be of use. Both methods accept 3
+  # arguments: the file that will be operated on (which is an instance of
+  # File), a hash of options that were defined in has_attached_file's
+  # style hash, and the Paperclip::Attachment itself.
+  #
+  # All #make needs to return is an instance of File (Tempfile is
+  # acceptable) which contains the results of the processing.
+  #
+  # See Paperclip.run for more information about using command-line
+  # utilities from within Processors.
+  class Processor
+    attr_accessor :file, :options, :attachment
+
+    def initialize file, options = {}, attachment = nil
+      @file = file
+      @options = options
+      @attachment = attachment
+    end
+
+    def make
+    end
+
+    def self.make file, options = {}, attachment = nil
+      new(file, options, attachment).make
+    end
+  end
+
+  # Due to how ImageMagick handles its image format conversion and how Tempfile
+  # handles its naming scheme, it is necessary to override how Tempfile makes
+  # its names so as to allow for file extensions. Idea taken from the comments
+  # on this blog post:
+  # http://marsorange.com/archives/of-mogrify-ruby-tempfile-dynamic-class-definitions
+  class Tempfile < ::Tempfile
+    # Replaces Tempfile's +make_tmpname+ with one that honors file extensions.
+    def make_tmpname(basename, n)
+      extension = File.extname(basename)
+      sprintf("%s,%d,%d%s", File.basename(basename, extension), $$, n.to_i, extension)
+    end
+  end
+end

data/lib/paperclip/railtie.rb

@@ -0,0 +1,24 @@
+require 'paperclip'
+
+module Paperclip
+  if defined? Rails::Railtie
+    require 'rails'
+    class Railtie < Rails::Railtie
+      initializer 'paperclip.insert_into_active_record' do
+        ActiveSupport.on_load :active_record do
+          Paperclip::Railtie.insert
+        end
+      end
+      rake_tasks do
+        load "tasks/paperclip.rake"
+      end
+    end
+  end
+
+  class Railtie
+    def self.insert
+      ActiveRecord::Base.send(:include, Paperclip)
+      File.send(:include, Paperclip::Upfile)
+    end
+  end
+end