active_storage_validations 4.1.0 → 4.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24d8643d1f970252124d4429ca9bc15b222ef203cdcae93427a0860c7190c370
-  data.tar.gz: 62a74e517b40b32dba39c0529f0d4e4529d615a11decdebf8ec338505c082435
+  metadata.gz: 5a6bd490e0f58921da42838a5df629556c0e9f84a01c114b8772ac195afea917
+  data.tar.gz: 397f02aeea00242f94af79a422d37dbcd90c1e07946107bf08f2dccf1da0c793
 SHA512:
-  metadata.gz: c8fa701638b13eea05351e5a76847d144e93ec83b4e14a8d5b5e23ae71944eabd092704c723fcb81e9c44a3fb909ab6431be680390ee414f13002af671792ca1
-  data.tar.gz: 82af6984104d830cd7eda7ffdb557f3bb997d8bb59fbef6edc85e0830c3a4397209d4ab31f6427f5945fe392935fefe7c49dc6cabd87c840a34592e8b827f300
+  metadata.gz: ffc3c1b5b9a722dbc2b33d57560fdc41a2efb5ec68095883e15d251024e073f5d34342a2c0f10515794bd1ea6aeed1de593ca0e345af9cfb130d2d424543bf9a
+  data.tar.gz: aaf819d38fd5e91de9eeb68248b9d8e4f0faf733a9b5773a682819bb19933b6e740336315842914a1962b9ef2c39f2b9637fd3c481e584dd9c4f566237f0ace5

data/README.md

@@ -114,8 +114,21 @@ end
 #   event = ActiveSupport::Notifications::Event.new(*args)
 #   Rails.logger.warn("[ASV] command timeout: #{event.payload}")
 # end
