active_storage_validations 1.1.2 → 1.1.4

data/lib/active_storage_validations/dimension_validator.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
+require_relative 'concerns/errorable.rb'
 require_relative 'concerns/symbolizable.rb'
 require_relative 'metadata.rb'
 
 module ActiveStorageValidations
   class DimensionValidator < ActiveModel::EachValidator # :nodoc
     include OptionProcUnfolding
-    include ErrorHandler
+    include Errorable
     include Symbolizable
 
     AVAILABLE_CHECKS = %i[width height min max].freeze
@@ -46,7 +47,6 @@ module ActiveStorageValidations
       flat_options
     end
 
-
     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'
@@ -64,7 +64,7 @@ module ActiveStorageValidations
         files = Array.wrap(changes.is_a?(ActiveStorage::Attached::Changes::CreateMany) ? changes.attachables : changes.attachable)
         files.each do |file|
           metadata = Metadata.new(file).metadata
-          next if is_valid?(record, attribute, metadata)
+          next if is_valid?(record, attribute, file, metadata)
           break
         end
       end
@@ -78,19 +78,19 @@ module ActiveStorageValidations
           # Analyze file first if not analyzed to get all required metadata.
           file.analyze; file.reload unless file.analyzed?
           metadata = file.metadata rescue {}
-          next if is_valid?(record, attribute, metadata)
+          next if is_valid?(record, attribute, file, metadata)
           break
         end
       end
     end
 
 
-    def is_valid?(record, attribute, file_metadata)
+    def is_valid?(record, attribute, file, metadata)
       flat_options = process_options(record)
-      errors_options = initialize_error_options(options)
+      errors_options = initialize_error_options(options, file)
 
       # Validation fails unless file metadata contains valid width and height.
-      if file_metadata[:width].to_i <= 0 || file_metadata[:height].to_i <= 0
+      if metadata[:width].to_i <= 0 || metadata[:height].to_i <= 0
         add_error(record, attribute, :image_metadata_missing, **errors_options)
         return false
       end
@@ -98,8 +98,8 @@ module ActiveStorageValidations
       # 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] && file_metadata[:width] < flat_options[:width][:min]) ||
