shrine 2.18.1 → 2.19.0

data/lib/shrine/plugins/logging.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+Shrine.deprecation("The logging plugin has been deprecated in favor of instrumentation plugin. The logging plugin will be removed in Shrine 3.")
+
 require "logger"
 require "json"
 require "time"

data/lib/shrine/plugins/moving.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+Shrine.deprecation("The moving plugin has been deprecated in favor of the :move upload option for FileSystem storage. It will no longer be available in Shrine 3.")
+
 class Shrine
   module Plugins
     # Documentation lives in [doc/plugins/moving.md] on GitHub.

data/lib/shrine/plugins/pretty_location.rb

@@ -7,29 +7,38 @@ class Shrine
     # [doc/plugins/pretty_location.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/pretty_location.md
     module PrettyLocation
       def self.configure(uploader, opts = {})
-        uploader.opts[:pretty_location_namespace] = opts.fetch(:namespace, uploader.opts[:pretty_location_namespace])
+        uploader.opts[:pretty_location] ||= { identifier: :id }
+        uploader.opts[:pretty_location].merge!(opts)
       end
 
       module InstanceMethods
         def generate_location(io, context)
-          if context[:record]
-            type = class_location(context[:record].class) if context[:record].class.name
-            id   = context[:record].id if context[:record].respond_to?(:id)
+          pretty_location(io, context)
+        end
+
+        def pretty_location(io, name: nil, record: nil, version: nil, identifier: nil, **)
+          if record
+            namespace    = record_namespace(record)
+            identifier ||= record_identifier(record)
           end
-          name = context[:name]
 
-          dirname, slash, basename = super.rpartition("/")
-          basename = "#{context[:version]}-#{basename}" if context[:version]
-          original = dirname + slash + basename
+          basename = basic_location(io)
+          basename = "#{version}-#{basename}" if version
 
-          [type, id, name, original].compact.join("/")
+          [*namespace, *identifier, *name, basename].join("/")
         end
 
         private
 
-        def class_location(klass)
-          parts = klass.name.downcase.split("::")
-          if separator = opts[:pretty_location_namespace]
+        def record_identifier(record)
+          record.public_send(opts[:pretty_location][:identifier])
+        end
+
+        def record_namespace(record)
+          class_name = record.class.name or return
+          parts      = class_name.downcase.split("::")
+
+          if separator = opts[:pretty_location][:namespace]
             parts.join(separator)
           else
             parts.last

data/lib/shrine/plugins/rack_file.rb

@@ -19,7 +19,7 @@ class Shrine
             )
           end
 
-          UploadedFile.new(hash)
+          Shrine::RackFile.new(hash)
         end
       end
 
@@ -77,27 +77,32 @@ class Shrine
         end
       end
 
-      # This is used to wrap the Rack hash into an IO-like object which Shrine
-      # can upload.
-      class UploadedFile
-        attr_reader :tempfile, :original_filename, :content_type
-        alias :to_io :tempfile
+    end
 
-        def initialize(hash)
-          @tempfile          = hash[:tempfile]
-          @original_filename = hash[:filename]
-          @content_type      = hash[:type]
-        end
+    register_plugin(:rack_file, RackFile)
+  end
 
-        def path
-          @tempfile.path
-        end
+  # This is used to wrap the Rack hash into an IO-like object which Shrine
+  # can upload.
+  class RackFile
+    attr_reader :tempfile, :original_filename, :content_type
+    alias :to_io :tempfile
 
-        extend Forwardable
-        delegate [:read, :size, :rewind, :eof?, :close] => :@tempfile
-      end
+    def initialize(hash)
+      @tempfile          = hash[:tempfile]
+      @original_filename = hash[:filename]
+      @content_type      = hash[:type]
     end
 
-    register_plugin(:rack_file, RackFile)
+    def path
+      @tempfile.path
+    end
+
+    extend Forwardable
+    delegate [:read, :size, :rewind, :eof?, :close] => :@tempfile
   end
+
+  # backwards compatibility
+  Plugins::RackFile.const_set(:UploadedFile, RackFile)
+  Plugins::RackFile.deprecate_constant(:UploadedFile)
 end

data/lib/shrine/plugins/refresh_metadata.rb

