active_storage_validations 4.0.0 → 4.1.1

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.0.0"
+  VERSION = "4.1.1"
 end

data/lib/active_storage_validations/with_audio_validator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "shared/asv_active_storageable"
+require_relative "shared/asv_analyzable"
+require_relative "shared/asv_attachable"
+require_relative "shared/asv_errorable"
+require_relative "shared/asv_symbolizable"
+
+module ActiveStorageValidations
+  class WithAudioValidator < ActiveModel::EachValidator # :nodoc
+    include ASVActiveStorageable
+    include ASVAnalyzable
+    include ASVAttachable
+    include ASVErrorable
+    include ASVSymbolizable
+
+    ERROR_TYPES = %i[audio_missing audio_present].freeze
+    METADATA_KEYS = %i[audio].freeze
+
+    def validate_each(record, attribute, _value)
+      return if no_attachments?(record, attribute)
+
+      validate_changed_files_from_metadata(record, attribute, METADATA_KEYS)
+    end
+
+    private
+
+    def is_valid?(record, attribute, attachable, metadata)
+      expected_audio = options.fetch(:with, true)
+      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

data/lib/active_storage_validations.rb

@@ -41,6 +41,7 @@ require "active_storage_validations/content_type_validator"
 require "active_storage_validations/limit_validator"
 require "active_storage_validations/dimension_validator"
 require "active_storage_validations/duration_validator"
+require "active_storage_validations/with_audio_validator"
 require "active_storage_validations/aspect_ratio_validator"
 require "active_storage_validations/processable_file_validator"
 require "active_storage_validations/size_validator"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_storage_validations
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.1.1
 platform: ruby
 authors:
 - Igor Kasyanchuk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-02 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
@@ -265,6 +266,7 @@ files:
 - lib/active_storage_validations/matchers/shared/asv_validatable.rb
 - lib/active_storage_validations/matchers/size_validator_matcher.rb
 - lib/active_storage_validations/matchers/total_size_validator_matcher.rb
+- lib/active_storage_validations/matchers/with_audio_validator_matcher.rb
 - lib/active_storage_validations/pages_validator.rb
 - lib/active_storage_validations/processable_file_validator.rb
 - lib/active_storage_validations/railtie.rb
@@ -279,6 +281,7 @@ files:
 - lib/active_storage_validations/size_validator.rb
 - lib/active_storage_validations/total_size_validator.rb
 - lib/active_storage_validations/version.rb
+- lib/active_storage_validations/with_audio_validator.rb
 homepage: https://github.com/igorkasyanchuk/active_storage_validations
 licenses:
 - MIT