kt-paperclip 4.4.0

data/lib/paperclip.rb

@@ -0,0 +1,213 @@
+# Paperclip allows file attachments that are stored in the filesystem. All graphical
+# transformations are done using the Graphics/ImageMagick command line utilities and
+# are stored in Tempfiles until the record is saved. Paperclip does not require a
+# separate model for storing the attachment's information, instead adding a few simple
+# columns to your table.
+#
+# Author:: Jon Yurek
+# Copyright:: Copyright (c) 2008-2011 thoughtbot, inc.
+# License:: MIT License (http://www.opensource.org/licenses/mit-license.php)
+#
+# Paperclip defines an attachment as any file, though it makes special considerations
+# for image files. You can declare that a model has an attached file with the
+# +has_attached_file+ method:
+#
+#   class User < ActiveRecord::Base
+#     has_attached_file :avatar, :styles => { :thumb => "100x100" }
+#   end
+#
+#   user = User.new
+#   user.avatar = params[:user][:avatar]
+#   user.avatar.url
+#   # => "/users/avatars/4/original_me.jpg"
+#   user.avatar.url(:thumb)
+#   # => "/users/avatars/4/thumb_me.jpg"
+#
+# See the +has_attached_file+ documentation for more details.
+
+require 'erb'
+require 'digest'
+require 'tempfile'
+require 'paperclip/version'
+require 'paperclip/geometry_parser_factory'
+require 'paperclip/geometry_detector_factory'
+require 'paperclip/geometry'
+require 'paperclip/processor'
+require 'paperclip/processor_helpers'
+require 'paperclip/tempfile'
+require 'paperclip/thumbnail'
+require 'paperclip/interpolations/plural_cache'
+require 'paperclip/interpolations'
+require 'paperclip/tempfile_factory'
+require 'paperclip/style'
+require 'paperclip/attachment'
+require 'paperclip/storage'
+require 'paperclip/callbacks'
+require 'paperclip/file_command_content_type_detector'
+require 'paperclip/media_type_spoof_detector'
+require 'paperclip/content_type_detector'
+require 'paperclip/glue'
+require 'paperclip/errors'
+require 'paperclip/missing_attachment_styles'
+require 'paperclip/validators'
+require 'paperclip/logger'
+require 'paperclip/helpers'
+require 'paperclip/has_attached_file'
+require 'paperclip/attachment_registry'
+require 'paperclip/filename_cleaner'
+require 'paperclip/rails_environment'
+require "paperclip/deprecations"
+
+begin
+  # Use mime/types/columnar if available, for reduced memory usage
+  require "mime/types/columnar"
+rescue LoadError
+  require "mime/types"
+end
+
+require 'mimemagic'
+require 'mimemagic/overlay'
+require 'logger'
+require 'cocaine'
+
+require 'paperclip/railtie' if defined?(Rails::Railtie)
+
+# The base module that gets included in ActiveRecord::Base. See the
+# documentation for Paperclip::ClassMethods for more useful information.
+module Paperclip
+  extend Helpers
+  extend Logger
+  extend ProcessorHelpers
+
+  # Provides configurability to Paperclip. The options available are:
+  # * whiny: Will raise an error if Paperclip cannot process thumbnails of
+  #   an uploaded image. Defaults to true.
+  # * log: Logs progress to the Rails log. Uses ActiveRecord's logger, so honors
+  #   log levels, etc. Defaults to true.
+  # * command_path: Defines the path at which to find the command line
+  #   programs if they are not visible to Rails the system's search path. Defaults to
+  #   nil, which uses the first executable found in the user's search path.
+  # * use_exif_orientation: Whether to inspect EXIF data to determine an
+  #   image's orientation. Defaults to true.
+  def self.options
+    @options ||= {
+      :whiny => true,
+      :image_magick_path => nil,
+      :command_path => nil,
+      :log => true,
+      :log_command => true,
+      :swallow_stderr => true,
+      :content_type_mappings => {},
+      :use_exif_orientation => true
+    }
+  end
+
+  def self.io_adapters=(new_registry)
+    @io_adapters = new_registry
+  end
+
+  def self.io_adapters
+    @io_adapters ||= Paperclip::AdapterRegistry.new
+  end
+
+  module ClassMethods
+    # +has_attached_file+ gives the class it is called on an attribute that maps to a file. This
+    # is typically a file stored somewhere on the filesystem and has been uploaded by a user.
+    # The attribute returns a Paperclip::Attachment object which handles the management of
+    # that file. The intent is to make the attachment as much like a normal attribute. The
+    # thumbnails will be created when the new file is assigned, but they will *not* be saved
+    # until +save+ is called on the record. Likewise, if the attribute is set to +nil+ is
+    # called on it, the attachment will *not* be deleted until +save+ is called. See the
+    # Paperclip::Attachment documentation for more specifics. There are a number of options
+    # you can set to change the behavior of a Paperclip attachment:
+    # * +url+: The full URL of where the attachment is publically accessible. This can just
+    #   as easily point to a directory served directly through Apache as it can to an action
+    #   that can control permissions. You can specify the full domain and path, but usually
+    #   just an absolute path is sufficient. The leading slash *must* be included manually for
+    #   absolute paths. The default value is
+    #   "/system/:class/:attachment/:id_partition/:style/:filename". See
+    #   Paperclip::Attachment#interpolate for more information on variable interpolaton.
+    #     :url => "/:class/:attachment/:id/:style_:filename"
+    #     :url => "http://some.other.host/stuff/:class/:id_:extension"
+    # * +default_url+: The URL that will be returned if there is no attachment assigned.
+    #   This field is interpolated just as the url is. The default value is
+    #   "/:attachment/:style/missing.png"
+    #     has_attached_file :avatar, :default_url => "/images/default_:style_avatar.png"
+    #     User.new.avatar_url(:small) # => "/images/default_small_avatar.png"
+    # * +styles+: A hash of thumbnail styles and their geometries. You can find more about
+    #   geometry strings at the ImageMagick website
+    #   (http://www.imagemagick.org/script/command-line-options.php#resize). Paperclip
+    #   also adds the "#" option (e.g. "50x50#"), which will resize the image to fit maximally
+    #   inside the dimensions and then crop the rest off (weighted at the center). The
+    #   default value is to generate no thumbnails.
+    # * +default_style+: The thumbnail style that will be used by default URLs.
+    #   Defaults to +original+.
+    #     has_attached_file :avatar, :styles => { :normal => "100x100#" },
+    #                       :default_style => :normal
+    #     user.avatar.url # => "/avatars/23/normal_me.png"
+    # * +keep_old_files+: Keep the existing attachment files (original + resized) from
+    #   being automatically deleted when an attachment is cleared or updated. Defaults to +false+.
+    # * +preserve_files+: Keep the existing attachment files in all cases, even if the parent
+    #   record is destroyed. Defaults to +false+.
+    # * +whiny+: Will raise an error if Paperclip cannot post_process an uploaded file due
+    #   to a command line error. This will override the global setting for this attachment.
+    #   Defaults to true.
+    # * +convert_options+: When creating thumbnails, use this free-form options
+    #   array to pass in various convert command options.  Typical options are "-strip" to
+    #   remove all Exif data from the image (save space for thumbnails and avatars) or
+    #   "-depth 8" to specify the bit depth of the resulting conversion.  See ImageMagick
+    #   convert documentation for more options: (http://www.imagemagick.org/script/convert.php)
+    #   Note that this option takes a hash of options, each of which correspond to the style
+    #   of thumbnail being generated. You can also specify :all as a key, which will apply
+    #   to all of the thumbnails being generated. If you specify options for the :original,
+    #   it would be best if you did not specify destructive options, as the intent of keeping
+    #   the original around is to regenerate all the thumbnails when requirements change.
+    #     has_attached_file :avatar, :styles => { :large => "300x300", :negative => "100x100" }
+    #                                :convert_options => {
+    #                                  :all => "-strip",
+    #                                  :negative => "-negate"
+    #                                }
+    #   NOTE: While not deprecated yet, it is not recommended to specify options this way.
+    #   It is recommended that :convert_options option be included in the hash passed to each
+    #   :styles for compatibility with future versions.
+    #   NOTE: Strings supplied to :convert_options are split on space in order to undergo
+    #   shell quoting for safety. If your options require a space, please pre-split them
+    #   and pass an array to :convert_options instead.
+    # * +storage+: Chooses the storage backend where the files will be stored. The current
+    #   choices are :filesystem, :fog and :s3. The default is :filesystem. Make sure you read the
+    #   documentation for Paperclip::Storage::Filesystem, Paperclip::Storage::Fog and Paperclip::Storage::S3
+    #   for backend-specific options.
+    #
+    # It's also possible for you to dynamically define your interpolation string for :url,
+    # :default_url, and :path in your model by passing a method name as a symbol as a argument
+    # for your has_attached_file definition:
+    #
+    #   class Person
+    #     has_attached_file :avatar, :default_url => :default_url_by_gender
+    #
+    #     private
+    #
+    #     def default_url_by_gender
+    #       "/assets/avatars/default_#{gender}.png"
+    #     end
+    #   end
+    def has_attached_file(name, options = {})
+      Paperclip::Deprecations.check
+      HasAttachedFile.define_on(self, name, options)
+    end
+  end
+end
+
+# This stuff needs to be run after Paperclip is defined.
+require 'paperclip/io_adapters/registry'
+require 'paperclip/io_adapters/abstract_adapter'
+require 'paperclip/io_adapters/empty_string_adapter'
+require 'paperclip/io_adapters/identity_adapter'
+require 'paperclip/io_adapters/file_adapter'
+require 'paperclip/io_adapters/stringio_adapter'
+require 'paperclip/io_adapters/data_uri_adapter'
+require 'paperclip/io_adapters/nil_adapter'
+require 'paperclip/io_adapters/attachment_adapter'
+require 'paperclip/io_adapters/uploaded_file_adapter'
+require 'paperclip/io_adapters/uri_adapter'
+require 'paperclip/io_adapters/http_url_proxy_adapter'