@@ -7,12 +7,12 @@ class Shrine
     # [doc/plugins/refresh_metadata.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/refresh_metadata.md
     module RefreshMetadata
       module FileMethods
-        def refresh_metadata!(context = {})
+        def refresh_metadata!(**context)
           refreshed_metadata =
-            if @io
-              uploader.extract_metadata(self, context)
+            if opened?
+              uploader.send(:get_metadata, self, metadata: true, **context)
             else
-              open { uploader.extract_metadata(self, context) }
+              open { uploader.send(:get_metadata, self, metadata: true, **context) }
             end
 
           @data = @data.merge("metadata" => metadata.merge(refreshed_metadata))

data/lib/shrine/plugins/remote_url.rb

@@ -8,12 +8,48 @@ class Shrine
     #
     # [doc/plugins/remote_url.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/remote_url.md
     module RemoteUrl
+      LOG_SUBSCRIBER = -> (event) do
+        Shrine.logger.info "Remote URL (#{event.duration}ms) – #{{
+          remote_url:       event[:remote_url],
+          download_options: event[:download_options],
+          uploader:         event[:uploader],
+        }.inspect}"
+      end
+
       def self.configure(uploader, opts = {})
-        raise Error, "The :max_size option is required for remote_url plugin" if !opts.key?(:max_size) && !uploader.opts.key?(:remote_url_max_size)
+        uploader.opts[:remote_url] ||= { downloader: Down.method(:download), log_subscriber: LOG_SUBSCRIBER }
+        uploader.opts[:remote_url].merge!(opts)
+
+        unless uploader.opts[:remote_url].key?(:max_size)
+          fail Error, "The :max_size option is required for remote_url plugin"
+        end
+
+        # instrumentation plugin integration
+        if uploader.respond_to?(:subscribe)
+          uploader.subscribe(:remote_url, &uploader.opts[:remote_url][:log_subscriber])
+        end
+      end
+
+      module ClassMethods
+        # Downloads the file using the "down" gem or a custom downloader.
+        # Checks the file size and terminates the download early if the file
+        # is too big.
+        def remote_url(url, **options)
+          options = { max_size: opts[:remote_url][:max_size] }.merge(options)
+
+          instrument_remote_url(url, options) do
+            opts[:remote_url][:downloader].call(url, options)
+          end
+        end
+
+        private
+
+        # Sends a `remote_url.shrine` event for instrumentation plugin.
+        def instrument_remote_url(url, options, &block)
+          return yield unless respond_to?(:instrument)
 
-        uploader.opts[:remote_url_downloader] = opts.fetch(:downloader, uploader.opts.fetch(:remote_url_downloader, :open_uri))
-        uploader.opts[:remote_url_max_size] = opts.fetch(:max_size, uploader.opts[:remote_url_max_size])
-        uploader.opts[:remote_url_error_message] = opts.fetch(:error_message, uploader.opts[:remote_url_error_message])
+          instrument(:remote_url, remote_url: url, download_options: options, &block)
+        end
       end
 
       module AttachmentMethods
@@ -38,7 +74,7 @@ class Shrine
           return if url == "" || url.nil?
 
           begin
-            downloaded_file = download(url, downloader)
+            downloaded_file = shrine_class.remote_url(url, downloader)
           rescue => error
             download_error = error
           end
@@ -64,25 +100,8 @@ class Shrine
 
         private
 
-        # Downloads the file using the "down" gem or a custom downloader.
-        # Checks the file size and terminates the download early if the file
-        # is too big.
-        def download(url, options)
-          downloader = shrine_class.opts[:remote_url_downloader]
-          downloader = method(:"download_with_#{downloader}") if downloader.is_a?(Symbol)
-          max_size = shrine_class.opts[:remote_url_max_size]
-
-          downloader.call(url, { max_size: max_size }.merge(options))
-        end
-
-        # We silence any download errors, because for the user's point of view
-        # the download simply failed.
-        def download_with_open_uri(url, options)
-          Down.download(url, options)
-        end
-
         def download_error_message(url, error)
-          if message = shrine_class.opts[:remote_url_error_message]
+          if message = shrine_class.opts[:remote_url][:error_message]
             if message.respond_to?(:call)
               args = [url, error].take(message.arity.abs)
               message = message.call(*args)

data/lib/shrine/plugins/signature.rb

