active_storage_validations 0.9.7 → 2.0.2

data/lib/active_storage_validations/limit_validator.rb

@@ -1,33 +1,92 @@
 # 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'
+
 module ActiveStorageValidations
   class LimitValidator < ActiveModel::EachValidator # :nodoc:
+    include ASVActiveStorageable
+    include ASVErrorable
+    include ASVOptionable
+    include ASVSymbolizable
+
     AVAILABLE_CHECKS = %i[max min].freeze
+    ERROR_TYPES = %i[
+      limit_out_of_range
+      limit_min_not_reached
+      limit_max_exceeded
+    ].freeze
 
     def check_validity!
-      return true if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-
-      raise ArgumentError, 'You must pass either :max or :min to the validator'
+      ensure_at_least_one_validator_option
+      ensure_arguments_validity
     end
 
-    def validate_each(record, attribute, _)
-      return true unless record.send(attribute).attached?
+    def validate_each(record, attribute, _value)
+      files = attached_files(record, attribute).reject(&:blank?)
+      flat_options = set_flat_options(record)
+      count = files.count
+
+      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
+
+      add_error(record, attribute, error_type, **errors_options)
+    end
 
-      files = Array.wrap(record.send(attribute)).compact.uniq
-      errors_options = { min: options[:min], max: options[:max] }
+    private
 
-      return true if files_count_valid?(files.count)
-      record.errors.add(attribute, options[:message].presence || :limit_out_of_range, **errors_options)
+    def files_count_valid?(count, flat_options)
+      if flat_options[:max].present? && flat_options[:min].present?
+        count >= flat_options[:min] && count <= flat_options[:max]
+      elsif flat_options[:max].present?
+        count <= flat_options[:max]
+      elsif flat_options[:min].present?
+        count >= flat_options[:min]
+      end
     end
 
-    def files_count_valid?(count)
-      if options[:max].present? && options[:min].present?
-        count >= options[:min] && count <= options[:max]
-      elsif options[:max].present?
-        count <= options[:max]
-      elsif options[:min].present?
-        count >= options[:min]
+    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'
       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?
+    end
+
+    def min_max_are_proc?
+      options[:min]&.is_a?(Proc) && options[:max]&.is_a?(Proc)
+    end
+
+    def min_or_max_is_proc_and_other_not_present?
+      (options[:min]&.is_a?(Proc) && options[:max].nil?) ||
+        (options[:min].nil? && options[:max]&.is_a?(Proc))
+    end
+
+    def min_or_max_defined_and_not_integer?
+      (options.key?(:min) && !options[:min].is_a?(Integer)) ||
+        (options.key?(:max) && !options[:max].is_a?(Integer))
+    end
+
+    def min_higher_than_max?
+      options[:min] > options[:max] if options[:min].is_a?(Integer) && options[:max].is_a?(Integer)
+    end
   end
 end

data/lib/active_storage_validations/matchers/aspect_ratio_validator_matcher.rb

@@ -0,0 +1,119 @@
+# 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'
+
+module ActiveStorageValidations
+  module Matchers
+    def validate_aspect_ratio_of(attribute_name)
+      AspectRatioValidatorMatcher.new(attribute_name)
+    end
+
+    class AspectRatioValidatorMatcher
+      include ASVActiveStorageable
+      include ASVAllowBlankable
+      include ASVAttachable
+      include ASVContextable
+      include ASVMessageable
+      include ASVRspecable
+      include ASVValidatable
+
+      def initialize(attribute_name)
+        initialize_allow_blankable
+        initialize_contextable
+        initialize_messageable
+        initialize_rspecable
+        @attribute_name = attribute_name
+        @allowed_aspect_ratios = @rejected_aspect_ratios = []
+      end
+
+      def description
+        "validate the aspect ratios allowed on :#{@attribute_name}."
+      end
+
+      def failure_message
+        "is expected to validate aspect ratio of :#{@attribute_name}"
+      end
+
+      def allowing(*aspect_ratios)
+        @allowed_aspect_ratios = aspect_ratios.flatten
+        self
+      end
+
+      def rejecting(*aspect_ratios)
+        @rejected_aspect_ratios = aspect_ratios.flatten
+        self
+      end
+
+      def matches?(subject)
+        @subject = subject.is_a?(Class) ? subject.new : subject
+
+        is_a_valid_active_storage_attribute? &&
+          is_context_valid? &&
+          is_allowing_blank? &&
+          is_custom_message_valid? &&
+          all_allowed_aspect_ratios_allowed? &&
+          all_rejected_aspect_ratios_rejected?
+      end
+
+      protected
+
+      def all_allowed_aspect_ratios_allowed?
+        @allowed_aspect_ratios_not_allowed ||= @allowed_aspect_ratios.reject { |aspect_ratio| aspect_ratio_allowed?(aspect_ratio) }
+        @allowed_aspect_ratios_not_allowed.empty?
+      end
+
+      def all_rejected_aspect_ratios_rejected?
+        @rejected_aspect_ratios_not_rejected ||= @rejected_aspect_ratios.select { |aspect_ratio| aspect_ratio_allowed?(aspect_ratio) }
+        @rejected_aspect_ratios_not_rejected.empty?
+      end
+
+      def aspect_ratio_allowed?(aspect_ratio)
+        width, height = valid_width_and_height_for(aspect_ratio)
+
+        mock_dimensions_for(attach_file, width, height) do
+          validate
+          detach_file
+          is_valid?
+        end
+      end
+
+      def is_custom_message_valid?
+        return true unless @custom_message
+
+        mock_dimensions_for(attach_file, -1, -1) do
+          validate
+          detach_file
+          has_an_error_message_which_is_custom_message?
+        end
+      end
+
+      def mock_dimensions_for(attachment, width, height)
+        Matchers.mock_metadata(attachment, { width: width, height: height }) do
+          yield
+        end
+      end
+
+      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 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]
+        else
+          [-1, -1]
+        end
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/attached_validator_matcher.rb