data/lib/tasks/paperclip.rake

@@ -0,0 +1,127 @@
+require 'paperclip/attachment_registry'
+
+module Paperclip
+  module Task
+    def self.obtain_class
+      class_name = ENV['CLASS'] || ENV['class']
+      raise "Must specify CLASS" unless class_name
+      class_name
+    end
+
+    def self.obtain_attachments(klass)
+      klass = Paperclip.class_for(klass.to_s)
+      name = ENV['ATTACHMENT'] || ENV['attachment']
+
+      attachment_names = Paperclip::AttachmentRegistry.names_for(klass)
+
+      if attachment_names.empty?
+        raise "Class #{klass.name} has no attachments specified"
+      end
+
+      if !name.blank? && attachment_names.map(&:to_s).include?(name.to_s)
+        [ name ]
+      else
+        attachment_names
+      end
+    end
+
+    def self.log_error(error)
+      $stderr.puts error
+    end
+  end
+end
+
+namespace :paperclip do
+  desc "Refreshes both metadata and thumbnails."
+  task :refresh => ["paperclip:refresh:metadata", "paperclip:refresh:thumbnails"]
+
+  namespace :refresh do
+    desc "Regenerates thumbnails for a given CLASS (and optional ATTACHMENT and STYLES splitted by comma)."
+    task :thumbnails => :environment do
+      klass = Paperclip::Task.obtain_class
+      names = Paperclip::Task.obtain_attachments(klass)
+      styles = (ENV['STYLES'] || ENV['styles'] || '').split(',').map(&:to_sym)
+      names.each do |name|
+        Paperclip.each_instance_with_attachment(klass, name) do |instance|
+          attachment = instance.send(name)
+          begin
+            attachment.reprocess!(*styles)
+          rescue Exception => e
+            Paperclip::Task.log_error("exception while processing #{klass} ID #{instance.id}:")
+            Paperclip::Task.log_error(" " + e.message + "\n")
+          end
+          unless instance.errors.blank?
+            Paperclip::Task.log_error("errors while processing #{klass} ID #{instance.id}:")
+            Paperclip::Task.log_error(" " + instance.errors.full_messages.join("\n ") + "\n")
+          end
+        end
+      end
+    end
+
+    desc "Regenerates content_type/size metadata for a given CLASS (and optional ATTACHMENT)."
+    task :metadata => :environment do
+      klass = Paperclip::Task.obtain_class
+      names = Paperclip::Task.obtain_attachments(klass)
+      names.each do |name|
+        Paperclip.each_instance_with_attachment(klass, name) do |instance|
+          if file = Paperclip.io_adapters.for(instance.send(name))
+            instance.send("#{name}_file_name=", instance.send("#{name}_file_name").strip)
+            instance.send("#{name}_content_type=", file.content_type.to_s.strip)
+            instance.send("#{name}_file_size=", file.size) if instance.respond_to?("#{name}_file_size")
+            instance.save(:validate => false)
+          else
+            true
+          end
+        end
+      end
+    end
+
+    desc "Regenerates missing thumbnail styles for all classes using Paperclip."
+    task :missing_styles => :environment do
+      Rails.application.eager_load!
+      Paperclip.missing_attachments_styles.each do |klass, attachment_definitions|
+        attachment_definitions.each do |attachment_name, missing_styles|
+          puts "Regenerating #{klass} -> #{attachment_name} -> #{missing_styles.inspect}"
+          ENV['CLASS'] = klass.to_s
+          ENV['ATTACHMENT'] = attachment_name.to_s
+          ENV['STYLES'] = missing_styles.join(',')
+          Rake::Task['paperclip:refresh:thumbnails'].execute
+        end
+      end
+      Paperclip.save_current_attachments_styles!
+    end
+  end
+
+  desc "Cleans out invalid attachments. Useful after you've added new validations."
+  task :clean => :environment do
+    klass = Paperclip::Task.obtain_class
+    names = Paperclip::Task.obtain_attachments(klass)
+    names.each do |name|
+      Paperclip.each_instance_with_attachment(klass, name) do |instance|
+        unless instance.valid?
+          attributes = %w(file_size file_name content_type).map{ |suffix| "#{name}_#{suffix}".to_sym }
+          if attributes.any?{ |attribute| instance.errors[attribute].present? }
+            instance.send("#{name}=", nil)
+            instance.save(:validate => false)
+          end
+        end
+      end
+    end
+  end
+
+ desc "find missing attachments. Useful to know which attachments are broken"
+  task :find_broken_attachments => :environment do
+    klass = Paperclip::Task.obtain_class
+    names = Paperclip::Task.obtain_attachments(klass)
+    names.each do |name|
+      Paperclip.each_instance_with_attachment(klass, name) do |instance|
+        attachment = instance.send(name)
+        if attachment.exists?
+          print "."
+        else
+          Paperclip::Task.log_error("#{instance.class}##{attachment.name}, #{instance.id}, #{attachment.url}")
+        end
+      end
+    end
+  end
+end

