active_storage_validations 2.0.1 → 2.0.3

data/lib/active_storage_validations/content_type_validator.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative 'shared/asv_active_storageable'
-require_relative 'shared/asv_analyzable'
-require_relative 'shared/asv_attachable'
-require_relative 'shared/asv_errorable'
-require_relative 'shared/asv_optionable'
-require_relative 'shared/asv_symbolizable'
-require_relative 'analyzer/content_type_analyzer'
+require_relative "shared/asv_active_storageable"
+require_relative "shared/asv_analyzable"
+require_relative "shared/asv_attachable"
+require_relative "shared/asv_errorable"
+require_relative "shared/asv_optionable"
+require_relative "shared/asv_symbolizable"
+require_relative "analyzer/content_type_analyzer"
 
 module ActiveStorageValidations
   class ContentTypeValidator < ActiveModel::EachValidator # :nodoc:
@@ -96,9 +96,7 @@ module ActiveStorageValidations
 
       return true if attachable_content_type_is_authorized
 
-      errors_options = initialize_and_populate_error_options(options, attachable)
-      add_error(record, attribute, ERROR_TYPES.first, **errors_options)
-      false
+      add_content_type_invalid_error(record, attribute, attachable)
     end
 
     def marcel_attachable_content_type(attachable)
@@ -108,14 +106,15 @@ module ActiveStorageValidations
     def not_spoofing_content_type?(record, attribute, attachable, blob)
       return true unless enable_spoofing_protection?
 
-      @detected_content_type = metadata_for(blob, attachable, METADATA_KEYS)&.fetch(:content_type, nil)
+      @detected_content_type = begin
+        metadata_for(blob, attachable, METADATA_KEYS)&.fetch(:content_type, nil)
+      rescue ActiveStorage::FileNotFoundError
+        add_attachment_missing_error(record, attribute, attachable)
+        return false
+      end
 
       if attachable_content_type_vs_detected_content_type_mismatch?
-        errors_options = initialize_and_populate_error_options(options, attachable)
-        errors_options[:detected_content_type] = @detected_content_type
-        errors_options[:detected_human_content_type] = content_type_to_human_format(@detected_content_type)
-        add_error(record, attribute, ERROR_TYPES.second, **errors_options)
-        false
+        add_content_type_spoofed_error(record, attribute, attachable, @detected_content_type)
       else
         true
       end
@@ -142,13 +141,27 @@ module ActiveStorageValidations
     end
 
     def enlarged_content_type(content_type)
-      [content_type, *parent_content_types(content_type)].compact.uniq
+      [ content_type, *parent_content_types(content_type) ].compact.uniq
     end
 
     def parent_content_types(content_type)
       Marcel::TYPE_PARENTS[content_type] || []
     end
 
+    def add_content_type_invalid_error(record, attribute, attachable)
+      errors_options = initialize_and_populate_error_options(options, attachable)
+      add_error(record, attribute, ERROR_TYPES.first, **errors_options)
+      false
+    end
+
+    def add_content_type_spoofed_error(record, attribute, attachable, detected_content_type)
+      errors_options = initialize_and_populate_error_options(options, attachable)
+      errors_options[:detected_content_type] = @detected_content_type
+      errors_options[:detected_human_content_type] = content_type_to_human_format(@detected_content_type)
+      add_error(record, attribute, ERROR_TYPES.second, **errors_options)
+      false
+    end
+
     def initialize_and_populate_error_options(options, attachable)
       errors_options = initialize_error_options(options, attachable)
       errors_options[:content_type] = @attachable_content_type
@@ -170,12 +183,12 @@ module ActiveStorageValidations
         end
         .flatten
         .compact
-        .join(', ')
+        .join(", ")
     end
 
     def ensure_exactly_one_validator_option
       unless AVAILABLE_CHECKS.one? { |argument| options.key?(argument) }
-        raise ArgumentError, 'You must pass either :with or :in to the validator'
+        raise ArgumentError, "You must pass either :with or :in to the validator"
       end
     end
 
@@ -211,20 +224,22 @@ module ActiveStorageValidations
     end
 
     def invalid_content_type?(content_type)
-      if content_type == 'image/jpg'
+      if content_type == "image/jpg"
         raise ArgumentError, "'image/jpg' is not a valid content type, you should use 'image/jpeg' instead"
       end
 
