active_storage_validations 4.0.0 → 4.1.1

data/lib/active_storage_validations/asv_attachable_adapter.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  # Wraps a Rails attachable so callers do not repeat the type-dispatch case tree.
+  #
+  # Must not be named +Attachable+: ActiveStorageValidations is included into
+  # Active Record, so +include Attachable+ in an app model under this namespace
+  # would resolve to this class instead of the app's concern.
+  #
+  # Supported representations: ActiveStorage::Blob, ActionDispatch::Http::UploadedFile,
+  # Rack::Test::UploadedFile, Hash, File, Pathname, and a signed blob id (String).
+  class ASVAttachableAdapter
+    def self.wrap(attachable, file_supported:)
+      handler_class_for(attachable).new(attachable, file_supported: file_supported)
+    end
+
+    # Filename for error options. Unknown types return nil (never raise).
+    # File / Pathname are always accepted here so a validation error can name
+    # the file even on Rails versions that cannot attach them.
+    def self.filename_for(file)
+      case file
+      when ActiveStorage::Attached, ActiveStorage::Attachment
+        file.blob&.filename
+      else
+        return unless known?(file)
+
+        wrap(file, file_supported: true).filename
+      end
+    end
+
+    def self.known?(attachable)
+      handler_class_for(attachable) != Unsupported
+    end
+    private_class_method :known?
+
+    def self.handler_class_for(attachable)
+      case attachable
+      when ActiveStorage::Blob then Blob
+      when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile then Uploaded
+      when String then SignedId
+      when Hash then HashIo
+      when File then FileLike
+      when Pathname then Path
+      else Unsupported
+      end
+    end
+    private_class_method :handler_class_for
+
+    class Base
+      def initialize(attachable, file_supported:)
+        @attachable = attachable
+        @file_supported = file_supported
+      end
+
+      def content_type
+        raise NotImplementedError
+      end
+
+      def filename
+        raise NotImplementedError
+      end
+
+      def read(max_byte_size: nil)
+        raise NotImplementedError
+      end
+
+      def rewind
+      end
+
+      def with_media_path(_tempfile)
+        raise NotImplementedError
+      end
+
+      private
+
+      def raise_unsupported
+        raise ArgumentError,
+          "Could not find or build blob: expected attachable, " \
+            "got #{@attachable.inspect}"
+      end
+
+      def read_from(io, max_byte_size)
+        max_byte_size ? io.read(max_byte_size) : io.read
+      end
+
+      def copy_to_tempfile(tempfile, source)
+        if source.is_a?(ActiveStorage::Blob)
+          source.download { |chunk| tempfile.write(chunk) }
+        else
+          IO.copy_stream(source, tempfile)
+          source.rewind
+        end
+
+        tempfile.flush
+        tempfile.rewind
+        yield tempfile.path
+      end
+
+      def marcel_content_type
+        Marcel::MimeType.for(name: filename.to_s)
+      end
+    end
+
+    class Blob < Base
+      def content_type
+        @attachable.content_type
+      end
+
+      def filename
+        @attachable.filename
+      end
+
+      def read(max_byte_size: nil)
+        max_byte_size ? @attachable.download_chunk(0...max_byte_size) : @attachable.download
+      end
+
+      def with_media_path(tempfile, &block)
+        copy_to_tempfile(tempfile, @attachable, &block)
+      end
+    end
+
+    class SignedId < Blob
+      def initialize(attachable, file_supported:)
+        super(ActiveStorage::Blob.find_signed!(attachable), file_supported: file_supported)
+      end
+    end
+
+    class Uploaded < Base
+      def content_type
+        @attachable.content_type
+      end
+
+      def filename
+        @attachable.original_filename
+      end
+
+      def read(max_byte_size: nil)
+        read_from(@attachable, max_byte_size)
+      end
+
+      def rewind
+        @attachable.rewind
+      end
+
+      def with_media_path(_tempfile)
+        yield @attachable.path
+      end
+    end
+
+    class HashIo < Base
+      def content_type
+        @attachable[:content_type]
+      end
+
+      def filename
+        @attachable[:filename]
+      end
+
+      def read(max_byte_size: nil)
+        read_from(@attachable[:io], max_byte_size)
+      end
+
+      def rewind
+        @attachable[:io].rewind
+      end
+
+      def with_media_path(tempfile, &block)
+        io = @attachable[:io]
+        if io.is_a?(StringIO)
+          copy_to_tempfile(tempfile, io, &block)
+        else
+          File.open(io) { |file| yield file.path }
+        end
+      end
+    end
+
+    class FileLike < Base
+      def initialize(attachable, file_supported:)
+        super
+        raise_unsupported unless file_supported
+      end
+
+      def content_type
+        marcel_content_type
+      end
+
+      def filename
+        File.basename(@attachable)
+      end
+
+      def read(max_byte_size: nil)
+        read_from(@attachable, max_byte_size)
+      end
+
+      def rewind
+        @attachable.rewind
+      end
+
+      def with_media_path(_tempfile)
+        yield @attachable.path
+      end
+    end
+
+    class Path < FileLike
+      def rewind
+        File.open(@attachable) { |file| file.rewind }
+      end
+
+      def with_media_path(_tempfile)
+        yield @attachable.to_s
+      end
+    end
+
+    class Unsupported < Base
+      def initialize(attachable, file_supported:)
+        super
+        raise_unsupported
+      end
+    end
+  end
+end