@@ -1,58 +1,81 @@
 # frozen_string_literal: true
 
+require_relative 'shared/asv_active_storageable'
+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
-    def validate_attached_of(name)
-      AttachedValidatorMatcher.new(name)
+    def validate_attached_of(attribute_name)
+      AttachedValidatorMatcher.new(attribute_name)
     end
 
     class AttachedValidatorMatcher
+      include ASVActiveStorageable
+      include ASVAttachable
+      include ASVContextable
+      include ASVMessageable
+      include ASVRspecable
+      include ASVValidatable
+
       def initialize(attribute_name)
+        initialize_contextable
+        initialize_messageable
+        initialize_rspecable
         @attribute_name = attribute_name
       end
 
       def description
-        "validate #{@attribute_name} must be attached"
+        "validate that :#{@attribute_name} must be attached"
+      end
+
+      def failure_message
+        "is expected to validate attachment of :#{@attribute_name}"
       end
 
       def matches?(subject)
         @subject = subject.is_a?(Class) ? subject.new : subject
-        responds_to_methods && valid_when_attached && invalid_when_not_attached
+
+        is_a_valid_active_storage_attribute? &&
+          is_context_valid? &&
+          is_custom_message_valid? &&
+          is_valid_when_file_attached? &&
+          is_invalid_when_file_not_attached?
       end
 
-      def failure_message
-        "is expected to validate attached of #{@attribute_name}"
+      private
+
+      def is_valid_when_file_attached?
+        attach_file unless file_attached?
+        validate
+        is_valid?
       end
 
-      def failure_message_when_negated
-        "is expected to not validate attached of #{@attribute_name}"
+      def is_invalid_when_file_not_attached?
+        detach_file if file_attached?
+        validate
+        !is_valid?
       end
 
-      private
+      def is_custom_message_valid?
+        return true unless @custom_message
 
-      def responds_to_methods
-        @subject.respond_to?(@attribute_name) &&
-          @subject.public_send(@attribute_name).respond_to?(:attach) &&
-          @subject.public_send(@attribute_name).respond_to?(:detach)
+        detach_file if file_attached?
+        validate
+        has_an_error_message_which_is_custom_message?
       end
 
-      def valid_when_attached
-        @subject.public_send(@attribute_name).attach(attachable) unless @subject.public_send(@attribute_name).attached?
-        @subject.validate
-        @subject.errors.details[@attribute_name].exclude?(error: :blank)
+      def file_attached?
+        @subject.public_send(@attribute_name).attached?
       end
 
-      def invalid_when_not_attached
+      def detach_file
         @subject.public_send(@attribute_name).detach
         # Unset the direct relation since `detach` on an unpersisted record does not set `attached?` to false.
         @subject.public_send("#{@attribute_name}=", nil)
-
-        @subject.validate
-        @subject.errors.details[@attribute_name].include?(error: :blank)
-      end
-
-      def attachable
-        { io: Tempfile.new('.'), filename: 'dummy.txt', content_type: 'text/plain' }
       end
     end
   end