-      all_available_marcel_content_types.keys.exclude?(content_type.to_s)
+      all_available_marcel_content_types.exclude?(content_type.to_s)
     end
 
     def all_available_marcel_content_types
-      @all_available_marcel_content_types ||= Marcel::MAGIC.map {|dd| dd.first }
-                                                           .each_with_object(Marcel::TYPE_EXTS) { |(k,v), h| h[k] = v unless h.key?(k) }
+      @all_available_marcel_content_types ||= Marcel::TYPE_EXTS
+        .keys
+        .push(*Marcel::MAGIC.map(&:first))
+        .tap(&:uniq!)
     end
 
     def invalid_extension?(content_type)
-      Marcel::MimeType.for(extension: content_type.to_s) == 'application/octet-stream'
+      Marcel::MimeType.for(extension: content_type.to_s) == "application/octet-stream"
     end
   end
 end

data/lib/active_storage_validations/dimension_validator.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'shared/asv_active_storageable'
-require_relative 'shared/asv_analyzable'
-require_relative 'shared/asv_attachable'
-require_relative 'shared/asv_errorable'
-require_relative 'shared/asv_optionable'
-require_relative 'shared/asv_symbolizable'
+require_relative "shared/asv_active_storageable"
+require_relative "shared/asv_analyzable"
+require_relative "shared/asv_attachable"
+require_relative "shared/asv_errorable"
+require_relative "shared/asv_optionable"
+require_relative "shared/asv_symbolizable"
 
 module ActiveStorageValidations
   class DimensionValidator < ActiveModel::EachValidator # :nodoc
@@ -33,9 +33,9 @@ module ActiveStorageValidations
     METADATA_KEYS = %i[width height].freeze
 
     def check_validity!
-      unless AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-        raise ArgumentError, 'You must pass either :width, :height, :min or :max to the validator'
-      end
+      ensure_at_least_one_validator_option
+      ensure_dimension_in_option_validity
+      ensure_min_max_option_validity
     end
 
     def validate_each(record, attribute, _value)
@@ -46,101 +46,177 @@ module ActiveStorageValidations
 
     private
 
+    def ensure_at_least_one_validator_option
+      unless AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
+        raise ArgumentError, "You must pass either :width, :height, :min or :max to the validator"
+      end
+    end
+
+    def ensure_dimension_in_option_validity
+      %i[width height].each do |dimension|
+        if options[dimension]&.is_a?(Hash) && options[dimension][:in].present?
+          raise ArgumentError, "{ #{dimension}: { in: value } } value must be a Range (min..max)" if !options[dimension][:in].is_a?(Range) && !options[dimension][:in].is_a?(Proc)
+        end
+      end
+    end
+
+    def ensure_min_max_option_validity
+      %i[min max].each do |bound|
+        if options[bound].present?
+          raise ArgumentError, "{ #{bound}: value } value must be a Range (#{bound}_width..#{bound}_height)" if !options[bound]&.is_a?(Range) && !options[bound]&.is_a?(Proc)
+        end
+      end
+    end
+
     def is_valid?(record, attribute, file, metadata)
       flat_options = process_options(record)
       errors_options = initialize_error_options(options, file)
 
-      # Validation fails unless file metadata contains valid width and height.
-      if metadata[:width].to_i <= 0 || metadata[:height].to_i <= 0
-        add_error(record, attribute, :media_metadata_missing, **errors_options)
-        return false
+      return add_media_metadata_missing_error(record, attribute, file, errors_options) unless valid_metadata?(metadata)
+
+      if min_max_validation?(flat_options)
+        validate_min_max(record, attribute, metadata, flat_options, errors_options)
+      else
+        validate_width_height(record, attribute, metadata, flat_options, errors_options)
       end
+    end
+
+    def valid_metadata?(metadata)
+      metadata[:width].to_i > 0 && metadata[:height].to_i > 0
+    end
 
-      # Validation based on checks :min and :max (:min, :max has higher priority to :width, :height).
-      if flat_options[:min] || flat_options[:max]
-        if flat_options[:min] && (
-          (flat_options[:width][:min] && metadata[:width] < flat_options[:width][:min]) ||
-          (flat_options[:height][:min] && metadata[:height] < flat_options[:height][:min])
-          )
-          errors_options[:width] = flat_options[:width][:min]
-          errors_options[:height] = flat_options[:height][:min]
+    def min_max_validation?(flat_options)
+      flat_options[:min] || flat_options[:max]
+    end
+
+    def validate_min_max(record, attribute, metadata, flat_options, errors_options)
+      return false unless validate_min(record, attribute, metadata, flat_options, errors_options)
+      return false unless validate_max(record, attribute, metadata, flat_options, errors_options)
+
+      true
+    end
 
