active_storage_validations 1.3.5 → 2.0.0

data/lib/active_storage_validations/{base_size_validator.rb → base_comparison_validator.rb}

@@ -6,14 +6,12 @@ require_relative 'shared/asv_optionable'
 require_relative 'shared/asv_symbolizable'
 
 module ActiveStorageValidations
-  class BaseSizeValidator < ActiveModel::EachValidator # :nodoc:
+  class BaseComparisonValidator < ActiveModel::EachValidator # :nodoc:
     include ASVActiveStorageable
     include ASVErrorable
     include ASVOptionable
     include ASVSymbolizable
 
-    delegate :number_to_human_size, to: ActiveSupport::NumberHelper
-
     AVAILABLE_CHECKS = %i[
       less_than
       less_than_or_equal_to
@@ -23,8 +21,8 @@ module ActiveStorageValidations
     ].freeze
 
     def initialize(*args)
-      if self.class == BaseSizeValidator
-        raise NotImplementedError, 'BaseSizeValidator is an abstract class and cannot be instantiated directly.'
+      if self.class == BaseComparisonValidator
+        raise NotImplementedError, 'BaseComparisonValidator is an abstract class and cannot be instantiated directly.'
       end
       super
     end
@@ -37,32 +35,36 @@ module ActiveStorageValidations
 
     private
 
-    def is_valid?(size, flat_options)
-      return false if size < 0
+    def is_valid?(value, flat_options)
+      return false if value < 0
 
       if flat_options[:between].present?
-        flat_options[:between].include?(size)
+        flat_options[:between].include?(value)
       elsif flat_options[:less_than].present?
-        size < flat_options[:less_than]
+        value < flat_options[:less_than]
       elsif flat_options[:less_than_or_equal_to].present?
-        size <= flat_options[:less_than_or_equal_to]
+        value <= flat_options[:less_than_or_equal_to]
       elsif flat_options[:greater_than].present?
-        size > flat_options[:greater_than]
+        value > flat_options[:greater_than]
       elsif flat_options[:greater_than_or_equal_to].present?
-        size >= flat_options[:greater_than_or_equal_to]
+        value >= flat_options[:greater_than_or_equal_to]
       end
     end
 
     def populate_error_options(errors_options, flat_options)
-      errors_options[:min_size] = number_to_human_size(min_size(flat_options))
-      errors_options[:max_size] = number_to_human_size(max_size(flat_options))
+      errors_options[:min] = format_bound_value(min(flat_options))
+      errors_options[:max] = format_bound_value(max(flat_options))
+    end
+
+    def format_bound_value
+      raise NotImplementedError
     end
 
-    def min_size(flat_options)
+    def min(flat_options)
       flat_options[:between]&.min || flat_options[:greater_than] || flat_options[:greater_than_or_equal_to]
     end
 
-    def max_size(flat_options)
+    def max(flat_options)
       flat_options[:between]&.max || flat_options[:less_than] || flat_options[:less_than_or_equal_to]
     end
   end

data/lib/active_storage_validations/content_type_validator.rb

@@ -6,7 +6,7 @@ require_relative 'shared/asv_attachable'
 require_relative 'shared/asv_errorable'
 require_relative 'shared/asv_optionable'
 require_relative 'shared/asv_symbolizable'
-require_relative 'content_type_spoof_detector'
+require_relative 'analyzer/content_type_analyzer'
 
 module ActiveStorageValidations
   class ContentTypeValidator < ActiveModel::EachValidator # :nodoc:
@@ -20,8 +20,9 @@ module ActiveStorageValidations
     AVAILABLE_CHECKS = %i[with in].freeze
     ERROR_TYPES = %i[
       content_type_invalid
-      spoofed_content_type
+      content_type_spoofed
     ].freeze
+    METADATA_KEYS = %i[content_type].freeze
 
     def check_validity!
       ensure_exactly_one_validator_option
@@ -34,9 +35,9 @@ module ActiveStorageValidations
       @authorized_content_types = authorized_content_types_from_options(record)
       return if @authorized_content_types.empty?
 
