active_storage_validations 1.4.0 → 2.0.0

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}

@@ -7,3 +7,6 @@ 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

data/lib/active_storage_validations/matchers/{processable_image_validator_matcher.rb → processable_file_validator_matcher.rb}

@@ -10,11 +10,11 @@ require_relative 'shared/asv_validatable'
 
 module ActiveStorageValidations
   module Matchers
-    def validate_processable_image_of(name)
-      ProcessableImageValidatorMatcher.new(name)
+    def validate_processable_file_of(name)
+      ProcessableFileValidatorMatcher.new(name)
     end
 
-    class ProcessableImageValidatorMatcher
+    class ProcessableFileValidatorMatcher
       include ASVActiveStorageable
       include ASVAllowBlankable
       include ASVAttachable
@@ -46,7 +46,7 @@ module ActiveStorageValidations
           is_context_valid? &&
           is_custom_message_valid? &&
           is_valid_when_image_processable? &&
-          is_invalid_when_image_not_processable?
+          is_invalid_when_file_not_processable?
       end
 
       private
@@ -58,7 +58,7 @@ module ActiveStorageValidations
         is_valid?
       end
 
-      def is_invalid_when_image_not_processable?
+      def is_invalid_when_file_not_processable?
         attach_file(not_processable_image)
         validate
         detach_file

data/lib/active_storage_validations/matchers/size_validator_matcher.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'base_size_validator_matcher'
+require_relative 'base_comparison_validator_matcher'
 
 module ActiveStorageValidations
   module Matchers
@@ -8,7 +8,7 @@ module ActiveStorageValidations
       SizeValidatorMatcher.new(attribute_name)
     end
 
-    class SizeValidatorMatcher < BaseSizeValidatorMatcher
+    class SizeValidatorMatcher < BaseComparisonValidatorMatcher
       def description
         "validate file size of :#{@attribute_name}"
       end
@@ -18,6 +18,22 @@ module ActiveStorageValidations
         build_failure_message(message)
         message.join("\n")
       end
+
+      private
+
+      def failure_message_unit
+        "bytes"
+      end
+
+      def smallest_measurement
+        1.byte
+      end
+
+      def mock_value_for(io, size)
+        Matchers.stub_method(io, :size, size) do
+          yield
+        end
+      end
     end
   end
 end

data/lib/active_storage_validations/matchers/total_size_validator_matcher.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'base_size_validator_matcher'
+require_relative 'base_comparison_validator_matcher'
 
 module ActiveStorageValidations
   module Matchers
@@ -8,7 +8,7 @@ module ActiveStorageValidations
       TotalSizeValidatorMatcher.new(attribute_name)
     end
 
-    class TotalSizeValidatorMatcher < BaseSizeValidatorMatcher
+    class TotalSizeValidatorMatcher < BaseComparisonValidatorMatcher
       def description
         "validate total file size of :#{@attribute_name}"
       end
@@ -26,6 +26,22 @@ module ActiveStorageValidations
         @subject.public_send(@attribute_name).attach([dummy_blob])
         @subject.public_send(@attribute_name)
       end
+
+      private
+
+      def failure_message_unit
+        "bytes"
+      end
+
+      def smallest_measurement
+        1.byte
+      end
+
+      def mock_value_for(io, size)
+        Matchers.stub_method(io, :size, size) do
+          yield
+        end
+      end
     end
   end
 end

data/lib/active_storage_validations/matchers.rb

@@ -2,10 +2,11 @@
 
 require 'active_storage_validations/matchers/aspect_ratio_validator_matcher'
 require 'active_storage_validations/matchers/attached_validator_matcher'
-require 'active_storage_validations/matchers/processable_image_validator_matcher'
+require 'active_storage_validations/matchers/processable_file_validator_matcher'
 require 'active_storage_validations/matchers/limit_validator_matcher'
 require 'active_storage_validations/matchers/content_type_validator_matcher'
 require 'active_storage_validations/matchers/dimension_validator_matcher'
+require 'active_storage_validations/matchers/duration_validator_matcher'
 require 'active_storage_validations/matchers/size_validator_matcher'
 require 'active_storage_validations/matchers/total_size_validator_matcher'
 