data/paperclip.gemspec

@@ -0,0 +1,52 @@
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+require 'paperclip/version'
+
+Gem::Specification.new do |s|
+  s.name              = "kt-paperclip"
+  s.version           = Paperclip::VERSION
+  s.platform          = Gem::Platform::RUBY
+  s.author            = "Surendra Singhi"
+  s.email             = ["ssinghi@kreeti.com"]
+  s.homepage          = "https://github.com/kreeti/kt-paperclip"
+  s.summary           = "File attachments as attributes for ActiveRecord"
+  s.description       = "Easy upload management for ActiveRecord"
+  s.license           = "MIT"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.requirements << "ImageMagick"
+  s.required_ruby_version = ">= 1.9.2"
+
+  s.add_dependency('activemodel', '>= 3.2.0', '< 5.0')
+  s.add_dependency('activesupport', '>= 3.2.0', '< 5.0')
+  s.add_dependency('cocaine', '~> 0.5.5')
+  s.add_dependency('mime-types')
+  s.add_dependency('mimemagic', '~> 0.3.8')
+  s.add_dependency('bigdecimal', '1.3.5')
+
+  s.add_development_dependency('activerecord', '>= 3.2.0', '< 5.0')
+  s.add_development_dependency('shoulda')
+  s.add_development_dependency('rspec', '~> 3.0')
+  s.add_development_dependency('appraisal')
+  s.add_development_dependency('mocha')
+  s.add_development_dependency('aws-sdk', '>= 1.5.7', "<= 2.0")
+  s.add_development_dependency('bourne', '< 1.6')
+  s.add_development_dependency('cucumber', '~> 1.3.18')
+  s.add_development_dependency('aruba', '~> 0.9.0')
+  s.add_development_dependency('nokogiri')
+  # Ruby version < 1.9.3 can't install capybara > 2.0.3.
+  s.add_development_dependency('capybara')
+  s.add_development_dependency('bundler')
+  s.add_development_dependency('fog-aws')
+  s.add_development_dependency('fog-local')
+  s.add_development_dependency('launchy')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('fakeweb')
+  s.add_development_dependency('railties')
+  s.add_development_dependency('actionmailer', '>= 3.2.0', '< 5.0')
+  s.add_development_dependency('generator_spec')
+  s.add_development_dependency('timecop')
+end