@@ -6,11 +6,42 @@ class Shrine
     #
     # [doc/plugins/signature.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/signature.md
     module Signature
+      LOG_SUBSCRIBER = -> (event) do
+        Shrine.logger.info "Signature (#{event.duration}ms) – #{{
+          io:        event[:io].class,
+          algorithm: event[:algorithm],
+          format:    event[:format],
+          uploader:  event[:uploader],
+        }.inspect}"
+      end
+
+      def self.configure(uploader, opts = {})
+        uploader.opts[:signature] ||= { log_subscriber: LOG_SUBSCRIBER }
+        uploader.opts[:signature].merge!(opts)
+
+        # instrumentation plugin integration
+        if uploader.respond_to?(:subscribe)
+          uploader.subscribe(:signature, &uploader.opts[:signature][:log_subscriber])
+        end
+      end
+
       module ClassMethods
         # Calculates `algorithm` hash of the contents of the IO object, and
         # encodes it into `format`.
         def calculate_signature(io, algorithm, format: :hex)
-          SignatureCalculator.new(algorithm.downcase, format: format).call(io)
+          instrument_signature(io, algorithm, format) do
+            SignatureCalculator.new(algorithm.downcase, format: format).call(io)
+          end
+        end
+        alias signature calculate_signature
+
+        private
+
+        # Sends a `signature.shrine` event for instrumentation plugin.
+        def instrument_signature(io, algorithm, format, &block)
+          return yield unless respond_to?(:instrument)
+
+          instrument(:signature, io: io, algorithm: algorithm, format: format, &block)
         end
       end
 

data/lib/shrine/plugins/store_dimensions.rb

@@ -6,23 +6,47 @@ class Shrine
     #
     # [doc/plugins/store_dimensions.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/store_dimensions.md
     module StoreDimensions
+      LOG_SUBSCRIBER = -> (event) do
+        Shrine.logger.info "Image Dimensions (#{event.duration}ms) – #{{
+          io:       event[:io].class,
+          uploader: event[:uploader],
+        }.inspect}"
+      end
+
       def self.configure(uploader, opts = {})
-        uploader.opts[:dimensions_analyzer] = opts.fetch(:analyzer, uploader.opts.fetch(:dimensions_analyzer, :fastimage))
+        uploader.opts[:store_dimensions] ||= { analyzer: :fastimage, on_error: :warn, log_subscriber: LOG_SUBSCRIBER }
+        uploader.opts[:store_dimensions].merge!(opts)
+
+        # resolve error strategy
+        case uploader.opts[:store_dimensions][:on_error]
+        when :fail
+          uploader.opts[:store_dimensions][:on_error] = -> (error) { fail error }
+        when :warn
+          uploader.opts[:store_dimensions][:on_error] = -> (error) { Shrine.warn "Error occurred when attempting to extract image dimensions: #{error.inspect}" }
+        when :ignore
+          uploader.opts[:store_dimensions][:on_error] = -> (error) { }
+        end
+
+        # instrumentation plugin integration
+        if uploader.respond_to?(:subscribe)
+          uploader.subscribe(:image_dimensions, &uploader.opts[:store_dimensions][:log_subscriber])
+        end
       end
 
       module ClassMethods
         # Determines the dimensions of the IO object by calling the specified
         # analyzer.
         def extract_dimensions(io)
-          analyzer = opts[:dimensions_analyzer]
+          analyzer = opts[:store_dimensions][:analyzer]
           analyzer = dimensions_analyzer(analyzer) if analyzer.is_a?(Symbol)
           args = [io, dimensions_analyzers].take(analyzer.arity.abs)
 
-          dimensions = analyzer.call(*args)
+          dimensions = instrument_dimensions(io) { analyzer.call(*args) }
           io.rewind
 
           dimensions
         end
+        alias dimensions extract_dimensions
 
         # Returns a hash of built-in dimensions analyzers, where keys are
         # analyzer names and values are `#call`-able objects which accepts the
@@ -35,7 +59,18 @@ class Shrine
 
         # Returns callable dimensions analyzer object.
         def dimensions_analyzer(name)