-      attachables_from_changes(record, attribute).each do |attachable|
-        set_attachable_cached_values(attachable)
-        is_valid?(record, attribute, attachable)
+      attachables_and_blobs(record, attribute).each do |attachable, blob|
+        set_attachable_cached_values(blob)
+        is_valid?(record, attribute, attachable, blob)
       end
     end
 
@@ -53,16 +54,16 @@ module ActiveStorageValidations
       end
     end
 
-    def set_attachable_cached_values(attachable)
-      @attachable_content_type = attachable_content_type_rails_like(attachable)
-      @attachable_filename = attachable_filename(attachable).to_s
+    def set_attachable_cached_values(blob)
+      @attachable_content_type = blob.content_type
+      @attachable_filename = blob.filename.to_s
     end
 
     # Check if the provided content_type is authorized and not spoofed against
     # the file io.
-    def is_valid?(record, attribute, attachable)
+    def is_valid?(record, attribute, attachable, blob)
       authorized_content_type?(record, attribute, attachable) &&
-        not_spoofing_content_type?(record, attribute, attachable)
+        not_spoofing_content_type?(record, attribute, attachable, blob)
     end
 
     # Dead code that we keep here for some time, maybe we will find a solution
@@ -100,11 +101,19 @@ module ActiveStorageValidations
       false
     end
 
-    def not_spoofing_content_type?(record, attribute, attachable)
+    def marcel_attachable_content_type(attachable)
+      Marcel::MimeType.for(declared_type: @attachable_content_type, name: @attachable_filename)
+    end
+
+    def not_spoofing_content_type?(record, attribute, attachable, blob)
       return true unless enable_spoofing_protection?
 
-      if ContentTypeSpoofDetector.new(record, attribute, attachable).spoofed?
-        errors_options = initialize_error_options(options, attachable)
+      @detected_content_type = metadata_for(blob, attachable, METADATA_KEYS)&.fetch(:content_type, nil)
+
+      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
       else
@@ -112,19 +121,40 @@ module ActiveStorageValidations
       end
     end
 
-    def marcel_attachable_content_type(attachable)
-      Marcel::MimeType.for(declared_type: @attachable_content_type, name: @attachable_filename)
+    def disable_spoofing_protection?
+      !enable_spoofing_protection?
     end
 
     def enable_spoofing_protection?
       options[:spoofing_protection] == true
     end
 
+    def attachable_content_type_vs_detected_content_type_mismatch?
+      @attachable_content_type.present? &&
+        !attachable_content_type_intersects_detected_content_type?
+    end
+
+    def attachable_content_type_intersects_detected_content_type?
+      # Ruby intersects? method is only available from 3.1
+      enlarged_content_type(content_type_without_parameters(@attachable_content_type)).any? do |item|
+        enlarged_content_type(content_type_without_parameters(@detected_content_type)).include?(item)
+      end
+    end
+
+    def enlarged_content_type(content_type)
+      [content_type, *parent_content_types(content_type)].compact.uniq
+    end
+
+    def parent_content_types(content_type)
+      Marcel::TYPE_PARENTS[content_type] || []
+    end
+
     def initialize_and_populate_error_options(options, attachable)
       errors_options = initialize_error_options(options, attachable)
       errors_options[:content_type] = @attachable_content_type
       errors_options[:human_content_type] = content_type_to_human_format(@attachable_content_type)
-      errors_options[:authorized_types] = content_type_to_human_format(@authorized_content_types)
+      errors_options[:authorized_human_content_types] = content_type_to_human_format(@authorized_content_types)
+      errors_options[:count] = @authorized_content_types.size
       errors_options
     end
 
@@ -152,7 +182,7 @@ module ActiveStorageValidations
     def ensure_content_types_validity
       return true if options[:with]&.is_a?(Proc) || options[:in]&.is_a?(Proc)
 
-      ([options[:with]] || options[:in]).each do |content_type|
+      (Array(options[:with]) + Array(options[:in])).each do |content_type|
         raise ArgumentError, invalid_content_type_option_message(content_type) if invalid_option?(content_type)
       end
     end