data/shoulda_macros/paperclip.rb

@@ -0,0 +1,134 @@
+require 'paperclip/matchers'
+
+module Paperclip
+  # =Paperclip Shoulda Macros
+  #
+  # These macros are intended for use with shoulda, and will be included into
+  # your tests automatically. All of the macros use the standard shoulda
+  # assumption that the name of the test is based on the name of the model
+  # you're testing (that is, UserTest is the test for the User model), and
+  # will load that class for testing purposes.
+  module Shoulda
+    include Matchers
+    # This will test whether you have defined your attachment correctly by
+    # checking for all the required fields exist after the definition of the
+    # attachment.
+    def should_have_attached_file name
+      klass   = self.name.gsub(/Test$/, '').constantize
+      matcher = have_attached_file name
+      should matcher.description do
+        assert_accepts(matcher, klass)
+      end
+    end
+
+    # Tests for validations on the presence of the attachment.
+    def should_validate_attachment_presence name
+      klass   = self.name.gsub(/Test$/, '').constantize
+      matcher = validate_attachment_presence name
+      should matcher.description do
+        assert_accepts(matcher, klass)
+      end
+    end
+
+    # Tests that you have content_type validations specified. There are two
+    # options, :valid and :invalid. Both accept an array of strings. The
+    # strings should be a list of content types which will pass and fail
+    # validation, respectively.
+    def should_validate_attachment_content_type name, options = {}
+      klass   = self.name.gsub(/Test$/, '').constantize
+      valid   = [options[:valid]].flatten
+      invalid = [options[:invalid]].flatten
+      matcher = validate_attachment_content_type(name).allowing(valid).rejecting(invalid)
+      should matcher.description do
+        assert_accepts(matcher, klass)
+      end
+    end
+
+    # Tests to ensure that you have file size validations turned on. You
+    # can pass the same options to this that you can to
+    # validate_attachment_file_size - :less_than, :greater_than, and :in.
+    # :less_than checks that a file is less than a certain size, :greater_than
+    # checks that a file is more than a certain size, and :in takes a Range or
+    # Array which specifies the lower and upper limits of the file size.
+    def should_validate_attachment_size name, options = {}
+      klass   = self.name.gsub(/Test$/, '').constantize
+      min     = options[:greater_than] || (options[:in] && options[:in].first) || 0
+      max     = options[:less_than]    || (options[:in] && options[:in].last)  || (1.0/0)
+      range   = (min..max)
+      matcher = validate_attachment_size(name).in(range)
+      should matcher.description do
+        assert_accepts(matcher, klass)
+      end
+    end
+
+    # Stubs the HTTP PUT for an attachment using S3 storage.
+    #
+    # @example
+    #   stub_paperclip_s3('user', 'avatar', 'png')
+    def stub_paperclip_s3(model, attachment, extension)
+      definition = model.gsub(" ", "_").classify.constantize.
+                         attachment_definitions[attachment.to_sym]
+
+      path = "http://s3.amazonaws.com/:id/#{definition[:path]}"
+      path.gsub!(/:([^\/\.]+)/) do |match|
+        "([^\/\.]+)"
+      end
+
+      begin
+        FakeWeb.register_uri(:put, Regexp.new(path), :body => "OK")
+      rescue NameError
+        raise NameError, "the stub_paperclip_s3 shoulda macro requires the fakeweb gem."
+      end
+    end
+
+    # Stub S3 and return a file for attachment. Best with Factory Girl.
+    # Uses a strict directory convention:
+    #
+    #     features/support/paperclip
+    #
+    # This method is used by the Paperclip-provided Cucumber step:
+    #
+    #     When I attach a "demo_tape" "mp3" file to a "band" on S3
+    #
+    # @example
+    #   Factory.define :band_with_demo_tape, :parent => :band do |band|
+    #     band.demo_tape { band.paperclip_fixture("band", "demo_tape", "png") }
+    #   end
+    def paperclip_fixture(model, attachment, extension)
+      stub_paperclip_s3(model, attachment, extension)
+      base_path = File.join(File.dirname(__FILE__), "..", "..",
+                            "features", "support", "paperclip")
+      File.new(File.join(base_path, model, "#{attachment}.#{extension}"))
+    end
+  end
+end
+
+if defined?(ActionDispatch::Integration::Session)
+  class ActionDispatch::IntegrationTest::Session  #:nodoc:
+    include Paperclip::Shoulda
+  end
+elsif defined?(ActionController::Integration::Session)
+  class ActionController::Integration::Session  #:nodoc:
+    include Paperclip::Shoulda
+  end
+end
+
+if defined?(FactoryGirl::Factory)
+  class FactoryGirl::Factory
+    include Paperclip::Shoulda  #:nodoc:
+  end
+else
+  class Factory
+    include Paperclip::Shoulda  #:nodoc:
+  end
+end
+
+if defined?(Minitest)
+  class Minitest::Unit::TestCase #:nodoc:
+    extend Paperclip::Shoulda
+  end
+elsif defined?(Test)
+  class Test::Unit::TestCase #:nodoc:
+    extend Paperclip::Shoulda
+  end
+end