-          add_error(record, attribute, :dimension_min_not_included_in, **errors_options)
-          return false
+    def validate_width_height(record, attribute, metadata, flat_options, errors_options)
+      %i[width height].each do |dimension|
+        next unless flat_options[dimension]
+
+        if flat_options[dimension].is_a?(Hash)
+          validate_range(record, attribute, dimension, metadata, flat_options, errors_options)
+        else
+          validate_exact(record, attribute, dimension, metadata, flat_options, errors_options)
         end
-        if flat_options[:max] && (
-          (flat_options[:width][:max] && metadata[:width] > flat_options[:width][:max]) ||
-          (flat_options[:height][:max] && metadata[:height] > flat_options[:height][:max])
-          )
-          errors_options[:width] = flat_options[:width][:max]
-          errors_options[:height] = flat_options[:height][:max]
-
-          add_error(record, attribute, :dimension_max_not_included_in, **errors_options)
-          return false
+      end
+    end
+
+    # rubocop:disable Metrics/BlockLength
+    %i[min max].each do |bound|
+      define_method("validate_#{bound}") do |record, attribute, metadata, flat_options, errors_options|
+        if send(:"invalid_#{bound}?", flat_options, metadata)
+          send(:"add_#{bound}_error", record, attribute, flat_options, errors_options)
+          false
+        else
+          true
         end
+      end
 
-      # Validation based on checks :width and :height.
-      else
-        width_or_height_invalid = false
-
-        [:width, :height].each do |length|
-          next unless flat_options[length]
-          if flat_options[length].is_a?(Hash)
-            if flat_options[length][:in] && (metadata[length] < flat_options[length][:min] || metadata[length] > flat_options[length][:max])
-              error_type = :"dimension_#{length}_not_included_in"
-              errors_options[:min] = flat_options[length][:min]
-              errors_options[:max] = flat_options[length][:max]
-
-              add_error(record, attribute, error_type, **errors_options)
-              width_or_height_invalid = true
-            else
-              if flat_options[length][:min] && metadata[length] < flat_options[length][:min]
-                error_type = :"dimension_#{length}_not_greater_than_or_equal_to"
-                errors_options[:length] = flat_options[length][:min]
-
-                add_error(record, attribute, error_type, **errors_options)
-                width_or_height_invalid = true
-              elsif flat_options[length][:max] && metadata[length] > flat_options[length][:max]
-                error_type = :"dimension_#{length}_not_less_than_or_equal_to"
-                errors_options[:length] = flat_options[length][:max]
-
-                add_error(record, attribute, error_type, **errors_options)
-                width_or_height_invalid = true
-              end
-            end
-          else
-            if metadata[length] != flat_options[length]
-              error_type = :"dimension_#{length}_not_equal_to"
-              errors_options[:length] = flat_options[length]
-
-              add_error(record, attribute, error_type, **errors_options)
-              width_or_height_invalid = true
-            end
-          end
+      define_method("validate_dimension_#{bound}") do |record, attribute, dimension, metadata, flat_options, errors_options|
+        if send(:"invalid_dimension_#{bound}?", flat_options, dimension, metadata)
+          send(:"add_dimension_#{bound}_error", record, attribute, dimension, flat_options, errors_options)
+          false
+        else
+          true
         end
+      end
+
+      define_method("invalid_#{bound}?") do |flat_options, metadata|
+        flat_options[bound] && (
+          send(:"invalid_dimension_#{bound}?", flat_options, :width, metadata) ||
+          send(:"invalid_dimension_#{bound}?", flat_options, :height, metadata)
+        )
+      end
+
+      define_method("invalid_dimension_#{bound}?") do |flat_options, dimension, metadata|
+        flat_options[dimension][bound] && metadata[dimension].public_send(bound == :min ? :< : :>, flat_options[dimension][bound])
+      end
+
+      define_method("add_#{bound}_error") do |record, attribute, flat_options, errors_options|
+        errors_options[:width] = flat_options[:width][bound]
+        errors_options[:height] = flat_options[:height][bound]
+        add_error(record, attribute, :"dimension_#{bound}_not_included_in", **errors_options)
+      end
 