@@ -181,6 +211,10 @@ module ActiveStorageValidations
     end
 
     def invalid_content_type?(content_type)
+      if content_type == 'image/jpg'
+        raise ArgumentError, "'image/jpg' is not a valid content type, you should use 'image/jpeg' instead"
+      end
+
       Marcel::TYPE_EXTS[content_type.to_s] == nil
     end
 

data/lib/active_storage_validations/dimension_validator.rb

@@ -18,18 +18,19 @@ module ActiveStorageValidations
 
     AVAILABLE_CHECKS = %i[width height min max].freeze
     ERROR_TYPES = %i[
-      image_metadata_missing
-      dimension_min_inclusion
-      dimension_max_inclusion
-      dimension_width_inclusion
-      dimension_height_inclusion
-      dimension_width_greater_than_or_equal_to
-      dimension_height_greater_than_or_equal_to
-      dimension_width_less_than_or_equal_to
-      dimension_height_less_than_or_equal_to
-      dimension_width_equal_to
-      dimension_height_equal_to
+      dimension_min_not_included_in
+      dimension_max_not_included_in
+      dimension_width_not_included_in
+      dimension_height_not_included_in
+      dimension_width_not_greater_than_or_equal_to
+      dimension_height_not_greater_than_or_equal_to
+      dimension_width_not_less_than_or_equal_to
+      dimension_height_not_less_than_or_equal_to
+      dimension_width_not_equal_to
+      dimension_height_not_equal_to
+      media_metadata_missing
     ].freeze
+    METADATA_KEYS = %i[width height].freeze
 
     def check_validity!
       unless AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
@@ -40,7 +41,7 @@ module ActiveStorageValidations
     def validate_each(record, attribute, _value)
       return if no_attachments?(record, attribute)
 
-      validate_changed_files_from_metadata(record, attribute)
+      validate_changed_files_from_metadata(record, attribute, METADATA_KEYS)
     end
 
     private
@@ -51,7 +52,7 @@ module ActiveStorageValidations
 
       # 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, :image_metadata_missing, **errors_options)
+        add_error(record, attribute, :media_metadata_missing, **errors_options)
         return false
       end
 
@@ -64,7 +65,7 @@ module ActiveStorageValidations
           errors_options[:width] = flat_options[:width][:min]
           errors_options[:height] = flat_options[:height][:min]
 
-          add_error(record, attribute, :dimension_min_inclusion, **errors_options)
+          add_error(record, attribute, :dimension_min_not_included_in, **errors_options)
           return false
         end
         if flat_options[:max] && (
@@ -74,7 +75,7 @@ module ActiveStorageValidations
           errors_options[:width] = flat_options[:width][:max]
           errors_options[:height] = flat_options[:height][:max]
 
-          add_error(record, attribute, :dimension_max_inclusion, **errors_options)
+          add_error(record, attribute, :dimension_max_not_included_in, **errors_options)
           return false
         end
 
@@ -86,7 +87,7 @@ module ActiveStorageValidations
           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}_inclusion"
+              error_type = :"dimension_#{length}_not_included_in"
               errors_options[:min] = flat_options[length][:min]
               errors_options[:max] = flat_options[length][:max]
 
@@ -94,13 +95,13 @@ module ActiveStorageValidations
               width_or_height_invalid = true
             else
               if flat_options[length][:min] && metadata[length] < flat_options[length][:min]
-                error_type = :"dimension_#{length}_greater_than_or_equal_to"
+                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}_less_than_or_equal_to"
+                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)
@@ -109,7 +110,7 @@ module ActiveStorageValidations
             end
           else
             if metadata[length] != flat_options[length]
-              error_type = :"dimension_#{length}_equal_to"
+              error_type = :"dimension_#{length}_not_equal_to"
               errors_options[:length] = flat_options[length]
 
               add_error(record, attribute, error_type, **errors_options)