data/lib/active_storage_validations/content_type_validator.rb

@@ -24,6 +24,11 @@ module ActiveStorageValidations
     ].freeze
     METADATA_KEYS = %i[content_type].freeze
 
+    # State for a single attachable check. Active Model builds one validator per
+    # class and reuses it for every record and every thread, so this must travel
+    # through arguments rather than instance variables.
+    Context = Struct.new(:authorized_content_types, :content_type, :filename)
+
     def check_validity!
       ensure_exactly_one_validator_option
       ensure_content_types_validity
@@ -33,12 +38,12 @@ module ActiveStorageValidations
     def validate_each(record, attribute, _value)
       return if no_attachments?(record, attribute)
 
-      @authorized_content_types = authorized_content_types_from_options(record)
-      return if @authorized_content_types.empty?
+      authorized_content_types = authorized_content_types_from_options(record)
+      return if authorized_content_types.empty?
 
       attachables_and_blobs(record, attribute).each do |attachable, blob|
-        set_attachable_cached_values(blob)
-        is_valid?(record, attribute, attachable, blob)
+        context = Context.new(authorized_content_types, blob.content_type, blob.filename.to_s)
+        is_valid?(record, attribute, attachable, blob, context)
       end
     end
 
@@ -55,76 +60,47 @@ module ActiveStorageValidations
       end
     end
 
-    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, blob)
-      authorized_content_type?(record, attribute, attachable) &&
-        not_spoofing_content_type?(record, attribute, attachable, blob)
+    def is_valid?(record, attribute, attachable, blob, context)
+      authorized_content_type?(record, attribute, attachable, context) &&
+        not_spoofing_content_type?(record, attribute, attachable, blob, context)
     end
 
-    # Dead code that we keep here for some time, maybe we will find a solution
-    # to this check later? (November 2024)
-    #
-    # We do not perform any validations against the extension because it is an
-    # unreliable source of truth. For example, a `.csv` file could have its
-    # `text/csv` content_type changed to  `application/vnd.ms-excel` because
-    # it had been opened by Excel at some point, making the file extension vs
-    # file content_type check invalid.
-    # def extension_matches_content_type?(record, attribute, attachable)
-    #   return true if !@attachable_filename || !@attachable_content_type
-
-    #   extension = @attachable_filename.split('.').last
-    #   possible_extensions = Marcel::TYPE_EXTS[@attachable_content_type]
-    #   return true if possible_extensions && extension.downcase.in?(possible_extensions)
-
-    #   errors_options = initialize_and_populate_error_options(options, attachable)
-    #   add_error(record, attribute, ERROR_TYPES.first, **errors_options)
-    #   false
-    # end
-
-    def authorized_content_type?(record, attribute, attachable)
-      attachable_content_type_is_authorized = @authorized_content_types.any? do |authorized_content_type|
+    def authorized_content_type?(record, attribute, attachable, context)
+      attachable_content_type_is_authorized = context.authorized_content_types.any? do |authorized_content_type|
         case authorized_content_type
-        when String then authorized_content_type == marcel_attachable_content_type(attachable)
-        when Regexp then authorized_content_type.match?(marcel_attachable_content_type(attachable).to_s)
+        when String then authorized_content_type == marcel_attachable_content_type(context)
+        when Regexp then authorized_content_type.match?(marcel_attachable_content_type(context).to_s)
         end
       end
 
       return true if attachable_content_type_is_authorized
 