-          DimensionsAnalyzer.new(name).method(:call)
+          on_error = opts[:store_dimensions][:on_error]
+
+          DimensionsAnalyzer.new(name, on_error: on_error).method(:call)
+        end
+
+        private
+
+        # Sends a `image_dimensions.shrine` event for instrumentation plugin.
+        def instrument_dimensions(io, &block)
+          return yield unless respond_to?(:instrument)
+
+          instrument(:image_dimensions, io: io, &block)
         end
       end
 
@@ -77,10 +112,11 @@ class Shrine
       class DimensionsAnalyzer
         SUPPORTED_TOOLS = [:fastimage, :mini_magick, :ruby_vips]
 
-        def initialize(tool)
+        def initialize(tool, on_error: method(:fail))
           raise Error, "unknown dimensions analyzer #{tool.inspect}, supported analyzers are: #{SUPPORTED_TOOLS.join(",")}" unless SUPPORTED_TOOLS.include?(tool)
 
-          @tool = tool
+          @tool     = tool
+          @on_error = on_error
         end
 
         def call(io)
@@ -93,19 +129,28 @@ class Shrine
 
         def extract_with_fastimage(io)
           require "fastimage"
-          FastImage.size(io)
+          FastImage.size(io, raise_on_failure: true)
+        rescue FastImage::FastImageException => error
+          on_error(error)
         end
 
         def extract_with_mini_magick(io)
           require "mini_magick"
           Shrine.with_file(io) { |file| MiniMagick::Image.new(file.path).dimensions }
-        rescue MiniMagick::Error
+        rescue MiniMagick::Error => error
+          on_error(error)
         end
 
         def extract_with_ruby_vips(io)
           require "vips"
           Shrine.with_file(io) { |file| Vips::Image.new_from_file(file.path).size }
-        rescue Vips::Error
+        rescue Vips::Error => error
+          on_error(error)
+        end
+
+        def on_error(error)
+          @on_error.call(error)
+          nil
         end
       end
     end

data/lib/shrine/plugins/validation_helpers.rb

@@ -12,16 +12,18 @@ class Shrine
       end
 
       DEFAULT_MESSAGES = {
-        max_size: ->(max) { "is too large (max is #{PRETTY_FILESIZE.call(max)})" },
-        min_size: ->(min) { "is too small (min is #{PRETTY_FILESIZE.call(min)})" },
-        max_width: ->(max) { "is too wide (max is #{max} px)" },
-        min_width: ->(min) { "is too narrow (min is #{min} px)" },
-        max_height: ->(max) { "is too tall (max is #{max} px)" },
-        min_height: ->(min) { "is too short (min is #{min} px)" },
-        mime_type_inclusion: ->(list) { "isn't of allowed type (allowed types: #{list.join(", ")})" },
-        mime_type_exclusion: ->(list) { "is of forbidden type" },
-        extension_inclusion: ->(list) { "isn't of allowed format (allowed formats: #{list.join(", ")})" },
-        extension_exclusion: ->(list) { "is of forbidden format" },
+        max_size:            -> (max)  { "size must not be greater than #{PRETTY_FILESIZE.call(max)}" },
+        min_size:            -> (min)  { "size must not be less than #{PRETTY_FILESIZE.call(min)}" },
+        max_width:           -> (max)  { "width must not be greater than #{max}px" },
+        min_width:           -> (min)  { "width must not be less than #{min}px" },
+        max_height:          -> (max)  { "height must not be greater than #{max}px" },
+        min_height:          -> (min)  { "height must not be less than #{min}px" },
+        max_dimensions:      -> (dims) { "dimensions must not be greater than #{dims.join("x")}" },
+        min_dimensions:      -> (dims) { "dimensions must not be less than #{dims.join("x")}" },
+        mime_type_inclusion: -> (list) { "type must be one of: #{list.join(", ")}" },
+        mime_type_exclusion: -> (list) { "type must not be one of: #{list.join(", ")}" },
+        extension_inclusion: -> (list) { "extension must be one of: #{list.join(", ")}" },
+        extension_exclusion: -> (list) { "extension must not be one of: #{list.join(", ")}" },
       }
 
       FILESIZE_UNITS = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"].freeze
@@ -45,96 +47,195 @@ class Shrine
       end
 
       module AttacherMethods
-        # Validates that the file is not larger than `max`.
+        # Validates that the `size` metadata is not larger than `max`.
+        #
+        #     validate_max_size 5*1024*1024
         def validate_max_size(max, message: nil)