data/lib/active_storage_validations/duration_validator.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative 'base_comparison_validator'
+
+module ActiveStorageValidations
+  class DurationValidator < BaseComparisonValidator
+    include ASVAnalyzable
+    include ASVAttachable
+
+    ERROR_TYPES = %i[
+      duration_not_less_than
+      duration_not_less_than_or_equal_to
+      duration_not_greater_than
+      duration_not_greater_than_or_equal_to
+      duration_not_between
+    ].freeze
+    METADATA_KEYS = %i[duration].freeze
+
+    def validate_each(record, attribute, _value)
+      return if no_attachments?(record, attribute)
+
+      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)
+
+        if duration.to_i <= 0
+          errors_options = initialize_error_options(options, attachable)
+          add_error(record, attribute, :media_metadata_missing, **errors_options)
+          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)
+      end
+    end
+
+    private
+
+    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
+  end
+end

data/lib/active_storage_validations/extensors/asv_blob_metadatable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  module ASVBlobMetadatable
+    extend ActiveSupport::Concern
+
+    included do
+      def active_storage_validations_metadata
+        metadata.dig('custom', 'active_storage_validations') || {}
+      end
+
+      def active_storage_validations_metadata=(value)
+        metadata['custom'] ||= {}
+        metadata['custom']['active_storage_validations'] = value
+      end
+
+      def merge_into_active_storage_validations_metadata(new_data)
+        metadata['custom'] ||= {}
+        metadata['custom']['active_storage_validations'] ||= {}
+        metadata['custom']['active_storage_validations'].merge!(new_data)
+      end
+    end
+  end
+end

data/lib/active_storage_validations/{marcel_extensor.rb → extensors/asv_marcelable.rb}

@@ -1,7 +1,12 @@
 # frozen_string_literal: true
 
+require "marcel"
+
 Marcel::MimeType.extend "application/x-rar-compressed", parents: %(application/x-rar)
 Marcel::MimeType.extend "audio/x-hx-aac-adts", parents: %(audio/x-aac)
 Marcel::MimeType.extend "audio/x-m4a", parents: %(audio/mp4)
 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)

data/lib/active_storage_validations/limit_validator.rb

@@ -15,6 +15,8 @@ module ActiveStorageValidations
     AVAILABLE_CHECKS = %i[max min].freeze
     ERROR_TYPES = %i[
       limit_out_of_range
+      limit_min_not_reached
+      limit_max_exceeded
     ].freeze
 
     def check_validity!
@@ -25,13 +27,23 @@ module ActiveStorageValidations
     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?(files.count, flat_options)
+      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]
-      add_error(record, attribute, ERROR_TYPES.first, **errors_options)
+      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
 
     private

data/lib/active_storage_validations/matchers/aspect_ratio_validator_matcher.rb

@@ -94,7 +94,7 @@ module ActiveStorageValidations
       end
 
       def mock_dimensions_for(attachment, width, height)
-        Matchers.mock_metadata(attachment, width, height) do
+        Matchers.mock_metadata(attachment, { width: width, height: height }) do
           yield
         end
       end

data/lib/active_storage_validations/matchers/{base_size_validator_matcher.rb → base_comparison_validator_matcher.rb}

@@ -13,8 +13,8 @@ require_relative 'shared/asv_validatable'
 
 module ActiveStorageValidations
   module Matchers
-    class BaseSizeValidatorMatcher
-      # BaseSizeValidatorMatcher is an abstract class and shouldn't be instantiated directly.
+    class BaseComparisonValidatorMatcher
+      # BaseComparisonValidatorMatcher is an abstract class and shouldn't be instantiated directly.
 
       include ASVActiveStorageable
       include ASVAllowBlankable
@@ -33,23 +33,23 @@ module ActiveStorageValidations
         @min = @max = nil
       end
 
-      def less_than(size)
-        @max = size - 1.byte
+      def less_than(value)
+        @max = value - smallest_measurement
         self
       end
 
-      def less_than_or_equal_to(size)
-        @max = size
+      def less_than_or_equal_to(value)
+        @max = value
         self
       end
 
-      def greater_than(size)
-        @min = size + 1.byte
+      def greater_than(value)
+        @min = value + smallest_measurement
         self
       end
 