-      add_content_type_invalid_error(record, attribute, attachable)
+      add_content_type_invalid_error(record, attribute, attachable, context)
     end
 
-    def marcel_attachable_content_type(attachable)
-      Marcel::MimeType.for(declared_type: @attachable_content_type, name: @attachable_filename)
+    def marcel_attachable_content_type(context)
+      Marcel::MimeType.for(declared_type: context.content_type, name: context.filename)
     end
 
-    def not_spoofing_content_type?(record, attribute, attachable, blob)
+    def not_spoofing_content_type?(record, attribute, attachable, blob, context)
       return true unless enable_spoofing_protection?
 
-      @detected_content_type = begin
+      detected_content_type = begin
         metadata_for(blob, attachable, METADATA_KEYS)&.fetch(:content_type, nil)
       rescue ActiveStorage::FileNotFoundError
         add_attachment_missing_error(record, attribute, attachable)
         return false
       end
 
-      if attachable_content_type_vs_detected_content_type_mismatch?
-        add_content_type_spoofed_error(record, attribute, attachable, @detected_content_type)
+      if content_type_mismatch?(context.content_type, detected_content_type)
+        add_content_type_spoofed_error(record, attribute, attachable, context, detected_content_type)
       else
         true
       end
     end
 
-    def disable_spoofing_protection?
-      !enable_spoofing_protection?
-    end
-
     def enable_spoofing_protection?
       spoofing_protection_backend.present?
     end
@@ -147,14 +123,14 @@ module ActiveStorageValidations
       ERROR_MESSAGE
     end
 
-    def attachable_content_type_vs_detected_content_type_mismatch?
-      @attachable_content_type.present? &&
-        !attachable_content_type_intersects_detected_content_type?
+    def content_type_mismatch?(attachable_content_type, detected_content_type)
+      attachable_content_type.present? &&
+        !content_types_intersect?(attachable_content_type, detected_content_type)
     end
 
-    def attachable_content_type_intersects_detected_content_type?
-      enlarged_content_type(content_type_without_parameters(@attachable_content_type)).intersect?(
-        enlarged_content_type(content_type_without_parameters(@detected_content_type))
+    def content_types_intersect?(attachable_content_type, detected_content_type)
+      enlarged_content_type(content_type_without_parameters(attachable_content_type)).intersect?(
+        enlarged_content_type(content_type_without_parameters(detected_content_type))
       )
     end
 
@@ -166,26 +142,26 @@ module ActiveStorageValidations
       Marcel::TYPE_PARENTS[content_type] || []
     end
 
-    def add_content_type_invalid_error(record, attribute, attachable)
-      errors_options = initialize_and_populate_error_options(options, attachable)
+    def add_content_type_invalid_error(record, attribute, attachable, context)
+      errors_options = initialize_and_populate_error_options(options, attachable, context)
       add_error(record, attribute, ERROR_TYPES.first, **errors_options)
       false
     end
 
-    def add_content_type_spoofed_error(record, attribute, attachable, detected_content_type)
-      errors_options = initialize_and_populate_error_options(options, attachable)
-      errors_options[:detected_content_type] = @detected_content_type
-      errors_options[:detected_human_content_type] = content_type_to_human_format(@detected_content_type)
+    def add_content_type_spoofed_error(record, attribute, attachable, context, detected_content_type)
+      errors_options = initialize_and_populate_error_options(options, attachable, context)
+      errors_options[:detected_content_type] = detected_content_type
+      errors_options[:detected_human_content_type] = content_type_to_human_format(detected_content_type)
       add_error(record, attribute, ERROR_TYPES.second, **errors_options)
       false
     end
 
-    def initialize_and_populate_error_options(options, attachable)
+    def initialize_and_populate_error_options(options, attachable, context)
       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_human_content_types] = content_type_to_human_format(@authorized_content_types)
-      errors_options[:count] = @authorized_content_types.size
+      errors_options[:content_type] = context.content_type
+      errors_options[:human_content_type] = content_type_to_human_format(context.content_type)
+      errors_options[:authorized_human_content_types] = content_type_to_human_format(context.authorized_content_types)
+      errors_options[:count] = context.authorized_content_types.size
       errors_options
     end
 

data/lib/active_storage_validations/duration_validator.rb

@@ -30,7 +30,9 @@ module ActiveStorageValidations
           next
         end
 
-        if duration.to_i <= 0
+        # to_f, not to_i: durations are floats, and truncating would treat any
+        # file shorter than a second as unanalyzable.
+        if duration.to_f <= 0
           add_media_metadata_missing_error(record, attribute, attachable)
           next
         end