+
+# Optional: monitor how long metadata / content type analysis takes
+# ActiveSupport::Notifications.subscribe("analyze.active_storage_validations") do |*args|
+#   event = ActiveSupport::Notifications::Event.new(*args)
+#   Rails.logger.info("[ASV] analyzed: #{event.payload}")
+# end
 ```
 
+The gem emits two `ActiveSupport::Notifications` events:
+
+| Event | Payload | Emitted |
+|---|---|---|
+| `analyze.active_storage_validations` | `analyzer`, `command`, `timeout`, `timed_out`, `duration` | Every time an analyzer command runs (i.e. on a cache miss) |
+| `timeout.active_storage_validations` | `analyzer`, `command`, `timeout` | Only when a command exceeds its deadline |
+
 `command_timeout` bounds metadata analysis used by `dimension`, `aspect_ratio`, `duration`, `with_audio`, `pages`, `processable_file`, and `content_type` (with `spoofing_protection`). When a command times out, analysis fails closed and the validator adds its usual error (`file_not_processable` / `media_metadata_missing` / `audio_missing` / content-type errors) — there is no separate timeout error message.
 
 The 10s default is enough for typical uploads. Raise it (or set `nil`) if you analyze very large videos/PDFs, especially on slow or network storage — otherwise those files can start failing validation after upgrade. See [upgrade to 4.x](docs/upgrade_to_4.md#analyzer-command-timeout).
@@ -141,7 +154,7 @@ Notes:
 - [Total size](#total-size): validates total file size for several files
 - [Dimension](#dimension): validates image / video dimensions
 - [Duration](#duration): validates video / audio duration
-- [With audio](#with-audio): validates whether a video contains an audio track
+- [With audio](#with-audio): validates whether a video / audio file contains an audio track
 - [Aspect ratio](#aspect-ratio): validates image / video aspect ratio
 - [Processable file](#processable-file): validates if a file can be processed
 - [Pages](#pages): validates pdf number of pages
@@ -163,6 +176,8 @@ Some validators rely on an expensive operation (metadata analysis and content ty
 
 As stated in the Rails documentation: "Blobs are intended to be immutable in so far as their reference to a specific file goes". We based our performance optimization on the same assumption, so if you do not follow it, the gem will not work as expected.
 
+This also covers metadata the analyzer cannot extract from a given file (e.g. a `duration` validation on an image): the gem remembers that the value is unavailable, so the validation keeps failing with `media_metadata_missing` but the file is only analyzed once. Files that yield no metadata at all — missing command-line tool, [timed out](#configuration) command, unreadable file — are not remembered and get analyzed again on the next validation.
+
 ---
 
 ### Attached
@@ -319,7 +334,8 @@ ActiveStorageValidations.configure { |config| config.infer_file_field_accept = f
 
 Notes:
 - Only broad MIME-type regexes of the form `/\Aimage\/.*\z/` (or `video` / `audio` / etc.) are inferred, as `image/*`
-- Other regexes (e.g. `/\Aimage\/(png|gif)\z/`) and Proc / dynamic `content_type` options are skipped, since they cannot be reliably represented in `accept`
+- Other regexes (e.g. `/\Aimage\/(png|gif)\z/`) are skipped, since they cannot be reliably represented in `accept`
+- Proc / dynamic `content_type` options are skipped: they are not called while the form renders, because their result can depend on record state that is only set on submit, and a raising proc would break the whole view for what is merely a frontend hint. Backend validation is unchanged; pass a custom `accept:` on those fields if you want the picker filtered
 - Conditional validators (`if:` / `unless:`) are not evaluated: their content types are always included in `accept`, even when the condition would skip the validator for that record. Backend validation is unchanged; use `infer_accept: false` (or a custom `accept:`) if the picker must match the active conditions
 
 #### Content type shorthands
@@ -364,7 +380,7 @@ Spoofing protection compares the declared Active Storage content type to a type
 
 Neither backend fully parses the file. They do **not** load the whole file into RAM. For already-persisted blobs (e.g. remote storage), the analyzer still downloads the blob to a local tempfile before sniffing. That download is streamed in chunks to disk, but it can still be costly for very large files. Local path uploads are analyzed in place.
 
-Detected types are cached on the blob as `asv_content_type` + `asv_content_type_backend`. Switching backend re-analyzes. Legacy blobs that only have `asv_content_type` (no backend key) are treated as `:file` and keep using the cache — they are not re-analyzed.
+Detected types are cached on the blob as `asv_content_type` + `asv_content_type_backend`. Switching backend re-analyzes. Legacy blobs that only have `asv_content_type` (no backend key) are treated as `:file` and keep using the cache — they are not re-analyzed. New (unsaved) blobs keep `asv_*` in memory until the record is saved; already-persisted blobs write the cache immediately so it survives `reload`.
 
 Sniffers will not always return the exact same MIME as Active Storage (AS uses first ~4kb + filename + extension). Close parent types are accepted via `Marcel::TYPE_PARENTS` (e.g. `video/x-ms-wmv` vs `video/x-ms-asf`).
 
@@ -648,7 +664,7 @@ The `duration` validator error messages expose 4 values that you can use:
 
 ### With audio
 
-Validates whether attached video files contain an audio track.
+Validates whether attached video / audio files contain an audio track.
 (be sure to have the right dependencies installed as mentioned in [Using video and audio metadata validators](#using-video-and-audio-metadata-validators))
 
 #### Options
@@ -671,7 +687,9 @@ class User < ApplicationRecord
 end
 ```
 
-Rails treats a bare `with_audio: false` as a disabled validator. Use the hash form `with_audio: { with: false }` to reject videos that contain audio.
+Rails treats a bare `with_audio: false` as a disabled validator. Use the hash form `with_audio: { with: false }` to reject files that contain audio.
+
+Files that cannot contain an audio stream at all (images, pdfs) are treated as having no audio track: they fail `with_audio: true` and pass `with_audio: { with: false }`.
 
 #### Error messages (I18n)
 
@@ -958,9 +976,6 @@ All matchers can currently be customized with these options:
 
 ```ruby
 describe User do
-  # :allow_blank
-  it { is_expected.to validate_attached_of(:avatar).allow_blank }
-
   # :on
   it { is_expected.to validate_attached_of(:avatar).on(:update) }
   it { is_expected.to validate_attached_of(:avatar).on(%i[update custom]) }
@@ -982,7 +997,7 @@ end
 ### Minitest
 
 #### Setup
-To use the matchers, make sure you have the [shoulda-context](https://github.com/thoughtbot/shoulda-context) gem up and running.
+To use the matchers, make sure you have the [shoulda-context](https://github.com/thoughtbot/shoulda-context) gem up and running. No extra mock library is required (`minitest-mock` is not needed on Minitest 6).
 
 You need to require the matchers:
 

data/config/locales/sv.yml

@@ -52,8 +52,8 @@ sv:
       aspect_ratio_not_square: "måste vara kvadratisk (nuvarande fil är %{width}x%{height} pixlar)"
       aspect_ratio_not_portrait: "måste vara porträtt (nuvarande fil är %{width}x%{height} pixlar)"
       aspect_ratio_not_landscape: "måste vara landskap (nuvarande fil är %{width}x%{height} pixlar)"
-      aspect_ratio_not_x_y: "måste vara% { authorized_aspect_ratios } (nuvarande fil är %{width}x%{height} pixlar)"
-      aspect_ratio_invalid: "har ett ogiltigt bildförhållande (giltiga bildförhållanden är %{förväntat_aspect_ratios})"
+      aspect_ratio_not_x_y: "måste vara %{authorized_aspect_ratios} (nuvarande fil är %{width}x%{height} pixlar)"
+      aspect_ratio_invalid: "har ett ogiltigt bildförhållande (giltiga bildförhållanden är %{authorized_aspect_ratios})"
       file_not_processable: "identifieras inte som en giltig mediefil"
       audio_missing: "måste innehålla ett ljudspår"
       audio_present: "får inte innehålla ett ljudspår"

data/lib/active_storage_validations/analyzer/audio_analyzer.rb

@@ -10,12 +10,13 @@ module ActiveStorageValidations
   # * Duration (seconds)
   # * Bit rate (bits/s)
   # * Sample rate (hertz)
+  # * Audio (true if file has an audio channel, false if not)
   # * Tags (internal metadata)
   #
   # Example:
   #
   #   ActiveStorageValidations::Analyzer::AudioAnalyzer.new(attachable).metadata
-  #   # => { duration: 5.0, bit_rate: 320340, sample_rate: 44100, tags: { encoder: "Lavc57.64", ... } }
+  #   # => { duration: 5.0, bit_rate: 320340, sample_rate: 44100, audio: true, tags: { encoder: "Lavc57.64", ... } }
   #
   # This analyzer requires the {FFmpeg}[https://www.ffmpeg.org] system library, which is not provided by \Rails.
   class Analyzer::AudioAnalyzer < Analyzer
@@ -27,6 +28,7 @@ module ActiveStorageValidations
           duration: duration,
           bit_rate: bit_rate,
           sample_rate: sample_rate,
+          audio: audio?,
           tags: tags
         }.compact
       end
@@ -34,6 +36,10 @@ module ActiveStorageValidations
 
     private
 
+    def audio?
+      audio_stream.present?
+    end
+
     def duration
       duration = audio_stream["duration"]
       Float(duration).round(1) if duration

data/lib/active_storage_validations/analyzer/content_type_analyzer/file.rb

@@ -5,8 +5,6 @@ module ActiveStorageValidations
   #
   # Override the binary path with +ActiveStorage.paths[:file]+.
   class Analyzer::ContentTypeAnalyzer::File < Analyzer::ContentTypeAnalyzer
-    class CommandLineToolNotInstalledError < StandardError; end
-
     private
 
     def backend

data/lib/active_storage_validations/analyzer/content_type_analyzer/magika.rb

@@ -7,8 +7,6 @@ module ActiveStorageValidations
   #
   # Override the binary path with +ActiveStorage.paths[:magika]+.
   class Analyzer::ContentTypeAnalyzer::Magika < Analyzer::ContentTypeAnalyzer
-    class CommandLineToolNotInstalledError < StandardError; end
-
     private
 
     def backend

data/lib/active_storage_validations/analyzer/content_type_analyzer.rb

@@ -12,6 +12,9 @@ module ActiveStorageValidations
   #   ActiveStorageValidations::Analyzer::ContentTypeAnalyzer::Magika.new(attachable).content_type
   #   # => { content_type: "image/png", content_type_backend: "magika" }
   class Analyzer::ContentTypeAnalyzer < Analyzer
+    # Shared by File and Magika backends so consumers can rescue either missing CLI.
+    class CommandLineToolNotInstalledError < StandardError; end
+
     def content_type
       read_media do |media|
         {

data/lib/active_storage_validations/analyzer/image_analyzer.rb

@@ -12,7 +12,15 @@ module ActiveStorageValidations
   #   ActiveStorageValidations::Analyzer::ImageAnalyzer::ImageMagick.new(attachable).metadata
   #   # => { width: 4104, height: 2736 }
   class Analyzer::ImageAnalyzer < Analyzer
-    @@supported_analyzers = {}
+    class << self
+      def reset_supported_analyzers_cache!
+        @supported_analyzers = {}
+      end
+
+      def supported_analyzers
+        @supported_analyzers ||= {}
+      end
+    end
 
     def metadata
       return {} unless analyzer_supported?
@@ -28,12 +36,14 @@ module ActiveStorageValidations
 
     private
 
+    # Cache by class, not instance: a new analyzer is built per attachable, so
+    # an instance-keyed hash never hits and retains every attachable for the
+    # process lifetime.
     def analyzer_supported?
-      if @@supported_analyzers.key?(self)
-        @@supported_analyzers.fetch(self)
-      else
-        @@supported_analyzers[self] = supported?
-      end
+      cache = Analyzer::ImageAnalyzer.supported_analyzers
+      return cache[self.class] if cache.key?(self.class)
+
+      cache[self.class] = supported?
     end
 
     # Override this method in a concrete subclass. Have it return true if the image is rotated.

data/lib/active_storage_validations/analyzer/pdf_analyzer.rb

@@ -16,6 +16,11 @@ module ActiveStorageValidations
   #
   # This analyzer requires the {poppler}[https://pdf2image.readthedocs.io/en/latest/installation.html] system library, which is not provided by \Rails.
   class Analyzer::PdfAnalyzer < Analyzer
+    # pdfinfo reports e.g. "595.276 x 841.89 pts (A4)". Capture the full
+    # integer or decimal so extra fractional digits are not split into a
+    # second number (which would make height 8 for A4).
+    PAGE_SIZE_NUMBER = /\d+(?:\.\d+)?/
+
     def metadata
       read_media do |media|
         {
@@ -69,11 +74,15 @@ module ActiveStorageValidations
     end
 
     def width
-      @media["page_size"].scan(/\d+\.?\d?/)[0].to_i
+      page_size_in_points[0]
     end
 
     def height
-      @media["page_size"].scan(/\d+\.?\d?/)[1].to_i
+      page_size_in_points[1]
+    end
+
+    def page_size_in_points
+      @media["page_size"].to_s.scan(PAGE_SIZE_NUMBER).map(&:to_i)
     end
 
     def pages

data/lib/active_storage_validations/analyzer.rb

@@ -40,45 +40,12 @@ module ActiveStorageValidations
       raise NotImplementedError
     end
 
-    # rubocop:disable Metrics/MethodLength
     def media(tempfile)
-      @media ||= case @attachable
-      when ActiveStorage::Blob, String
-        blob = @attachable.is_a?(String) ? ActiveStorage::Blob.find_signed!(@attachable) : @attachable
-        media_from_tempfile_path(tempfile, blob)
-      when Hash
-        io = @attachable[:io]
-        if io.is_a?(StringIO)
-          media_from_tempfile_path(tempfile, io)
-        else
-          File.open(io) do |file|
-            media_from_path(file.path)
-        end
-        end
-      when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
-        media_from_path(@attachable.path)
-      when File
-        supports_file_attachment? ? media_from_path(@attachable.path) : raise_rails_like_error(@attachable)
-      when Pathname
-        supports_pathname_attachment? ? media_from_path(@attachable.to_s) : raise_rails_like_error(@attachable)
-      else
-        raise_rails_like_error(@attachable)
+      @media ||= wrap_attachable(@attachable).with_media_path(tempfile) do |path|
+        media_from_path(path)
       end
     end
 
-    def media_from_tempfile_path(tempfile, file_representation)
-      if file_representation.is_a?(ActiveStorage::Blob)
-        file_representation.download { |chunk| tempfile.write(chunk) }
-      else
-        IO.copy_stream(file_representation, tempfile)
-        file_representation.rewind
-      end
-
-      tempfile.flush
-      tempfile.rewind
-      media_from_path(tempfile.path)
-    end
-
     # Override this method in a concrete subclass. Have it return a media object.
     def media_from_path(path)
       raise NotImplementedError

data/lib/active_storage_validations/aspect_ratio_validator.rb

@@ -18,7 +18,7 @@ module ActiveStorageValidations
 
     AVAILABLE_CHECKS = %i[with in].freeze
     NAMED_ASPECT_RATIOS = %i[square portrait landscape].freeze
-    ASPECT_RATIO_REGEX = /is_([1-9]\d*)_([1-9]\d*)/.freeze
+    ASPECT_RATIO_REGEX = /is_([1-9]\d*)_([1-9]\d*)/
     ERROR_TYPES = %i[
       aspect_ratio_not_square
       aspect_ratio_not_portrait
@@ -27,7 +27,7 @@ module ActiveStorageValidations
       aspect_ratio_invalid
       media_metadata_missing
     ].freeze
-    PRECISION = 3.freeze
+    PRECISION = 3
     METADATA_KEYS = %i[width height].freeze
 
     def check_validity!
@@ -38,22 +38,28 @@ module ActiveStorageValidations
     def validate_each(record, attribute, _value)
       return if no_attachments?(record, attribute)
 
-      flat_options = set_flat_options(record)
-      @authorized_aspect_ratios = authorized_aspect_ratios_from_options(flat_options).compact
-      return if @authorized_aspect_ratios.empty?
+      return if authorized_aspect_ratios(record).empty?
 
       validate_changed_files_from_metadata(record, attribute, METADATA_KEYS)
     end
 
     private
 
+    # Recomputed for every attachable rather than memoized on the validator:
+    # Active Model reuses one validator instance across records and threads, so
+    # per-validation state cannot live in an instance variable.
+    def authorized_aspect_ratios(record)
+      authorized_aspect_ratios_from_options(set_flat_options(record)).compact
+    end
+
     def is_valid?(record, attribute, attachable, metadata)
       media_metadata_present?(record, attribute, attachable, metadata) &&
         authorized_aspect_ratio?(record, attribute, attachable, metadata)
     end
 
     def authorized_aspect_ratio?(record, attribute, attachable, metadata)
-      attachable_aspect_ratio_is_authorized = @authorized_aspect_ratios.any? do |authorized_aspect_ratio|
+      aspect_ratios = authorized_aspect_ratios(record)
+      attachable_aspect_ratio_is_authorized = aspect_ratios.any? do |authorized_aspect_ratio|
         case authorized_aspect_ratio
         when :square then valid_square_aspect_ratio?(metadata)
         when :portrait then valid_portrait_aspect_ratio?(metadata)
@@ -64,18 +70,18 @@ module ActiveStorageValidations
 
       return true if attachable_aspect_ratio_is_authorized
 
-      errors_options = initialize_and_populate_error_options(options, attachable)
+      errors_options = initialize_and_populate_error_options(options, attachable, aspect_ratios)
       errors_options[:width] = metadata[:width]
       errors_options[:height] = metadata[:height]
-      error_type = aspect_ratio_error_mapping
+      error_type = aspect_ratio_error_mapping(aspect_ratios)
       add_error(record, attribute, error_type, **errors_options)
       false
     end
 
-    def aspect_ratio_error_mapping
-      return :aspect_ratio_invalid if @authorized_aspect_ratios.many?
+    def aspect_ratio_error_mapping(aspect_ratios)
+      return :aspect_ratio_invalid if aspect_ratios.many?
 
-      aspect_ratio = @authorized_aspect_ratios.first
+      aspect_ratio = aspect_ratios.first
       NAMED_ASPECT_RATIOS.include?(aspect_ratio) ? :"aspect_ratio_not_#{aspect_ratio}" : :aspect_ratio_not_x_y
     end
 
@@ -86,9 +92,9 @@ module ActiveStorageValidations
       false
     end
 
-    def initialize_and_populate_error_options(options, attachable)
+    def initialize_and_populate_error_options(options, attachable, aspect_ratios)
       errors_options = initialize_error_options(options, attachable)
-      errors_options[:authorized_aspect_ratios] = string_aspect_ratios
+      errors_options[:authorized_aspect_ratios] = string_aspect_ratios(aspect_ratios)
       errors_options
     end
 
@@ -140,8 +146,8 @@ module ActiveStorageValidations
       (Array.wrap(flat_options[:with]) + Array.wrap(flat_options[:in]))
     end
 
-    def string_aspect_ratios
-      @authorized_aspect_ratios.map do |aspect_ratio|
+    def string_aspect_ratios(aspect_ratios)
+      aspect_ratios.map do |aspect_ratio|
         if NAMED_ASPECT_RATIOS.include?(aspect_ratio)
           aspect_ratio
         else

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.rb

@@ -14,19 +14,30 @@ 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 }

data/lib/active_storage_validations/shared/asv_analyzable.rb

@@ -8,7 +8,11 @@ module ActiveStorageValidations
   module ASVAnalyzable
     extend ActiveSupport::Concern
 
-    DEFAULT_IMAGE_PROCESSOR = :mini_magick.freeze
+    DEFAULT_IMAGE_PROCESSOR = :mini_magick
+    # Keys written by the content-type sniffers. They record what the file
+    # claims to be, not whether an analyzer could decode it, so they must never
+    # count as evidence that a media analysis happened.
+    CONTENT_TYPE_METADATA_KEYS = %i[content_type content_type_backend].freeze
 
     private
 
@@ -21,13 +25,42 @@ module ActiveStorageValidations
         return content_type_metadata_for(blob, attachable)
       end
 
-      return blob.active_storage_validations_metadata if blob_has_asv_metadata?(blob, metadata_keys)
+      return media_metadata(blob) 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)
-      blob.save!
+      blob.merge_into_active_storage_validations_metadata(memoize_unavailable_keys(new_metadata, metadata_keys))
+      persist_asv_metadata(blob)
 
-      blob.active_storage_validations_metadata
+      media_metadata(blob)
+    end
+
+    # The metadata produced by the media analyzers, i.e. everything the blob
+    # carries except the content-type sniffer keys. Validators that ask for an
+    # empty METADATA_KEYS (ProcessableFileValidator) treat a non-empty result as
+    # proof that an analyzer decoded the file, so a cached +asv_content_type+
+    # left behind by spoofing_protection must not leak into it.
+    def media_metadata(blob)
+      blob.active_storage_validations_metadata.except(*CONTENT_TYPE_METADATA_KEYS)
+    end
+
+    # Analyzers only return the keys they could extract, so a requested key the
+    # analyzer cannot produce for this file (e.g. :duration for an image) would
+    # never be cached and the expensive analysis would run again on every
+    # validation. Store those keys as blank to memoize the miss: the validator
+    # still sees no usable value and adds its usual error, but only analyzes once.
+    #
+    # An entirely empty result means no analysis happened at all — missing CLI,
+    # timed out command, unreadable file — so it is left unmemoized and retried
+    # on the next validation.
+    #
+    # Teaching an existing analyzer a new metadata key therefore requires
+    # clearing the misses memoized by previous versions of the gem, see
+    # ASVBlobMetadatable#remove_active_storage_validations_metadata!.
+    def memoize_unavailable_keys(new_metadata, metadata_keys)
+      return new_metadata if new_metadata.blank?
+
+      unavailable_keys = metadata_keys.reject { |key| new_metadata.key?(key) }
+      new_metadata.merge(unavailable_keys.index_with(nil))
     end
 
     def content_type_metadata_keys?(metadata_keys)
@@ -48,11 +81,20 @@ module ActiveStorageValidations
       return failed_content_type_metadata(backend) if content_type_analysis_failed?(new_metadata)
 
       blob.merge_into_active_storage_validations_metadata(new_metadata)
-      blob.save!
+      persist_asv_metadata(blob)
 
       blob.active_storage_validations_metadata
     end
 
+    # A bare +valid?+ on a new record must not INSERT an +active_storage_blobs+
+    # row (no file on the service, orphaned if the record is never saved).
+    # In-memory +asv_*+ on the unsaved blob is persisted by Rails when the
+    # record is saved. Already-persisted blobs (re-validation, attach after
+    # save, pre-v2 blobs) still need +save!+ so the cache survives +reload+.
+    def persist_asv_metadata(blob)
+      blob.save! if blob.persisted?
+    end
+
     def content_type_analysis_failed?(new_metadata)
       new_metadata.blank? || new_metadata[:content_type].blank?
     end
@@ -74,9 +116,10 @@ module ActiveStorageValidations
     end
 
     def blob_has_asv_metadata?(blob, metadata_keys)
-      return false unless blob.active_storage_validations_metadata.present?
+      cached = media_metadata(blob)
+      return false unless cached.present?
 
-      metadata_keys.all? { |key| blob.active_storage_validations_metadata.key?(key) }
+      metadata_keys.all? { |key| cached.key?(key) }
     end
 
     def generate_metadata_for(attachable, metadata_keys)

data/lib/active_storage_validations/shared/asv_attachable.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../asv_attachable_adapter"
+
 module ActiveStorageValidations
   # ActiveStorageValidations::ASVAttachable
   #
@@ -66,35 +68,17 @@ module ActiveStorageValidations
       end
     end
 
-    # Retrieve the full declared content_type from attachable.
-    # rubocop:disable Metrics/MethodLength
     def full_attachable_content_type(attachable)
-      case attachable
-      when ActiveStorage::Blob
-        attachable.content_type
-      when ActionDispatch::Http::UploadedFile
-        attachable.content_type
-      when Rack::Test::UploadedFile
-        attachable.content_type
-      when String
-        blob = ActiveStorage::Blob.find_signed!(attachable)
-        blob.content_type
-      when Hash
-        attachable[:content_type]
-      when File
-        supports_file_attachment? ? marcel_content_type_from_filename(attachable) : raise_rails_like_error(attachable)
-      when Pathname
-        supports_pathname_attachment? ? marcel_content_type_from_filename(attachable) : raise_rails_like_error(attachable)
-      else
-        raise_rails_like_error(attachable)
-      end
+      wrap_attachable(attachable).content_type
     end
-    # rubocop:enable Metrics/MethodLength
 
     # Retrieve the declared content_type from attachable without potential mime
     # type parameters (e.g. 'application/x-rar-compressed;version=5')
     def attachable_content_type(attachable)
-      (full_attachable_content_type(attachable) && content_type_without_parameters(full_attachable_content_type(attachable)) || marcel_content_type_from_filename(attachable))
+      declared_content_type = full_attachable_content_type(attachable)
+
+      (declared_content_type && content_type_without_parameters(declared_content_type)) ||
+        marcel_content_type_from_filename(attachable)
     end
 
     # Remove the potential mime type parameters from the content_type (e.g.
@@ -120,90 +104,23 @@ module ActiveStorageValidations
       (full_attachable_content_type(attachable) || marcel_content_type_from_filename(attachable)).split("/").first
     end
 
-    # Retrieve the io from attachable.
-    # rubocop:disable Metrics/MethodLength
-    # rubocop:disable Metrics/AbcSize
     def attachable_io(attachable, max_byte_size: nil)
-      io = case attachable
-      when ActiveStorage::Blob
-        max_byte_size ? attachable.download_chunk(0...max_byte_size) : attachable.download
-      when ActionDispatch::Http::UploadedFile
-        max_byte_size ? attachable.read(max_byte_size) : attachable.read
-      when Rack::Test::UploadedFile
-        max_byte_size ? attachable.read(max_byte_size) : attachable.read
-      when String
-        blob = ActiveStorage::Blob.find_signed!(attachable)
-        max_byte_size ? blob.download_chunk(0...max_byte_size) : blob.download
-      when Hash
-        max_byte_size ? attachable[:io].read(max_byte_size) : attachable[:io].read
-      when File
-        raise_rails_like_error(attachable) unless supports_file_attachment?
-        max_byte_size ? attachable.read(max_byte_size) : attachable.read
-      when Pathname
-        raise_rails_like_error(attachable) unless supports_pathname_attachment?
-        max_byte_size ? attachable.read(max_byte_size) : attachable.read
-      else
-        raise_rails_like_error(attachable)
-      end
-
-      rewind_attachable_io(attachable)
+      wrapped = wrap_attachable(attachable)
+      io = wrapped.read(max_byte_size: max_byte_size)
+      wrapped.rewind
       io
     end
-    # rubocop:enable Metrics/MethodLength
-    # rubocop:enable Metrics/AbcSize
 
-    # Rewind the io attachable.
     def rewind_attachable_io(attachable)
-      case attachable
-      when ActiveStorage::Blob, String
-        # nothing to do
-      when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
-        attachable.rewind
-      when Hash
-        attachable[:io].rewind
-      when File
-        raise_rails_like_error(attachable) unless supports_file_attachment?
-        attachable.rewind
-      when Pathname
-        raise_rails_like_error(attachable) unless supports_pathname_attachment?
-        File.open(attachable) { |f| f.rewind }
-      else
-        raise_rails_like_error(attachable)
-      end
+      wrap_attachable(attachable).rewind
     end
 
-    # Retrieve the declared filename from attachable.
-    # rubocop:disable Metrics/MethodLength
     def attachable_filename(attachable)
-      case attachable
-      when ActiveStorage::Blob
-        attachable.filename
-      when ActionDispatch::Http::UploadedFile
-        attachable.original_filename
-      when Rack::Test::UploadedFile
-        attachable.original_filename
-      when String
-        blob = ActiveStorage::Blob.find_signed!(attachable)
-        blob.filename
-      when Hash
-        attachable[:filename]
-      when File
-        supports_file_attachment? ? File.basename(attachable) : raise_rails_like_error(attachable)
-      when Pathname
-        supports_pathname_attachment? ? File.basename(attachable) : raise_rails_like_error(attachable)
-      else
-        raise_rails_like_error(attachable)
-      end
+      wrap_attachable(attachable).filename
     end
-    # rubocop:enable Metrics/MethodLength
 
-    # Raise the same Rails error for not-implemented file representations.
-    def raise_rails_like_error(attachable)
-      raise(
-        ArgumentError,
-        "Could not find or build blob: expected attachable, " \
-          "got #{attachable.inspect}"
-      )
+    def wrap_attachable(attachable)
+      ASVAttachableAdapter.wrap(attachable, file_supported: supports_file_attachment?)
     end
 
     # Check if the current Rails version supports File or Pathname attachment

data/lib/active_storage_validations/shared/asv_errorable.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../asv_attachable_adapter"
+
 module ActiveStorageValidations
   module ASVErrorable
     extend ActiveSupport::Concern
@@ -17,9 +19,9 @@ module ActiveStorageValidations
       curated_options.merge(active_storage_validations_options)
     end
 
+    # Every offending file gets its own error, so a has_many_attached relation
+    # reports each invalid filename rather than only the first one.
     def add_error(record, attribute, error_type, **errors_options)
-      return if record.errors.added?(attribute, error_type)
-
       # You can read https://api.rubyonrails.org/classes/ActiveModel/Errors.html#method-i-add
       # to better understand how Rails model errors work
       record.errors.add(attribute, error_type, **errors_options)
@@ -30,12 +32,11 @@ module ActiveStorageValidations
     def get_filename(file)
       return nil unless file
 
-      case file
-      when ActiveStorage::Attached, ActiveStorage::Attachment then file.blob&.filename&.to_s
-      when ActiveStorage::Blob then file.filename
-      when String then ActiveStorage::Blob.find_signed!(file)&.filename
-      when Hash then file[:filename]
-      end.to_s
+      filename_from(file)&.to_s.presence
+    end
+
+    def filename_from(file)
+      ASVAttachableAdapter.filename_for(file)
     end
   end
 end

data/lib/active_storage_validations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveStorageValidations
-  VERSION = "4.1.0"
+  VERSION = "4.1.1"
 end

data/lib/active_storage_validations/with_audio_validator.rb

@@ -27,11 +27,17 @@ module ActiveStorageValidations
 
     def is_valid?(record, attribute, attachable, metadata)
       expected_audio = options.fetch(:with, true)
-      return if metadata&.fetch(:audio, false) == expected_audio
+      return if audio_track?(metadata) == expected_audio
 
       errors_options = initialize_error_options(options, attachable)
       error_type = expected_audio ? :audio_missing : :audio_present
       add_error(record, attribute, error_type, **errors_options)
     end
+
+    # Files the analyzer cannot inspect for audio streams (images, pdfs) have no
+    # audio metadata, or a memoized unavailable value. Both mean no audio track.
+    def audio_track?(metadata)
+      metadata&.fetch(:audio, false) == true
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_storage_validations
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 4.1.1
 platform: ruby
 authors:
 - Igor Kasyanchuk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-18 00:00:00.000000000 Z
+date: 2026-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -233,6 +233,7 @@ files:
 - lib/active_storage_validations/analyzer/shared/asv_ff_probable.rb
 - lib/active_storage_validations/analyzer/video_analyzer.rb
 - lib/active_storage_validations/aspect_ratio_validator.rb
+- lib/active_storage_validations/asv_attachable_adapter.rb
 - lib/active_storage_validations/attached_validator.rb
 - lib/active_storage_validations/base_comparison_validator.rb
 - lib/active_storage_validations/content_type_validator.rb