data/lib/active_storage_validations/matchers/base_comparison_validator_matcher.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+# Big thank you to the paperclip validation matchers:
+# https://github.com/thoughtbot/paperclip/blob/v6.1.0/lib/paperclip/matchers/validate_attachment_size_matcher.rb
+
+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
+    class BaseComparisonValidatorMatcher
+      # BaseComparisonValidatorMatcher is an abstract class and shouldn't be instantiated directly.
+
+      include ASVActiveStorageable
+      include ASVAllowBlankable
+      include ASVAttachable
+      include ASVContextable
+      include ASVMessageable
+      include ASVRspecable
+      include ASVValidatable
+
+      def initialize(attribute_name)
+        initialize_allow_blankable
+        initialize_contextable
+        initialize_messageable
+        initialize_rspecable
+        @attribute_name = attribute_name
+        @min = @max = nil
+      end
+
+      def less_than(value)
+        @max = value - smallest_measurement
+        self
+      end
+
+      def less_than_or_equal_to(value)
+        @max = value
+        self
+      end
+
+      def greater_than(value)
+        @min = value + smallest_measurement
+        self
+      end
+
+      def greater_than_or_equal_to(value)
+        @min = value
+        self
+      end
+
+      def between(range)
+        @min, @max = range.first, range.last
+        self
+      end
+
+      def matches?(subject)
+        @subject = subject.is_a?(Class) ? subject.new : subject
+
+        is_a_valid_active_storage_attribute? &&
+          is_context_valid? &&
+          is_allowing_blank? &&
+          is_custom_message_valid? &&
+          not_lower_than_min? &&
+          higher_than_min? &&
+          lower_than_max? &&
+          not_higher_than_max?
+      end
+
+      protected
+
+      def build_failure_message(message)
+        return unless @failure_message_artefacts.present?
+
+        message << "  but there seem to have issues with the matcher methods you used, since:"
+        @failure_message_artefacts.each do |error_case|
+          message << "  validation failed when provided with a #{error_case[:value]} #{failure_message_unit} test file"
+        end
+        message << "  whereas it should have passed"
+      end
+
+      def failure_message_unit
+        raise NotImplementedError
+      end
+
+      def not_lower_than_min?
+        @min.nil? || !passes_validation_with_value(@min - 1)
+      end
+
+      def higher_than_min?
+        @min.nil? || passes_validation_with_value(@min + 1)
+      end
+
+      def lower_than_max?
+        @max.nil? || @max == Float::INFINITY || passes_validation_with_value(@max - 1)
+      end
+
+      def not_higher_than_max?
+        @max.nil? || @max == Float::INFINITY || !passes_validation_with_value(@max + 1)
+      end
+
+      def smallest_measurement
+        raise NotImplementedError
+      end
+
+      def passes_validation_with_value(value)
+        mock_value_for(io, value) do
+          attach_file
+          validate
+          detach_file
+          is_valid? || add_failure_message_artefact(value)
+        end
+      end
+
+      def add_failure_message_artefact(value)
+        @failure_message_artefacts << { value: value }
+        false
+      end
+
+      def is_custom_message_valid?
+        return true unless @custom_message
+
+        mock_value_for(io, -smallest_measurement) do
+          attach_file
+          validate
+          detach_file
+          has_an_error_message_which_is_custom_message?
+        end
+      end
+
+      def mock_value_for(io, size)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/content_type_validator_matcher.rb

@@ -2,109 +2,144 @@
 
 # Big thank you to the paperclip validation matchers:
 # https://github.com/thoughtbot/paperclip/blob/v6.1.0/lib/paperclip/matchers/validate_attachment_content_type_matcher.rb
+
+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
-    def validate_content_type_of(name)
-      ContentTypeValidatorMatcher.new(name)
+    def validate_content_type_of(attribute_name)
+      ContentTypeValidatorMatcher.new(attribute_name)
     end
 
     class ContentTypeValidatorMatcher
+      include ASVActiveStorageable
+      include ASVAllowBlankable
+      include ASVAttachable
+      include ASVContextable
+      include ASVMessageable
+      include ASVRspecable
+      include ASVValidatable
+
       def initialize(attribute_name)
+        initialize_allow_blankable
+        initialize_contextable
+        initialize_messageable
+        initialize_rspecable
         @attribute_name = attribute_name
+        @allowed_content_types = @rejected_content_types = []
       end
 
       def description
-        "validate the content types allowed on attachment #{@attribute_name}"
+        "validate the content types allowed on :#{@attribute_name}"
+      end
+
+      def failure_message
+        message = ["is expected to validate the content types of :#{@attribute_name}"]
+        build_failure_message(message)
+        message.join("\n")
       end
 
-      def allowing(*types)
-        @allowed_types = types.flatten
+      def allowing(*content_types)
+        @allowed_content_types = content_types.map { |content_type| normalize_content_type(content_type) }.flatten
         self
       end
 
-      def rejecting(*types)
-        @rejected_types = types.flatten
+      def rejecting(*content_types)
+        @rejected_content_types = content_types.map { |content_type| normalize_content_type(content_type) }.flatten
         self
       end
 
       def matches?(subject)
         @subject = subject.is_a?(Class) ? subject.new : subject
-        responds_to_methods && allowed_types_allowed? && rejected_types_rejected?
-      end
-
-      def failure_message
-        <<~MESSAGE
-          Expected #{@attribute_name}
 