-          get.size <= max or add_error(:max_size, message, max) && false
+          validate_result(get.size <= max, :max_size, message, max)
         end
 
-        # Validates that the file is not smaller than `min`.
+        # Validates that the `size` metadata is not smaller than `min`.
+        #
+        #     validate_min_size 1024
         def validate_min_size(min, message: nil)
-          get.size >= min or add_error(:min_size, message, min) && false
+          validate_result(get.size >= min, :min_size, message, min)
+        end
+
+        # Validates that the `size` metadata is in the given range.
+        #
+        #     validate_size 1024..5*1024*1024
+        def validate_size(size_range)
+          min_size, max_size = size_range.begin, size_range.end
+
+          validate_min_size(min_size) && validate_max_size(max_size)
         end
 
-        # Validates that the file is not wider than `max`. Requires the
-        # `store_dimensions` plugin.
+
+        # Validates that the `width` metadata is not larger than `max`.
+        # Requires the `store_dimensions` plugin.
+        #
+        #     validate_max_width 5000
         def validate_max_width(max, message: nil)
-          raise Error, ":store_dimensions plugin is required" if !get.respond_to?(:width)
+          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:width)
           if get.width
-            get.width <= max or add_error(:max_width, message, max) && false
+            validate_result(get.width <= max, :max_width, message, max)
           else
             Shrine.deprecation("Width of the uploaded file is nil, and Shrine skipped the validation. In Shrine 3 the validation will fail if width is nil.")
           end
         end
 
-        # Validates that the file is not narrower than `min`. Requires the
-        # `store_dimensions` plugin.
+        # Validates that the `width` metadata is not smaller than `min`.
+        # Requires the `store_dimensions` plugin.
+        #
+        #     validate_min_width 100
         def validate_min_width(min, message: nil)
-          raise Error, ":store_dimensions plugin is required" if !get.respond_to?(:width)
+          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:width)
           if get.width
-            get.width >= min or add_error(:min_width, message, min) && false
+            validate_result(get.width >= min, :min_width, message, min)
           else
             Shrine.deprecation("Width of the uploaded file is nil, and Shrine skipped the validation. In Shrine 3 the validation will fail if width is nil.")
           end
         end
 
-        # Validates that the file is not taller than `max`. Requires the
-        # `store_dimensions` plugin.
+        # Validates that the `width` metadata is in the given range.
+        #
+        #     validate_width 100..5000
+        def validate_width(width_range)
+          min_width, max_width = width_range.begin, width_range.end
+
+          validate_min_width(min_width) && validate_max_width(max_width)
+        end
+
+
+        # Validates that the `height` metadata is not larger than `max`.
+        # Requires the `store_dimensions` plugin.
+        #
+        #     validate_max_height 5000
         def validate_max_height(max, message: nil)
-          raise Error, ":store_dimensions plugin is required" if !get.respond_to?(:height)
+          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:height)
           if get.height
-            get.height <= max or add_error(:max_height, message, max) && false
+            validate_result(get.height <= max, :max_height, message, max)
           else
             Shrine.deprecation("Height of the uploaded file is nil, and Shrine skipped the validation. In Shrine 3 the validation will fail if height is nil.")
           end
         end
 
-        # Validates that the file is not shorter than `min`. Requires the
-        # `store_dimensions` plugin.
+        # Validates that the `height` metadata is not smaller than `min`.
+        # Requires the `store_dimensions` plugin.
+        #
+        #     validate_min_height 100
         def validate_min_height(min, message: nil)
-          raise Error, ":store_dimensions plugin is required" if !get.respond_to?(:height)
+          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:height)
           if get.height
-            get.height >= min or add_error(:min_height, message, min) && false
+            validate_result(get.height >= min, :min_height, message, min)
           else
             Shrine.deprecation("Height of the uploaded file is nil, and Shrine skipped the validation. In Shrine 3 the validation will fail if height is nil.")
           end
         end
 