-        return false if width_or_height_invalid
+      define_method("add_dimension_#{bound}_error") do |record, attribute, dimension, flat_options, errors_options|
+        error_type = bound == :min ? :not_greater_than_or_equal_to : :not_less_than_or_equal_to
+        errors_options[:length] = flat_options[dimension][bound]
+        add_error(record, attribute, :"dimension_#{dimension}_#{error_type}", **errors_options)
       end
+    end
+    # rubocop:enable Metrics/BlockLength
 
-      true # valid file
+    def validate_range(record, attribute, dimension, metadata, flat_options, errors_options)
+      if in_option_used?(flat_options, dimension)
+        return false unless validate_in(record, attribute, dimension, metadata, flat_options, errors_options)
+      else
+        return false unless validate_dimension_min_max(record, attribute, dimension, metadata, flat_options, errors_options)
+      end
+
+      true
+    end
+
+    def validate_in(record, attribute, dimension, metadata, flat_options, errors_options)
+      if outside_range?(metadata[dimension], flat_options[dimension])
+        add_range_error(record, attribute, dimension, flat_options, errors_options)
+        false
+      else
+        true
+      end
+    end
+
+    def in_option_used?(flat_options, dimension)
+      flat_options[dimension][:in]
+    end
+
+    def outside_range?(value, options)
+      value < options[:min] || value > options[:max]
+    end
+
+    def add_range_error(record, attribute, dimension, flat_options, errors_options)
+      errors_options[:min] = flat_options[dimension][:min]
+      errors_options[:max] = flat_options[dimension][:max]
+      add_error(record, attribute, :"dimension_#{dimension}_not_included_in", **errors_options)
+    end
+
+    def validate_dimension_min_max(record, attribute, dimension, metadata, flat_options, errors_options)
+      %i[min max].each do |bound|
+        send(:"validate_dimension_#{bound}", record, attribute, dimension, metadata, flat_options, errors_options)
+      end
+    end
+
+    def validate_exact(record, attribute, dimension, metadata, flat_options, errors_options)
+      if metadata[dimension] != flat_options[dimension]
+        errors_options[:length] = flat_options[dimension]
+        add_error(record, attribute, :"dimension_#{dimension}_not_equal_to", **errors_options)
+        false
+      else
+        true
+      end
     end
 
     def process_options(record)
       flat_options = set_flat_options(record)
 
-      [:width, :height].each do |length|
-        if flat_options[length] and flat_options[length].is_a?(Hash)
-          if (range = flat_options[length][:in])
-            raise ArgumentError, ":in must be a Range" unless range.is_a?(Range)
-            flat_options[length][:min], flat_options[length][:max] = range.min, range.max
+      %i[width height].each do |dimension|
+        if flat_options[dimension] and flat_options[dimension].is_a?(Hash)
+          if (range = flat_options[dimension][:in])
+            flat_options[dimension][:min], flat_options[dimension][:max] = range.min, range.max
           end
         end
       end
-      [:min, :max].each do |dim|
-        if (range = flat_options[dim])
-          raise ArgumentError, ":#{dim} must be a Range (width..height)" unless range.is_a?(Range)
-          flat_options[:width] = { dim => range.first }
-          flat_options[:height] = { dim => range.last }
+
+      %i[min max].each do |bound|
+        if (range = flat_options[bound])
+          flat_options[:width] = { bound => range.first }
+          flat_options[:height] = { bound => range.last }
         end
       end
 

data/lib/active_storage_validations/duration_validator.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'base_comparison_validator'
+require_relative "base_comparison_validator"
 
 module ActiveStorageValidations
   class DurationValidator < BaseComparisonValidator
@@ -22,34 +22,48 @@ module ActiveStorageValidations
       flat_options = set_flat_options(record)
 
       attachables_and_blobs(record, attribute).each do |attachable, blob|
-        duration = metadata_for(blob, attachable, METADATA_KEYS)&.fetch(:duration, nil)
+        duration = begin
+          metadata_for(blob, attachable, METADATA_KEYS)&.fetch(:duration, nil)
+        rescue ActiveStorage::FileNotFoundError
+          add_attachment_missing_error(record, attribute, attachable)
+          next
+        end
 
         if duration.to_i <= 0
-          errors_options = initialize_error_options(options, attachable)
-          add_error(record, attribute, :media_metadata_missing, **errors_options)
+          add_media_metadata_missing_error(record, attribute, attachable)
           next
         end
 
