jr-paperclip 7.3.0

data/lib/paperclip.rb

@@ -0,0 +1,215 @@
+# 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"
+
+begin
+  # Use mime/types/columnar if available, for reduced memory usage
+  require "mime/types/columnar"
+rescue LoadError
+  require "mime/types"
+end
+
+require "marcel"
+require "logger"
+require "terrapin"
+
+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 ||= {
+      command_path: nil,
+      content_type_mappings: {},
+      log: true,
+      log_command: true,
+      read_timeout: nil,
+      swallow_stderr: true,
+      use_exif_orientation: true,
+      whiny: true,
+      is_windows: Gem.win_platform?,
+      add_validation_errors_to: :both
+    }
+  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 publicly 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"
+    #   Note: When using the +s3+ storage option, the +url+ option expects
+    #   particular values. See the Paperclip::Storage::S3#url documentation for
+    #   specifics.
+    # * +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 = {})
+      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,140 @@
+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)
+
+      raise "Class #{klass.name} has no attachments specified" if attachment_names.empty?
+
+      if name.present? && 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 StandardError => 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|
+          attachment = instance.send(name)
+          if file = Paperclip.io_adapters.for(attachment, attachment.options[:adapter_options])
+            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
+
+    desc "Regenerates fingerprints for a given CLASS (and optional ATTACHMENT). Useful when changing digest."
+    task fingerprints: :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)
+          attachment.assign(attachment)
+          instance.save(validate: false)
+        end
+      end
+    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,51 @@
+$LOAD_PATH.push File.expand_path("lib", __dir__)
+require "paperclip/version"
+
+Gem::Specification.new do |s|
+  s.name              = "jr-paperclip"
+  s.version           = Paperclip::VERSION
+  s.platform          = Gem::Platform::RUBY
+  s.author            = "Jukka Rautanen"
+  s.email             = ["jukka.rautanen@gmail.com"]
+  s.homepage          = "https://github.com/jukra/jr-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.post_install_message = File.read("UPGRADING") if File.exist?("UPGRADING")
+
+  s.requirements << "ImageMagick"
+  s.required_ruby_version = ">= 3.2.0"
+
+  s.add_dependency("activemodel", ">= 7.0.0")
+  s.add_dependency("activesupport", ">= 7.0.0")
+  s.add_dependency("marcel", ">= 1.0.1")
+  s.add_dependency("mime-types")
+  s.add_dependency("terrapin", ">= 0.6.0", "< 2.0")
+
+  s.add_development_dependency("activerecord", ">= 7.0.0")
+  s.add_development_dependency("appraisal")
+  s.add_development_dependency("aruba", "~> 2.0")
+  s.add_development_dependency("aws-sdk-s3")
+  s.add_development_dependency("bundler")
+  s.add_development_dependency("capybara")
+  s.add_development_dependency("cucumber", "~> 9.0")
+  s.add_development_dependency("cucumber-rails", "~> 3.0")
+  s.add_development_dependency("fog-aws")
+  s.add_development_dependency("fog-local")
+  s.add_development_dependency("generator_spec")
+  s.add_development_dependency("launchy")
+  s.add_development_dependency("nokogiri")
+  s.add_development_dependency("ostruct")
+  s.add_development_dependency("railties")
+  s.add_development_dependency("rake")
+  s.add_development_dependency("rspec", "~> 3.0")
+  s.add_development_dependency("shoulda")
+  s.add_development_dependency("timecop")
+  s.add_development_dependency("webmock")
+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,79 @@
+require "spec_helper"
+
+describe "Attachment Processing" do
+  before { rebuild_class }
+
+  context "using validates_attachment_content_type" 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"
+      instance = Dummy.new
+      attachment = instance.avatar
+      expect(attachment).to receive(: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
+      expect(attachment).not_to receive(:post_process_styles)
+
+      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
+      expect(attachment).not_to receive(:post_process_styles)
+
+      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
+      expect(attachment).to receive(: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
+      expect(attachment).to receive(: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
+      expect(attachment).not_to receive(:post_process_styles)
+
+      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
+      expect(attachment).not_to receive(:post_process_styles)
+
+      attachment.assign(file)
+    end
+  end
+end