data/spec/database.yml

@@ -0,0 +1,4 @@
+test:
+  adapter: sqlite3
+  database: ":memory:"
+

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/spec/paperclip/attachment_processing_spec.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'Attachment Processing' do
+  context 'using validates_attachment_content_type' do
+    before do
+      rebuild_class
+    end
+
+    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"
+      instance = Dummy.new
+      attachment = instance.avatar
+      attachment.expects(:post_process_styles)
+
+      attachment.assign(file)
+    end
+
+    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"
+      instance = Dummy.new
+      attachment = instance.avatar
+      attachment.expects(:post_process_styles).never
+
+      attachment.assign(file)
+    end
+
+    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"
+      instance = Dummy.new
+      attachment = instance.avatar
+      attachment.expects(:post_process_styles).never
+
+      attachment.assign(file)
+    end
+
+    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}
+      instance = Dummy.new
+      attachment = instance.avatar
+      attachment.expects(:post_process_styles)
+
+      attachment.assign(invalid_assignment)
+    end
+  end
+
+  context 'using validates_attachment' 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"}
+      instance = Dummy.new
+      attachment = instance.avatar
+      attachment.expects(:post_process_styles)
+
+      attachment.assign(file)
+    end
+
+    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"}
+      instance = Dummy.new
+      attachment = instance.avatar
+      attachment.expects(:post_process_styles).never
+
+      attachment.assign(file)
+    end
+
+    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"}
+      instance = Dummy.new
+      attachment = instance.avatar
+      attachment.expects(:post_process_styles).never
+
+      attachment.assign(file)
+    end
+  end
+end