-        # Validates that the MIME type is in the given collection.
+        # Validates that the `height` metadata is in the given range.
+        #
+        #     validate_height 100..5000
+        def validate_height(height_range)
+          min_height, max_height = height_range.begin, height_range.end
+
+          validate_min_height(min_height) && validate_max_height(max_height)
+        end
+
+        # Validates that the dimensions are not larger than specified.
+        #
+        #     validate_max_dimensions [5000, 5000]
+        def validate_max_dimensions((max_width, max_height), message: nil)
+          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:width) && get.respond_to?(:height)
+          fail Error, "width or height metadata is nil" unless get.width && get.height
+
+          validate_result(
+            get.width <= max_width && get.height <= max_height,
+            :max_dimensions, message, [max_width, max_height]
+          )
+        end
+
+        # Validates that the dimensions are not smaller than specified.
+        #
+        #     validate_max_dimensions [100, 100]
+        def validate_min_dimensions((min_width, min_height), message: nil)
+          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:width) && get.respond_to?(:height)
+          fail Error, "width or height metadata is nil" unless get.width && get.height
+
+          validate_result(
+            get.width >= min_width && get.height >= min_height,
+            :min_dimensions, message, [min_width, min_height]
+          )
+        end
+
+        # Validates that the dimensions are in the given range.
+        #
+        #     validate_dimensions [100..5000, 100..5000]
+        def validate_dimensions((width_range, height_range))
+          min_dims = width_range.begin, height_range.begin
+          max_dims = width_range.end,   height_range.end
+
+          validate_min_dimensions(min_dims) && validate_max_dimensions(max_dims)
+        end
+
+        # Validates that the `mime_type` metadata is included in the given
+        # list.
         #
         #     validate_mime_type_inclusion %w[audio/mp3 audio/flac]
-        def validate_mime_type_inclusion(whitelist, message: nil)
-          whitelist.any? { |mime_type| regex(mime_type) =~ get.mime_type.to_s } \
-            or add_error(:mime_type_inclusion, message, whitelist) && false
+        def validate_mime_type_inclusion(types, message: nil)
+          validate_result(
+            types.any? { |type| regex(type) =~ get.mime_type.to_s },
+            :mime_type_inclusion, message, types
+          )
         end
+        alias validate_mime_type validate_mime_type_inclusion
 
-        # Validates that the MIME type is not in the given collection.
+        # Validates that the `mime_type` metadata is not included in the given
+        # list.
         #
         #     validate_mime_type_exclusion %w[text/x-php]
-        def validate_mime_type_exclusion(blacklist, message: nil)
-          blacklist.none? { |mime_type| regex(mime_type) =~ get.mime_type.to_s } \
-            or add_error(:mime_type_exclusion, message, blacklist) && false
+        def validate_mime_type_exclusion(types, message: nil)
+          validate_result(
+            types.none? { |type| regex(type) =~ get.mime_type.to_s },
+            :mime_type_exclusion, message, types
+          )
         end
 
-        # Validates that the extension is in the given collection. Comparison
-        # is case insensitive.
+        # Validates that the extension is included in the given list.
+        # Comparison is case insensitive.
         #
         #     validate_extension_inclusion %w[jpg jpeg png gif]
-        def validate_extension_inclusion(whitelist, message: nil)
-          whitelist.any? { |extension| regex(extension) =~ get.extension.to_s } \
-            or add_error(:extension_inclusion, message, whitelist) && false
+        def validate_extension_inclusion(extensions, message: nil)
+          validate_result(
+            extensions.any? { |extension| regex(extension) =~ get.extension.to_s },
+            :extension_inclusion, message, extensions
+          )
         end
+        alias validate_extension validate_extension_inclusion
 
-        # Validates that the extension is not in the given collection.
+        # Validates that the extension is not included in the given list.
         # Comparison is case insensitive.
         #
         #     validate_extension_exclusion %[php jar]
-        def validate_extension_exclusion(blacklist, message: nil)
-          blacklist.none? { |extension| regex(extension) =~ get.extension.to_s } \
-            or add_error(:extension_exclusion, message, blacklist) && false
+        def validate_extension_exclusion(extensions, message: nil)
+          validate_result(
+            extensions.none? { |extension| regex(extension) =~ get.extension.to_s },
+            :extension_exclusion, message, extensions
+          )
         end
 
         private
 
+        # Adds an error if result is false and returns the result.
+        def validate_result(result, type, message, *args)
+          if result
+            true
+          else
+            add_error(type, message, *args)
+            false
+          end
+        end
+
         # Converts a string to a regex.
         def regex(value)
           if value.is_a?(Regexp)