-        next if is_valid?(duration, flat_options)
-
-        errors_options = initialize_error_options(options, attachable)
-        populate_error_options(errors_options, flat_options)
-        errors_options[:duration] = format_bound_value(duration)
-
-        keys = AVAILABLE_CHECKS & flat_options.keys
-        error_type = "duration_not_#{keys.first}".to_sym
-
-        add_error(record, attribute, error_type, **errors_options)
+        is_valid?(duration, flat_options) || populate_error_options_and_add_error(record, attribute, attachable, flat_options, duration)
       end
     end
 
     private
 
+    def populate_error_options_and_add_error(record, attribute, attachable, flat_options, duration)
+      errors_options = initialize_error_options(options, attachable)
+      populate_error_options(errors_options, flat_options, duration)
+
+      error_type = set_error_type(flat_options)
+
+      add_error(record, attribute, error_type, **errors_options)
+    end
+
     def format_bound_value(value)
       return nil unless value
 
       custom_value = value == value.to_i ? value.to_i : value
       ActiveSupport::Duration.build(custom_value).inspect
     end
+
+    def populate_error_options(errors_options, flat_options, duration)
+      super(errors_options, flat_options)
+      errors_options[:duration] = format_bound_value(duration)
+    end
+
+    def set_error_type(flat_options)
+      keys = AVAILABLE_CHECKS & flat_options.keys
+      "duration_not_#{keys.first}".to_sym
+    end
   end
 end

data/lib/active_storage_validations/extensors/asv_blob_metadatable.rb

@@ -4,6 +4,7 @@ module ActiveStorageValidations
   module ASVBlobMetadatable
     extend ActiveSupport::Concern
 
+    # rubocop:disable Metrics/BlockLength
     included do
       # This method returns the metadata that has been set by our gem.
       # The metadata is stored in the blob's custom metadata. All keys are prefixed with 'asv_'
@@ -14,15 +15,15 @@ module ActiveStorageValidations
       # Because of how the metadata is stored, we need to convert the values from String
       # to Integer or Boolean.
       def active_storage_validations_metadata
-        metadata.dig('custom')
-                &.select { |key, _| key.to_s.start_with?('asv_') }
-                &.transform_keys { |key| key.to_s.delete_prefix('asv_') }
+        metadata.dig("custom")
+                &.select { |key, _| key.to_s.start_with?("asv_") }
+                &.transform_keys { |key| key.to_s.delete_prefix("asv_") }
                 &.transform_values do |value|
                   case value
                   when /\A\d+\z/ then value.to_i
                   when /\A\d+\.\d+\z/ then value.to_f
-                  when 'true' then true
-                  when 'false' then false
+                  when "true" then true
+                  when "false" then false
                   else value
                   end
                 end || {}
@@ -34,16 +35,22 @@ module ActiveStorageValidations
       def merge_into_active_storage_validations_metadata(hash)
         aws_compatible_metadata = normalize_active_storage_validations_metadata_for_aws(hash)
 
-        metadata['custom'] ||= {}
-        metadata['custom'].merge!(aws_compatible_metadata)
+        metadata["custom"] ||= {}
+        metadata["custom"].merge!(aws_compatible_metadata)
 
         active_storage_validations_metadata
       end
 
       def normalize_active_storage_validations_metadata_for_aws(hash)
-        hash.transform_keys { |key, _| key.to_s.start_with?('asv_') ? key : "asv_#{key}" }
+        hash.transform_keys { |key, _| key.to_s.start_with?("asv_") ? key : "asv_#{key}" }
             .transform_values(&:to_s)
       end
+
+      def remove_active_storage_validations_metadata!
+        metadata["custom"] ||= {}
+        metadata["custom"].delete_if { |key, _| key.to_s.start_with?("asv_") }
+      end
     end
+    # rubocop:enable Metrics/BlockLength
   end
 end

data/lib/active_storage_validations/extensors/asv_marcelable.rb

@@ -9,4 +9,4 @@ Marcel::MimeType.extend "text/xml", parents: %(application/xml) # alias
 Marcel::MimeType.extend "video/theora", parents: %(video/ogg)
 
 # Add empty content type
-Marcel::MimeType.extend "inode/x-empty", extensions: %w(empty)
+Marcel::MimeType.extend "inode/x-empty", extensions: %w[empty]