@@ -25,8 +26,8 @@ module ActiveStorageValidations
       end
     end
 
-    def self.mock_metadata(attachment, width, height)
-      mock = Struct.new(:metadata).new({ width: width, height: height })
+    def self.mock_metadata(attachment, metadata = {})
+      mock = Struct.new(:metadata).new(metadata)
 
       stub_method(ActiveStorageValidations::Analyzer, :new, mock) do
         yield

data/lib/active_storage_validations/{processable_image_validator.rb → processable_file_validator.rb}

@@ -7,7 +7,7 @@ require_relative 'shared/asv_errorable'
 require_relative 'shared/asv_symbolizable'
 
 module ActiveStorageValidations
-  class ProcessableImageValidator < ActiveModel::EachValidator # :nodoc
+  class ProcessableFileValidator < ActiveModel::EachValidator # :nodoc
     include ASVActiveStorageable
     include ASVAnalyzable
     include ASVAttachable
@@ -15,13 +15,14 @@ module ActiveStorageValidations
     include ASVSymbolizable
 
     ERROR_TYPES = %i[
-      image_not_processable
+      file_not_processable
     ].freeze
+    METADATA_KEYS = %i[].freeze
 
     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

data/lib/active_storage_validations/railtie.rb

@@ -2,5 +2,10 @@
 
 module ActiveStorageValidations
   class Railtie < ::Rails::Railtie
+    initializer 'active_storage_validations.extend_active_storage_blob' do
+      Rails.application.config.to_prepare do
+        ActiveStorage::Blob.include(ActiveStorageValidations::ASVBlobMetadatable)
+      end
+    end
   end
 end

data/lib/active_storage_validations/shared/asv_analyzable.rb

@@ -12,13 +12,36 @@ module ActiveStorageValidations
 
     private
 
-    def metadata_for(attachable)
-      analyzer_for(attachable).metadata
+    # Retrieve the ASV metadata from the blob.
+    # If the blob has not been analyzed by our gem yet, the gem will analyze the
+    # attachable with the corresponding analyzer and set the metadata in the
+    # blob.
+    def metadata_for(blob, attachable, metadata_keys)
+      return blob.active_storage_validations_metadata if blob_has_asv_metadata?(blob, metadata_keys)
+
+      new_metadata = generate_metadata_for(attachable, metadata_keys)
+      blob.merge_into_active_storage_validations_metadata(new_metadata)
+    end
+
+    def blob_has_asv_metadata?(blob, metadata_keys)
+      return false unless blob.active_storage_validations_metadata.present?
+
+      metadata_keys.all? { |key| blob.active_storage_validations_metadata.key?(key) }
+    end
+
+    def generate_metadata_for(attachable, metadata_keys)
+      if metadata_keys == ActiveStorageValidations::ContentTypeValidator::METADATA_KEYS
+        content_type_analyzer_for(attachable).content_type
+      else
+        metadata_analyzer_for(attachable).metadata
+      end
     end
 
-    def analyzer_for(attachable)
+    def metadata_analyzer_for(attachable)
       case attachable_media_type(attachable)
       when "image" then image_analyzer_for(attachable)
+      when "video" then video_analyzer_for(attachable)
+      when "audio" then audio_analyzer_for(attachable)
       else fallback_analyzer_for(attachable)
       end
     end
@@ -38,8 +61,20 @@ module ActiveStorageValidations
       ActiveStorage.variant_processor || DEFAULT_IMAGE_PROCESSOR
     end
 
+    def video_analyzer_for(attachable)
+      ActiveStorageValidations::Analyzer::VideoAnalyzer.new(attachable)
+    end
+
+    def audio_analyzer_for(attachable)
+      ActiveStorageValidations::Analyzer::AudioAnalyzer.new(attachable)
+    end
+
     def fallback_analyzer_for(attachable)
       ActiveStorageValidations::Analyzer::NullAnalyzer.new(attachable)
     end
+
+    def content_type_analyzer_for(attachable)
+      ActiveStorageValidations::Analyzer::ContentTypeAnalyzer.new(attachable)
+    end
   end
 end