data/lib/active_storage_validations/engine.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 module ActiveStorageValidations
+  # Registers the gem as a Rails engine so `config/locales/*.yml` is added to
+  # the I18n load path. Initializers live on {Railtie} (Active Record include,
+  # FormBuilder prepend, Blob metadata).
   class Engine < ::Rails::Engine
   end
 end

data/lib/active_storage_validations/extensors/asv_marcelable.rb

@@ -2,11 +2,11 @@
 
 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)
+Marcel::MimeType.extend "application/x-rar-compressed", parents: %w[application/x-rar]
+Marcel::MimeType.extend "audio/x-hx-aac-adts", parents: %w[audio/x-aac]
+Marcel::MimeType.extend "audio/x-m4a", parents: %w[audio/mp4]
+Marcel::MimeType.extend "text/xml", parents: %w[application/xml] # alias
+Marcel::MimeType.extend "video/theora", parents: %w[video/ogg]
 
 # Add empty content type
 Marcel::MimeType.extend "inode/x-empty", extensions: %w[empty]

data/lib/active_storage_validations/matchers/base_comparison_validator_matcher.rb

@@ -33,7 +33,7 @@ module ActiveStorageValidations
         initialize_messageable
         initialize_rspecable
         @attribute_name = attribute_name
-        @min = @max = nil
+        @min = @max = @exact = nil
       end
 
       def less_than(value)
@@ -107,12 +107,15 @@ module ActiveStorageValidations
         @min.nil? || !passes_validation_with_value(@min - 1)
       end
 
+      # Probe the inclusive bound itself. Checking only min+1 / max-1 lets
+      # less_than(n) satisfy less_than_or_equal_to(n) (and greater_than
+      # satisfy greater_than_or_equal_to).
       def higher_than_min?
-        @min.nil? || passes_validation_with_value(@min + 1)
+        @min.nil? || passes_validation_with_value(@min)
       end
 
       def lower_than_max?
-        @max.nil? || @max == Float::INFINITY || passes_validation_with_value(@max - 1)
+        @max.nil? || @max == Float::INFINITY || passes_validation_with_value(@max)
       end
 
       def not_higher_than_max?
@@ -120,7 +123,11 @@ module ActiveStorageValidations
       end
 
       def equal_to_exact?
-        @exact.nil? || passes_validation_with_value(@exact)
+        return true if @exact.nil?
+
+        passes_validation_with_value(@exact) &&
+          !passes_validation_with_value(@exact - smallest_measurement) &&
+          !passes_validation_with_value(@exact + smallest_measurement)
       end
 
       def smallest_measurement

data/lib/active_storage_validations/matchers/limit_validator_matcher.rb

@@ -61,6 +61,7 @@ module ActiveStorageValidations
         is_a_valid_active_storage_attribute? &&
           is_context_valid? &&
           is_except_on_valid? &&
+          is_allowing_blank? &&
           is_custom_message_valid? &&
           file_count_not_smaller_than_min? &&
           file_count_equal_min? &&
@@ -83,7 +84,7 @@ module ActiveStorageValidations
       end
 
       def file_count_not_smaller_than_min?
-        @min.nil? || @min.zero? || !passes_validation_with_limits(@min - 1)
+        @min.nil? || @min.zero? || (@allow_blank && @min == 1) || !passes_validation_with_limits(@min - 1)
       end
 
       def file_count_equal_min?

data/lib/active_storage_validations/matchers/processable_file_validator_matcher.rb

@@ -51,6 +51,7 @@ module ActiveStorageValidations
         is_a_valid_active_storage_attribute? &&
           is_context_valid? &&
           is_except_on_valid? &&
+          is_allowing_blank? &&
           is_timeout_valid? &&
           is_custom_message_valid? &&
           is_valid_when_image_processable? &&

data/lib/active_storage_validations/matchers/shared/asv_allow_blankable.rb

@@ -21,7 +21,7 @@ module ActiveStorageValidations
       def is_allowing_blank?
         return true unless @allow_blank
 
-        validate
+        attribute_validators.any? { |validator| validator.options[:allow_blank] }
       end
     end
   end

data/lib/active_storage_validations/matchers/with_audio_validator_matcher.rb