data/lib/active_storage_validations/limit_validator.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'shared/asv_active_storageable'
-require_relative 'shared/asv_errorable'
-require_relative 'shared/asv_optionable'
-require_relative 'shared/asv_symbolizable'
+require_relative "shared/asv_active_storageable"
+require_relative "shared/asv_errorable"
+require_relative "shared/asv_optionable"
+require_relative "shared/asv_symbolizable"
 
 module ActiveStorageValidations
   class LimitValidator < ActiveModel::EachValidator # :nodoc:
@@ -31,18 +31,8 @@ module ActiveStorageValidations
 
       return if files_count_valid?(count, flat_options)
 
-      errors_options = initialize_error_options(options)
-      errors_options[:min] = flat_options[:min]
-      errors_options[:max] = flat_options[:max]
-      errors_options[:count] = count
-      error_type = if flat_options[:min] && flat_options[:max]
-        :limit_out_of_range
-      elsif flat_options[:min] && count < flat_options[:min]
-        :limit_min_not_reached
-      else
-        :limit_max_exceeded
-      end
-
+      errors_options = initialize_and_populate_error_options(options, flat_options, count)
+      error_type = set_error_type(flat_options, count)
       add_error(record, attribute, error_type, **errors_options)
     end
 
@@ -60,15 +50,15 @@ module ActiveStorageValidations
 
     def ensure_at_least_one_validator_option
       unless AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-        raise ArgumentError, 'You must pass either :max or :min to the validator'
+        raise ArgumentError, "You must pass either :max or :min to the validator"
       end
     end
 
     def ensure_arguments_validity
       return true if min_max_are_proc? || min_or_max_is_proc_and_other_not_present?
 
-      raise ArgumentError, 'You must pass integers to :min and :max' if min_or_max_defined_and_not_integer?
-      raise ArgumentError, 'You must pass a higher value to :max than to :min' if min_higher_than_max?
+      raise ArgumentError, "You must pass integers to :min and :max" if min_or_max_defined_and_not_integer?
+      raise ArgumentError, "You must pass a higher value to :max than to :min" if min_higher_than_max?
     end
 
     def min_max_are_proc?
@@ -88,5 +78,23 @@ module ActiveStorageValidations
     def min_higher_than_max?
       options[:min] > options[:max] if options[:min].is_a?(Integer) && options[:max].is_a?(Integer)
     end
+
+    def initialize_and_populate_error_options(options, flat_options, count)
+      errors_options = initialize_error_options(options)
+      errors_options[:min] = flat_options[:min]
+      errors_options[:max] = flat_options[:max]
+      errors_options[:count] = count
+      errors_options
+    end
+
+    def set_error_type(flat_options, count)
+      if flat_options[:min] && flat_options[:max]
+        :limit_out_of_range
+      elsif flat_options[:min] && count < flat_options[:min]
+        :limit_min_not_reached
+      else
+        :limit_max_exceeded
+      end
+    end
   end
 end

data/lib/active_storage_validations/matchers/aspect_ratio_validator_matcher.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative 'shared/asv_active_storageable'
-require_relative 'shared/asv_allow_blankable'
-require_relative 'shared/asv_attachable'
-require_relative 'shared/asv_contextable'
-require_relative 'shared/asv_messageable'
-require_relative 'shared/asv_rspecable'
-require_relative 'shared/asv_validatable'
+require_relative "shared/asv_active_storageable"
+require_relative "shared/asv_allow_blankable"
+require_relative "shared/asv_attachable"
+require_relative "shared/asv_contextable"
+require_relative "shared/asv_messageable"
+require_relative "shared/asv_rspecable"
+require_relative "shared/asv_validatable"
 
 module ActiveStorageValidations
   module Matchers
@@ -101,17 +101,17 @@ module ActiveStorageValidations
 
       def valid_width_and_height_for(aspect_ratio)
         case aspect_ratio
-        when :square then [100, 100]
-        when :portrait then [100, 200]
-        when :landscape then [200, 100]
+        when :square then [ 100, 100 ]
+        when :portrait then [ 100, 200 ]
+        when :landscape then [ 200, 100 ]
         when validator_class::ASPECT_RATIO_REGEX
           aspect_ratio =~ validator_class::ASPECT_RATIO_REGEX
           x = Regexp.last_match(1).to_i
           y = Regexp.last_match(2).to_i
 
-          [100 * x, 100 * y]
+          [ 100 * x, 100 * y ]
         else
-          [-1, -1]
+          [ -1, -1 ]
         end
       end
     end