-      def greater_than_or_equal_to(size)
-        @min = size
+      def greater_than_or_equal_to(value)
+        @min = value
         self
       end
 
@@ -78,45 +78,53 @@ module ActiveStorageValidations
 
         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[:size]} bytes test file"
+          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_size(@min - 1)
+        @min.nil? || !passes_validation_with_value(@min - 1)
       end
 
       def higher_than_min?
-        @min.nil? || passes_validation_with_size(@min + 1)
+        @min.nil? || passes_validation_with_value(@min + 1)
       end
 
       def lower_than_max?
-        @max.nil? || @max == Float::INFINITY || passes_validation_with_size(@max - 1)
+        @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_size(@max + 1)
+        @max.nil? || @max == Float::INFINITY || !passes_validation_with_value(@max + 1)
       end
 
-      def passes_validation_with_size(size)
-        mock_size_for(io, size) do
+      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(size)
+          is_valid? || add_failure_message_artefact(value)
         end
       end
 
-      def add_failure_message_artefact(size)
-        @failure_message_artefacts << { size: size }
+      def add_failure_message_artefact(value)
+        @failure_message_artefacts << { value: value }
         false
       end
 
       def is_custom_message_valid?
         return true unless @custom_message
 
-        mock_size_for(io, -1.kilobytes) do
+        mock_value_for(io, -smallest_measurement) do
           attach_file
           validate
           detach_file
@@ -124,10 +132,8 @@ module ActiveStorageValidations
         end
       end
 
-      def mock_size_for(io, size)
-        Matchers.stub_method(io, :size, size) do
-          yield
-        end
+      def mock_value_for(io, size)
+        raise NotImplementedError
       end
     end
   end

data/lib/active_storage_validations/matchers/content_type_validator_matcher.rb

@@ -46,12 +46,12 @@ module ActiveStorageValidations
       end
 
       def allowing(*content_types)
-        @allowed_content_types = content_types.flatten
+        @allowed_content_types = content_types.map { |content_type| normalize_content_type(content_type) }.flatten
         self
       end
 
       def rejecting(*content_types)
-        @rejected_content_types = content_types.flatten
+        @rejected_content_types = content_types.map { |content_type| normalize_content_type(content_type) }.flatten
         self
       end
 
@@ -88,6 +88,10 @@ module ActiveStorageValidations
         end
       end
 
+      def normalize_content_type(content_type)
+        Marcel::MimeType.for(declared_type: content_type.to_s, extension: content_type.to_s)
+      end
+
       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?
@@ -135,7 +139,7 @@ module ActiveStorageValidations
       # (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] == :spoofed_content_type }
+        super.reject { |hash| hash[:error] == :content_type_spoofed }
       end
     end
   end

data/lib/active_storage_validations/matchers/dimension_validator_matcher.rb

@@ -185,7 +185,7 @@ module ActiveStorageValidations
       end
 
       def mock_dimensions_for(attachment, width, height)
-        Matchers.mock_metadata(attachment, width, height) do
+        Matchers.mock_metadata(attachment, { width: width, height: height }) do
           yield
         end
       end

data/lib/active_storage_validations/matchers/duration_validator_matcher.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'base_comparison_validator_matcher'
+
+module ActiveStorageValidations
+  module Matchers
+    def validate_duration_of(attribute_name)
+      DurationValidatorMatcher.new(attribute_name)
+    end
+
+    class DurationValidatorMatcher < BaseComparisonValidatorMatcher
+      def description
+        "validate file duration of :#{@attribute_name}"
+      end
+
+      def failure_message
+        message = ["is expected to validate file duration of :#{@attribute_name}"]
+        build_failure_message(message)
+        message.join("\n")
+      end
+
+      private
+
+      def failure_message_unit
+        "seconds"
+      end
+
+      def smallest_measurement
+        1.second
+      end
+
+      def mock_value_for(io, duration)
+        Matchers.mock_metadata(io, { duration: duration }) do
+          yield
+        end
+      end
+    end
+  end
+end