@@ -0,0 +1,114 @@
+# 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_except_onable"
+require_relative "shared/asv_messageable"
+require_relative "shared/asv_rspecable"
+require_relative "shared/asv_timeoutable"
+require_relative "shared/asv_validatable"
+
+module ActiveStorageValidations
+  module Matchers
+    def validate_with_audio_of(attribute_name)
+      WithAudioValidatorMatcher.new(attribute_name)
+    end
+
+    class WithAudioValidatorMatcher
+      include ASVActiveStorageable
+      include ASVAllowBlankable
+      include ASVAttachable
+      include ASVContextable
+      include ASVExceptOnable
+      include ASVMessageable
+      include ASVRspecable
+      include ASVTimeoutable
+      include ASVValidatable
+
+      def initialize(attribute_name)
+        initialize_allow_blankable
+        initialize_contextable
+        initialize_except_onable
+        initialize_messageable
+        initialize_rspecable
+        initialize_timeoutable
+        @attribute_name = attribute_name
+        @expected_audio = true
+      end
+
+      def description
+        "validate that :#{@attribute_name} #{audio_expectation}"
+      end
+
+      def failure_message
+        "is expected to validate that :#{@attribute_name} #{audio_expectation}"
+      end
+
+      def without_audio
+        @expected_audio = false
+        self
+      end
+
+      def matches?(subject)
+        @subject = subject.is_a?(Class) ? subject.new : subject
+
+        is_a_valid_active_storage_attribute? &&
+          is_context_valid? &&
+          is_except_on_valid? &&
+          is_allowing_blank? &&
+          is_timeout_valid? &&
+          is_custom_message_valid? &&
+          is_valid_with_expected_audio? &&
+          is_invalid_with_unexpected_audio?
+      end
+
+      private
+
+      def audio_expectation
+        @expected_audio ? "has an audio track" : "has no audio track"
+      end
+
+      def is_valid_with_expected_audio?
+        validation_passes_with_audio?(@expected_audio)
+      end
+
+      def is_invalid_with_unexpected_audio?
+        !validation_passes_with_audio?(!@expected_audio)
+      end
+
+      def is_custom_message_valid?
+        return true unless @custom_message
+
+        with_audio_metadata(false) do
+          attach_file(video_file)
+          validate
+          detach_file
+          has_an_error_message_which_is_custom_message?
+        end
+      end
+
+      def validation_passes_with_audio?(audio)
+        with_audio_metadata(audio) do
+          attach_file(video_file)
+          validate
+          detach_file
+          is_valid?
+        end
+      end
+
+      def with_audio_metadata(audio, &block)
+        Matchers.mock_metadata(io, { audio: audio }, &block)
+      end
+
+      def video_file
+        {
+          io: io,
+          filename: "test.mp4",
+          content_type: "video/mp4"
+        }
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers.rb

@@ -7,25 +7,37 @@ 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/with_audio_validator_matcher"
 require "active_storage_validations/matchers/size_validator_matcher"
 require "active_storage_validations/matchers/total_size_validator_matcher"
 require "active_storage_validations/matchers/pages_validator_matcher"
 
 module ActiveStorageValidations
   module Matchers
-    # Helper to stub a method with either RSpec or Minitest (whatever is available)
+    # Temporary singleton-method wrap. Independent of RSpec::Mocks and of
+    # Minitest::Mock / Object#stub (extracted to minitest-mock in Minitest 6),
+    # so size / metadata matchers work on stock Minitest 5 and 6.
     def self.stub_method(object, method, result)
-      if defined?(Minitest::Mock)
-        object.stub(method, result) do
-          yield
-        end
-      elsif defined?(RSpec::Mocks)
-        RSpec::Mocks.allow_message(object, method) { result }
-        yield
-      else
-        raise "Need either Minitest::Mock or RSpec::Mocks to run this validator matcher"
+      singleton = object.singleton_class
+      owned = singleton.instance_methods(false).include?(method)
+      original = owned ? singleton.instance_method(method) : nil
+
+      singleton.define_method(method) { |*_args, **_kwargs| result }
+      yield
+    ensure
+      restore_stubbed_method(singleton, method, owned, original)
+    end
+
+    def self.restore_stubbed_method(singleton, method, owned, original)
+      return unless singleton
+
+      if owned
+        singleton.define_method(method, original)
+      elsif singleton.instance_methods(false).include?(method)
+        singleton.remove_method(method)
       end
     end
+    private_class_method :restore_stubbed_method
 
     def self.mock_metadata(attachment, metadata = {})
       asv_metadata_available_keys = { width: nil, height: nil, duration: nil, content_type: nil }