-          (flat_options[:height][:min] && file_metadata[:height] < flat_options[:height][: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]
@@ -108,8 +108,8 @@ module ActiveStorageValidations
           return false
         end
         if flat_options[:max] && (
-          (flat_options[:width][:max] && file_metadata[:width] > flat_options[:width][:max]) ||
-          (flat_options[:height][:max] && file_metadata[:height] > flat_options[:height][: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]
@@ -125,7 +125,7 @@ module ActiveStorageValidations
         [:width, :height].each do |length|
           next unless flat_options[length]
           if flat_options[length].is_a?(Hash)
-            if flat_options[length][:in] && (file_metadata[length] < flat_options[length][:min] || file_metadata[length] > flat_options[length][:max])
+            if flat_options[length][:in] && (metadata[length] < flat_options[length][:min] || metadata[length] > flat_options[length][:max])
               error_type = :"dimension_#{length}_inclusion"
               errors_options[:min] = flat_options[length][:min]
               errors_options[:max] = flat_options[length][:max]
@@ -133,13 +133,13 @@ module ActiveStorageValidations
               add_error(record, attribute, error_type, **errors_options)
               width_or_height_invalid = true
             else
-              if flat_options[length][:min] && file_metadata[length] < flat_options[length][:min]
+              if flat_options[length][:min] && metadata[length] < flat_options[length][:min]
                 error_type = :"dimension_#{length}_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] && file_metadata[length] > flat_options[length][:max]
+              elsif flat_options[length][:max] && metadata[length] > flat_options[length][:max]
                 error_type = :"dimension_#{length}_less_than_or_equal_to"
                 errors_options[:length] = flat_options[length][:max]
 
@@ -148,7 +148,7 @@ module ActiveStorageValidations
               end
             end
           else
-            if file_metadata[length] != flat_options[length]
+            if metadata[length] != flat_options[length]
               error_type = :"dimension_#{length}_equal_to"
               errors_options[:length] = flat_options[length]
 

data/lib/active_storage_validations/limit_validator.rb

@@ -1,32 +1,38 @@
 # frozen_string_literal: true
 
+require_relative 'concerns/errorable.rb'
 require_relative 'concerns/symbolizable.rb'
 
 module ActiveStorageValidations
   class LimitValidator < ActiveModel::EachValidator # :nodoc:
     include OptionProcUnfolding
-    include ErrorHandler
+    include Errorable
     include Symbolizable
 
     AVAILABLE_CHECKS = %i[max min].freeze
+    ERROR_TYPES = %i[
+      limit_out_of_range
+    ].freeze
 
     def check_validity!
-      unless AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-        raise ArgumentError, 'You must pass either :max or :min to the validator'
-      end
+      ensure_at_least_one_validator_option
+      ensure_arguments_validity
     end
 
     def validate_each(record, attribute, _)
       files = Array.wrap(record.send(attribute)).reject { |file| file.blank? }.compact.uniq
       flat_options = unfold_procs(record, self.options, AVAILABLE_CHECKS)
+
+      return true if files_count_valid?(files.count, flat_options)
+
       errors_options = initialize_error_options(options)
       errors_options[:min] = flat_options[:min]
       errors_options[:max] = flat_options[:max]
-
-      return true if files_count_valid?(files.count, flat_options)
-      add_error(record, attribute, :limit_out_of_range, **errors_options)
+      add_error(record, attribute, ERROR_TYPES.first, **errors_options)
     end
 
+    private
+
     def files_count_valid?(count, flat_options)
       if flat_options[:max].present? && flat_options[:min].present?
         count >= flat_options[:min] && count <= flat_options[:max]
@@ -36,5 +42,36 @@ module ActiveStorageValidations
         count >= flat_options[:min]
       end
     end
+
+    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,128 @@
+# frozen_string_literal: true
+
+require_relative 'concerns/active_storageable.rb'
+require_relative 'concerns/allow_blankable.rb'
+require_relative 'concerns/contextable.rb'
+require_relative 'concerns/messageable.rb'
+require_relative 'concerns/rspecable.rb'
+require_relative 'concerns/validatable.rb'
+
+module ActiveStorageValidations
+  module Matchers
+    def validate_aspect_ratio_of(name, expected_aspect_ratio)
+      AspectRatioValidatorMatcher.new(name, expected_aspect_ratio)
+    end
+
+    class AspectRatioValidatorMatcher
+      include ActiveStorageable
+      include AllowBlankable
+      include Contextable
+      include Messageable
+      include Rspecable
+      include Validatable
+
+      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
+          is_valid?
+        end
+      end
+
+      def is_custom_message_valid?
+        return true unless @custom_message
+
+        mock_dimensions_for(attach_file, -1, -1) do
+          validate
+          has_an_error_message_which_is_custom_message?
+        end
+      end
+
+      def attach_file
+        @subject.public_send(@attribute_name).attach(dummy_file)
+        @subject.public_send(@attribute_name)
+      end
+
+      def dummy_file
+        {
+          io: Tempfile.new('Hello world!'),
+          filename: 'test.png',
+          content_type: 'image/png'
+        }
+      end
+
+      def mock_dimensions_for(attachment, width, height)
+        Matchers.mock_metadata(attachment, width, 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,5 +1,9 @@
 # frozen_string_literal: true
 
+require_relative 'concerns/active_storageable.rb'
+require_relative 'concerns/contextable.rb'
+require_relative 'concerns/messageable.rb'
+require_relative 'concerns/rspecable.rb'
 require_relative 'concerns/validatable.rb'
 
 module ActiveStorageValidations
@@ -9,46 +13,39 @@ module ActiveStorageValidations
     end
 
     class AttachedValidatorMatcher
+      include ActiveStorageable
+      include Contextable
+      include Messageable
+      include Rspecable
       include Validatable
 
       def initialize(attribute_name)
+        initialize_contextable
+        initialize_messageable
+        initialize_rspecable
         @attribute_name = attribute_name
-        @custom_message = nil
       end
 
       def description
-        "validate #{@attribute_name} must be attached"
+        "validate that :#{@attribute_name} must be attached"
       end
 
-      def with_message(message)
-        @custom_message = message
-        self
+      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 &&
-          is_valid_when_file_attached? &&
-          is_invalid_when_file_not_attached? &&
-          validate_custom_message?
-      end
 
-      def failure_message
-        "is expected to validate attached of #{@attribute_name}"
-      end
-
-      def failure_message_when_negated
-        "is expected to not validate attached of #{@attribute_name}"
+        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
 
       private
 
-      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)
-      end
-
       def is_valid_when_file_attached?
         attach_dummy_file unless file_attached?
         validate
@@ -61,7 +58,7 @@ module ActiveStorageValidations
         !is_valid?
       end
 
-      def validate_custom_message?
+      def is_custom_message_valid?
         return true unless @custom_message
 
         detach_file if file_attached?

data/lib/active_storage_validations/matchers/concerns/active_storageable.rb

@@ -0,0 +1,17 @@
+require "active_support/concern"
+
+module ActiveStorageValidations
+  module Matchers
+    module ActiveStorageable
+      extend ActiveSupport::Concern
+
+      private
+
+      def is_a_valid_active_storage_attribute?
+        @subject.respond_to?(@attribute_name) &&
+          @subject.public_send(@attribute_name).respond_to?(:attach) &&
+          @subject.public_send(@attribute_name).respond_to?(:detach)
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/concerns/allow_blankable.rb

@@ -0,0 +1,26 @@
+require "active_support/concern"
+
+module ActiveStorageValidations
+  module Matchers
+    module AllowBlankable
+      extend ActiveSupport::Concern
+
+      def initialize_allow_blankable
+        @allow_blank = nil
+      end
+
+      def allow_blank
+        @allow_blank = true
+        self
+      end
+
+      private
+
+      def is_allowing_blank?
+        return true unless @allow_blank
+
+        validate
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/concerns/contextable.rb

@@ -0,0 +1,35 @@
+require "active_support/concern"
+
+module ActiveStorageValidations
+  module Matchers
+    module Contextable
+      extend ActiveSupport::Concern
+
+      def initialize_contextable
+        @context = nil
+      end
+
+      def on(context)
+        @context = context
+        self
+      end
+
+      private
+
+      def is_context_valid?
+        return true if !@context && !(attribute_validator && attribute_validator.options[:on])
+
+        raise ArgumentError, "This validator matcher needs the #on option to work since its validator has one" if !@context
+        raise ArgumentError, "This validator matcher option only allows a symbol or an array" if !(@context.is_a?(Symbol) || @context.is_a?(Array))
+
+        if @context.is_a?(Array) && attribute_validator.options[:on].is_a?(Array)
+          @context.to_set == attribute_validator.options[:on].to_set
+        elsif @context.is_a?(Symbol) && attribute_validator.options[:on].is_a?(Symbol)
+          @context == attribute_validator.options[:on]
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/concerns/messageable.rb

@@ -0,0 +1,26 @@
+require "active_support/concern"
+
+module ActiveStorageValidations
+  module Matchers
+    module Messageable
+      extend ActiveSupport::Concern
+
+      def initialize_messageable
+        @custom_message = nil
+      end
+
+      def with_message(custom_message)
+        @custom_message = custom_message
+        self
+      end
+
+      private
+
+      def has_an_error_message_which_is_custom_message?
+        validator_errors_for_attribute.one? do |error|
+          error[:error] == @custom_message
+        end
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/concerns/rspecable.rb

@@ -0,0 +1,25 @@
+require "active_support/concern"
+
+module ActiveStorageValidations
+  module Matchers
+    module Rspecable
+      extend ActiveSupport::Concern
+
+      def initialize_rspecable
+        @failure_message_artefacts = []
+      end
+
+      def description
+        raise NotImplementedError, "#{self.class} did not define #{__method__}"
+      end
+
+      def failure_message
+        raise NotImplementedError, "#{self.class} did not define #{__method__}"
+      end
+
+      def failure_message_when_negated
+        failure_message.sub(/is expected to validate/, 'is expected not to validate')
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/concerns/validatable.rb

@@ -1,46 +1,48 @@
-module Validatable
-  extend ActiveSupport::Concern
-
-  private
-
-  def validate
-    @subject.validate
-  end
-
-  def validator_errors_for_attribute
-    @subject.errors.details[@attribute_name].select do |error|
-      error[:validator_type] == validator_class.to_sym
-    end
-  end
-
-  def is_valid?
-    validator_errors_for_attribute.none? do |error|
-      error[:error].in?(available_errors)
-    end
-  end
-
-  def available_errors
-    [
-      *validator_class::ERROR_TYPES,
-      *error_from_custom_message
-    ].compact
-  end
-
-  def validator_class
-    self.class.name.gsub(/::Matchers|Matcher/, '').constantize
-  end
-
-  def error_from_custom_message
-    associated_validation = @subject.class.validators_on(@attribute_name).find do |validator|
-      validator.class == validator_class
-    end
-
-    associated_validation.options[:message]
-  end
-
-  def has_an_error_message_which_is_custom_message?
-    validator_errors_for_attribute.one? do |error|
-      error[:error] == @custom_message
+require "active_support/concern"
+
+module ActiveStorageValidations
+  module Matchers
+    module Validatable
+      extend ActiveSupport::Concern
+
+      private
+
+      def validate
+        @subject.validate(@context)
+      end
+
+      def validator_errors_for_attribute
+        @subject.errors.details[@attribute_name].select do |error|
+          error[:validator_type] == validator_class.to_sym
+        end
+      end
+
+      def is_valid?
+        validator_errors_for_attribute.none? do |error|
+          error[:error].in?(available_errors)
+        end
+      end
+
+      def available_errors
+        [
+          *validator_class::ERROR_TYPES,
+          *error_from_custom_message
+        ].compact
+      end
+
+      def validator_class
+        self.class.name.gsub(/::Matchers|Matcher/, '').constantize
+      end
+
+      def attribute_validator
+        @subject.class.validators_on(@attribute_name).find do |validator|
+          validator.class == validator_class
+        end
+      end
+
+      def error_from_custom_message
+        attribute_validator.options[:message]
+      end
     end
   end
 end