-            Accept content types: #{allowed_types.join(", ")}
-              #{accepted_types_and_failures}
-
-            Reject content types: #{rejected_types.join(", ")}
-              #{rejected_types_and_failures}
-        MESSAGE
+        is_a_valid_active_storage_attribute? &&
+          is_context_valid? &&
+          is_allowing_blank? &&
+          is_custom_message_valid? &&
+          all_allowed_content_types_allowed? &&
+          all_rejected_content_types_rejected?
       end
 
       protected
 
-      def responds_to_methods
-        @subject.respond_to?(@attribute_name) &&
-          @subject.public_send(@attribute_name).respond_to?(:attach) &&
-          @subject.public_send(@attribute_name).respond_to?(:detach)
+      def build_failure_message(message)
+        if @allowed_content_types_not_allowed.present?
+          message << "  the following content type#{'s' if @allowed_content_types.count > 1} should be allowed: :#{@allowed_content_types.join(", :")}"
+          message << "  but #{pluralize(@allowed_content_types_not_allowed)} rejected"
+        end
+
+        if @rejected_content_types_not_rejected.present?
+          message << "  the following content type#{'s' if @rejected_content_types.count > 1} should be rejected: :#{@rejected_content_types.join(", :")}"
+          message << "  but #{pluralize(@rejected_content_types_not_rejected)} accepted"
+        end
       end
 
-      def allowed_types
-        @allowed_types || []
+      def pluralize(types)
+        if types.count == 1
+          ":#{types[0]} was"
+        else
+          ":#{types.join(", :")} were"
+        end
       end
 
-      def rejected_types
-        @rejected_types || (content_type_keys - allowed_types)
+      def normalize_content_type(content_type)
+        Marcel::MimeType.for(declared_type: content_type.to_s, extension: content_type.to_s)
       end
 
-      def allowed_types_allowed?
-        @missing_allowed_types ||= allowed_types.reject { |type| type_allowed?(type) }
-        @missing_allowed_types.none?
+      def all_allowed_content_types_allowed?
+        @allowed_content_types_not_allowed ||= @allowed_content_types.reject { |type| type_allowed?(type) }
+        @allowed_content_types_not_allowed.empty?
       end
 
-      def rejected_types_rejected?
-        @missing_rejected_types ||= rejected_types.select { |type| type_allowed?(type) }
-        @missing_rejected_types.none?
+      def all_rejected_content_types_rejected?
+        @rejected_content_types_not_rejected ||= @rejected_content_types.select { |type| type_allowed?(type) }
+        @rejected_content_types_not_rejected.empty?
       end
 
-      def accepted_types_and_failures
-        if @missing_allowed_types.present?
-          "#{@missing_allowed_types.join(", ")} were rejected."
-        else
-          "All were accepted successfully."
-        end
+      def type_allowed?(content_type)
+        attach_file_with_content_type(content_type)
+        validate
+        detach_file
+        is_valid?
       end
 
-      def rejected_types_and_failures
-        if @missing_rejected_types.present?
-          "#{@missing_rejected_types.join(", ")} were accepted."
-        else
-          "All were rejected successfully."
-        end
+      def attach_file_with_content_type(content_type)
+        @subject.public_send(@attribute_name).attach(attachment_for(content_type))
       end
 
-      def type_allowed?(type)
-        @subject.public_send(@attribute_name).attach(attachment_for(type))
-        @subject.validate
-        @subject.errors.details[@attribute_name].all? { |error| error[:error] != :content_type_invalid }
+      def is_custom_message_valid?
+        return true unless @custom_message
+
+        attach_invalid_content_type_file
+        validate
+        has_an_error_message_which_is_custom_message?
       end
 
-      def attachment_for(type)
-        suffix = type.to_s.split('/').last
-        { io: Tempfile.new('.'), filename: "test.#{suffix}", content_type: type }
+      def attach_invalid_content_type_file
+        @subject.public_send(@attribute_name).attach(attachment_for('fake/fake'))
       end
 
-      private
+      def attachment_for(content_type)
+        suffix = Marcel::TYPE_EXTS[content_type.to_s]&.first || 'fake'
 
-      def content_type_keys
-        if Rails.gem_version < Gem::Version.new('6.1.0')
-          Mime::LOOKUP.keys
-        else
-          Marcel::TYPES.keys
-        end
+        {
+          io: Tempfile.new('.'),
+          filename: "test.#{suffix}",
+          content_type: content_type
+        }
+      end
+
+      # Due to the way we build test attachments in #attachment_for
+      # (ie spoofed file basically), we need to ignore the error related to
+      # content type spoofing in our matcher to pass the tests
+      def validator_errors_for_attribute
+        super.reject { |hash| hash[:error] == :content_type_spoofed }
       end
     end
   end