active_storage_validations 3.0.6 → 4.0.0

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  # Content-type sniffer using the UNIX {file}[https://en.wikipedia.org/wiki/File_(command)] command.
+  #
+  # Override the binary path with +ActiveStorage.paths[:file]+.
+  class Analyzer::ContentTypeAnalyzer::File < Analyzer::ContentTypeAnalyzer
+    class CommandLineToolNotInstalledError < StandardError; end
+
+    private
+
+    def backend
+      :file
+    end
+
+    def media_from_path(path)
+      instrument("file") do |payload|
+        result = run_command(file_path, "-b", "--mime-type", path, payload: payload)
+        result.success? ? result.stdout.strip : nil
+      end
+    end
+
+    def file_path
+      ActiveStorage.paths[:file] || "file"
+    end
+
+    def missing_backend_error
+      CommandLineToolNotInstalledError.new("file command-line tool is not installed")
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ActiveStorageValidations
+  # Content-type sniffer using the Google {Magika}[https://github.com/google/magika] CLI.
+  #
+  # Override the binary path with +ActiveStorage.paths[:magika]+.
+  class Analyzer::ContentTypeAnalyzer::Magika < Analyzer::ContentTypeAnalyzer
+    class CommandLineToolNotInstalledError < StandardError; end
+
+    private
+
+    def backend
+      :magika
+    end
+
+    def media_from_path(path)
+      instrument("magika") do |payload|
+        result = run_command(magika_path, "--json", path, payload: payload)
+        result.success? ? mime_type_from_magika_json(result.stdout) : nil
+      end
+    end
+
+    def mime_type_from_magika_json(stdout)
+      parsed = JSON.parse(stdout)
+      entry = parsed.is_a?(Array) ? parsed.first : parsed
+      return nil unless entry.is_a?(Hash)
+      return nil unless entry.dig("result", "status") == "ok"
+
+      entry.dig("result", "value", "output", "mime_type").presence
+    rescue JSON::ParserError
+      nil
+    end
+
+    def magika_path
+      ActiveStorage.paths[:magika] || "magika"
+    end
+
+    def missing_backend_error
+      CommandLineToolNotInstalledError.new("magika command-line tool is not installed")
+    end
+  end
+end

data/lib/active_storage_validations/analyzer/content_type_analyzer.rb

@@ -1,26 +1,22 @@
 # frozen_string_literal: true
 
-require "open3"
-
 module ActiveStorageValidations
   # = ActiveStorageValidations ContentType \Analyzer
   #
-  # Extracts the content type from an attachable. This is used to prevent content
-  # type spoofing.
-  #
-  # Example:
+  # Abstract base for content-type sniffers used by +spoofing_protection+.
+  # Concrete backends:
   #
-  #   ActiveStorageValidations::Analyzer::ContentTypeAnalyzer.new(attachable).content_type
-  #   # => { content_type: "image/png" }
+  #   ActiveStorageValidations::Analyzer::ContentTypeAnalyzer::File.new(attachable).content_type
+  #   # => { content_type: "image/png", content_type_backend: "file" }
   #
-  # This analyzer requires the {UNIX file}[https://en.wikipedia.org/wiki/File_(command)] command, which is not provided by \Rails. While it is available on most UNIX distributions, it may need to be installed explicitly on minimal or custom setups.
+  #   ActiveStorageValidations::Analyzer::ContentTypeAnalyzer::Magika.new(attachable).content_type
+  #   # => { content_type: "image/png", content_type_backend: "magika" }
   class Analyzer::ContentTypeAnalyzer < Analyzer
-    class FileCommandLineToolNotInstalledError < StandardError; end
-
     def content_type
       read_media do |media|
         {
-          content_type: media
+          content_type: media,
+          content_type_backend: backend.to_s
         }
       end
     end
@@ -33,7 +29,7 @@ module ActiveStorageValidations
           if media(tempfile).present?
             yield media(tempfile)
           else
-            logger.info "Skipping file content_type analysis because Linux file command doesn't support the file"
+            logger.info "Skipping content_type analysis because #{backend} doesn't support the file"
             nil
           end
         ensure
@@ -41,20 +37,15 @@ module ActiveStorageValidations
         end
       end
     rescue Errno::ENOENT
-      raise FileCommandLineToolNotInstalledError, "file command-line tool is not installed"
+      raise missing_backend_error
     end
 
-    def media_from_path(path)
-      instrument("file") do
-        stdout, status = Open3.capture2(
-          "file",
-          "-b",
-          "--mime-type",
-          path
-        )
+    def backend
+      raise NotImplementedError
+    end
 
-        status.success? ? stdout.strip : nil
-      end
+    def missing_backend_error
+      raise NotImplementedError
     end
   end
 end

data/lib/active_storage_validations/analyzer/image_analyzer/image_magick.rb

@@ -1,17 +1,30 @@
 # frozen_string_literal: true
 
 module ActiveStorageValidations
-  # This analyzer relies on the third-party {MiniMagick}[https://github.com/minimagick/minimagick] gem.
+  # This analyzer relies on the third-party {MiniMagick}[https://github.com/minimagick/minimagick] gem
+  # only to resolve the ImageMagick / GraphicsMagick +identify+ argv. Commands are executed through
+  # {ASVCommandable#run_command} so +command_timeout+ can kill hung processes.
   # MiniMagick requires the {ImageMagick}[http://www.imagemagick.org] system library.
   # This is the default Rails image analyzer.
   class Analyzer::ImageAnalyzer::ImageMagick < Analyzer::ImageAnalyzer
+    ImageInfo = Struct.new(:width, :height, :orientation, keyword_init: true) do
+      def valid?
+        width.to_i.positive? && height.to_i.positive?
+      end
+
+      def [](key)
+        orientation if key == "%[orientation]"
+      end
+    end
+
     private
 
     def read_media
       Tempfile.create(binmode: true) do |tempfile|
         begin
-          if media(tempfile).valid?
-            yield media(tempfile)
+          info = media(tempfile)
+          if info&.valid?
+            yield info
           else
             logger.info "Skipping image analysis because ImageMagick doesn't support the file"
             {}
@@ -20,17 +33,38 @@ module ActiveStorageValidations
           tempfile.close
         end
       end
-    rescue MiniMagick::Error => error
-      logger.error "Skipping image analysis due to an ImageMagick error: #{error.message}"
+    rescue Errno::ENOENT
+      logger.info "Skipping image analysis because ImageMagick isn't installed"
       {}
     end
 
     def media_from_path(path)
-      instrument("mini_magick") do
-        MiniMagick::Image.new(path)
+      instrument("mini_magick") do |payload|
+        result = run_command(*identify_command(path), payload: payload)
+        return nil unless result.success?
+
+        parse_identify_output(result.stdout)
       end
     end
 
+    def identify_command(path)
+      require "mini_magick"
+
+      tool = ::MiniMagick::Tool.new("identify")
+      tool.format("%w\t%h\t%[orientation]")
+      tool << path
+      tool.command
+    end
+
+    def parse_identify_output(stdout)
+      width, height, orientation = stdout.to_s.strip.split("\t", 3)
+      ImageInfo.new(
+        width: width.to_i,
+        height: height.to_i,
+        orientation: orientation.to_s
+      )
+    end
+
     def rotated_image?(image)
       %w[ RightTop LeftBottom TopRight BottomLeft ].include?(image["%[orientation]"])
     end

data/lib/active_storage_validations/analyzer/image_analyzer/vips.rb

@@ -16,6 +16,9 @@ module ActiveStorageValidations
             {}
           end
         ensure
+          # Best-effort: avoid unlinking the tempfile while a timed-out FFI load
+          # may still be using the path.
+          wait_for_vips_load_thread
           tempfile.close
         end
       end
@@ -25,19 +28,42 @@ module ActiveStorageValidations
     end
 
     def media_from_path(path)
-      instrument("vips") do
-        begin
-          ::Vips::Image.new_from_file(path, access: :sequential)
-        rescue ::Vips::Error
-          # Vips throw errors rather than returning false when reading a not
-          # supported attachable.
-          # We stumbled upon this issue while reading 0 byte size attachable
-          # https://github.com/janko/image_processing/issues/97
-          nil
-        end
+      instrument("vips") do |payload|
+        load_vips_image(path, payload)
+      end
+    end
+
+    def load_vips_image(path, payload)
+      timeout = timeout_in_seconds
+      return open_vips_image(path) if timeout.nil?
+
+      result = nil
+      @vips_load_thread = Thread.new { result = open_vips_image(path) }
+
+      if @vips_load_thread.join(timeout)
+        result
+      else
+        # libvips work may continue in the background until the C call returns.
+        mark_timed_out!(payload, "vips")
+        nil
       end
     end
 
+    def wait_for_vips_load_thread
+      return unless @vips_load_thread&.alive?
+
+      @vips_load_thread.join(0.5)
+    end
+
+    # Returns nil for unsupported / empty files instead of raising.
+    # Vips raises on unreadable input (e.g. 0-byte files) rather than returning
+    # a falsy image — see https://github.com/janko/image_processing/issues/97
+    def open_vips_image(path)
+      ::Vips::Image.new_from_file(path, access: :sequential)
+    rescue ::Vips::Error
+      nil
+    end
+
     ROTATIONS = /Right-top|Left-bottom|Top-right|Bottom-left/
     def rotated_image?(image)
       ROTATIONS === image.get("exif-ifd0-Orientation")

data/lib/active_storage_validations/analyzer/pdf_analyzer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "open3"
-
 module ActiveStorageValidations
   # = ActiveStorageValidations PDF \Analyzer
   #
@@ -49,13 +47,9 @@ module ActiveStorageValidations
     end
 
     def media_from_path(path)
-      instrument(File.basename(pdfinfo_path)) do
-        stdout, _stderr, status = Open3.capture3(
-          pdfinfo_path,
-          path
-        )
-
-        status.success? ? stdout_to_hash(stdout) : nil
+      instrument(File.basename(pdfinfo_path)) do |payload|
+        result = run_command(pdfinfo_path, path, payload: payload)
+        result.success? ? stdout_to_hash(result.stdout) : nil
       end
     end
 

data/lib/active_storage_validations/analyzer/shared/asv_ff_probable.rb

@@ -28,17 +28,18 @@ module ActiveStorageValidations
     end
 
     def media_from_path(path)
-      instrument(File.basename(ffprobe_path)) do
-        stdout, _stderr, status = Open3.capture3(
+      instrument(File.basename(ffprobe_path)) do |payload|
+        result = run_command(
           ffprobe_path,
           "-print_format", "json",
           "-show_streams",
           "-show_format",
           "-v", "error",
-          path
+          path,
+          payload: payload
         )
 
-        status.success? ? JSON.parse(stdout) : nil
+        result.success? ? JSON.parse(result.stdout) : nil
       end
     end
 

data/lib/active_storage_validations/analyzer/video_analyzer.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "open3"
 require_relative "shared/asv_ff_probable"
 
 module ActiveStorageValidations

data/lib/active_storage_validations/analyzer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "shared/asv_attachable"
+require_relative "shared/asv_commandable"
 require_relative "shared/asv_loggable"
 
 module ActiveStorageValidations
@@ -12,12 +13,14 @@ module ActiveStorageValidations
   # Heavily (not to say 100%) inspired by Rails own ActiveStorage::Analyzer
   class Analyzer
     include ASVAttachable
+    include ASVCommandable
     include ASVLoggable
 
     attr_reader :attachable
 
-    def initialize(attachable)
+    def initialize(attachable, timeout: ActiveStorageValidations.command_timeout)
       @attachable = attachable
+      @timeout = timeout
     end
 
     # Override this method in a concrete subclass. Have it return a String content type.
@@ -81,8 +84,37 @@ module ActiveStorageValidations
       raise NotImplementedError
     end
 
-    def instrument(analyzer, &block)
-      ActiveSupport::Notifications.instrument("analyze.active_storage_validations", analyzer: analyzer, &block)
+    def timeout_in_seconds
+      return nil if @timeout.nil?
+
+      @timeout.to_f
+    end
+
+    def instrument(analyzer)
+      payload = {
+        analyzer: analyzer,
+        command: analyzer,
+        timeout: timeout_in_seconds,
+        timed_out: false
+      }
+
+      ActiveSupport::Notifications.instrument("analyze.active_storage_validations", payload) do
+        started_at = monotonic_time
+        result = yield payload
+        payload[:duration] = monotonic_time - started_at
+        result
+      end
+    end
+
+    def mark_timed_out!(payload, command)
+      payload[:timed_out] = true if payload
+      ActiveSupport::Notifications.instrument(
+        "timeout.active_storage_validations",
+        analyzer: payload&.[](:analyzer) || command,
+        command: command,
+        timeout: timeout_in_seconds
+      )
+      logger.info "Skipping file analysis because #{command} timed out after #{timeout_in_seconds} seconds"
     end
   end
 end

data/lib/active_storage_validations/content_type_validator.rb

@@ -6,7 +6,6 @@ require_relative "shared/asv_attachable"
 require_relative "shared/asv_errorable"
 require_relative "shared/asv_optionable"
 require_relative "shared/asv_symbolizable"
-require_relative "analyzer/content_type_analyzer"
 
 module ActiveStorageValidations
   class ContentTypeValidator < ActiveModel::EachValidator # :nodoc:
@@ -18,6 +17,7 @@ module ActiveStorageValidations
     include ASVSymbolizable
 
     AVAILABLE_CHECKS = %i[with in].freeze
+    AVAILABLE_SPOOFING_PROTECTION_VALUES = [ true, false, :file, :magika ].freeze
     ERROR_TYPES = %i[
       content_type_invalid
       content_type_spoofed
@@ -27,6 +27,7 @@ module ActiveStorageValidations
     def check_validity!
       ensure_exactly_one_validator_option
       ensure_content_types_validity
+      ensure_spoofing_protection_validity
     end
 
     def validate_each(record, attribute, _value)
@@ -125,7 +126,25 @@ module ActiveStorageValidations
     end
 
     def enable_spoofing_protection?
-      options[:spoofing_protection] == true
+      spoofing_protection_backend.present?
+    end
+
+    # +true+ and +:file+ both select the UNIX +file+ CLI; +:magika+ selects Magika.
+    def spoofing_protection_backend
+      case options[:spoofing_protection]
+      when true, :file then :file
+      when :magika then :magika
+      end
+    end
+
+    def ensure_spoofing_protection_validity
+      return unless options.key?(:spoofing_protection)
+      return if AVAILABLE_SPOOFING_PROTECTION_VALUES.include?(options[:spoofing_protection])
+
+      raise ArgumentError, <<~ERROR_MESSAGE
+        Unknown spoofing_protection option: #{options[:spoofing_protection].inspect}.
+        Allowed values: #{AVAILABLE_SPOOFING_PROTECTION_VALUES.map(&:inspect).join(", ")}
+      ERROR_MESSAGE
     end
 
     def attachable_content_type_vs_detected_content_type_mismatch?
@@ -134,10 +153,9 @@ module ActiveStorageValidations
     end
 
     def attachable_content_type_intersects_detected_content_type?
-      # Ruby intersects? method is only available from 3.1
-      enlarged_content_type(content_type_without_parameters(@attachable_content_type)).any? do |item|
-        enlarged_content_type(content_type_without_parameters(@detected_content_type)).include?(item)
-      end
+      enlarged_content_type(content_type_without_parameters(@attachable_content_type)).intersect?(
+        enlarged_content_type(content_type_without_parameters(@detected_content_type))
+      )
     end
 
     def enlarged_content_type(content_type)

data/lib/active_storage_validations/dimension_validator.rb

@@ -215,8 +215,10 @@ module ActiveStorageValidations
 
       %i[min max].each do |bound|
         if (range = flat_options[bound])
-          flat_options[:width] = { bound => range.first }
-          flat_options[:height] = { bound => range.last }
+          flat_options[:width] ||= {}
+          flat_options[:height] ||= {}
+          flat_options[:width][bound] = range.first
+          flat_options[:height][bound] = range.last
         end
       end
 

data/lib/active_storage_validations/form_builder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  module FormBuilder
+    def file_field(method, options = {})
+      options = options.symbolize_keys
+      infer_accept = options.delete(:infer_accept)
+      infer_accept = ActiveStorageValidations.infer_file_field_accept if infer_accept.nil?
+
+      if infer_accept && !options.key?(:accept)
+        accept = inferred_accept_types(method)
+        options[:accept] = accept.join(",") if accept.any?
+      end
+
+      super(method, options)
+    end
+
+    private
+
+    def inferred_accept_types(method)
+      return [] unless @object.class.respond_to?(:validators_on)
+
+      content_type_validators = @object.class.validators_on(method).select do |v|
+        v.is_a?(ActiveStorageValidations::ContentTypeValidator)
+      end
+
+      content_type_validators.flat_map do |validator|
+        types = Array(validator.options[:with]) + Array(validator.options[:in])
+        types.filter_map do |type|
+          case type
+          when String
+            type.include?("/") ? type : Marcel::MimeType.for(declared_type: type, extension: type)
+          when Symbol
+            Marcel::MimeType.for(declared_type: type.to_s, extension: type.to_s)
+          when Regexp
+            match = type.source.match(%r{\A\\A([a-z]+)/\.\*\\z\z})
+            "#{match[1]}/*" if match
+          end
+        end
+      end.uniq
+    end
+  end
+end

data/lib/active_storage_validations/matchers/aspect_ratio_validator_matcher.rb

@@ -4,8 +4,10 @@ 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
@@ -19,15 +21,19 @@ module ActiveStorageValidations
       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
         @allowed_aspect_ratios = @rejected_aspect_ratios = []
       end
@@ -55,7 +61,9 @@ 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? &&
           all_allowed_aspect_ratios_allowed? &&
           all_rejected_aspect_ratios_rejected?

data/lib/active_storage_validations/matchers/attached_validator_matcher.rb

@@ -3,6 +3,7 @@
 require_relative "shared/asv_active_storageable"
 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_validatable"
@@ -17,12 +18,14 @@ module ActiveStorageValidations
       include ASVActiveStorageable
       include ASVAttachable
       include ASVContextable
+      include ASVExceptOnable
       include ASVMessageable
       include ASVRspecable
       include ASVValidatable
 
       def initialize(attribute_name)
         initialize_contextable
+        initialize_except_onable
         initialize_messageable
         initialize_rspecable
         @attribute_name = attribute_name
@@ -41,6 +44,7 @@ module ActiveStorageValidations
 
         is_a_valid_active_storage_attribute? &&
           is_context_valid? &&
+          is_except_on_valid? &&
           is_custom_message_valid? &&
           is_valid_when_file_attached? &&
           is_invalid_when_file_not_attached?

data/lib/active_storage_validations/matchers/base_comparison_validator_matcher.rb

@@ -7,6 +7,7 @@ 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_validatable"
@@ -20,6 +21,7 @@ module ActiveStorageValidations
       include ASVAllowBlankable
       include ASVAttachable
       include ASVContextable
+      include ASVExceptOnable
       include ASVMessageable
       include ASVRspecable
       include ASVValidatable
@@ -27,6 +29,7 @@ module ActiveStorageValidations
       def initialize(attribute_name)
         initialize_allow_blankable
         initialize_contextable
+        initialize_except_onable
         initialize_messageable
         initialize_rspecable
         @attribute_name = attribute_name
@@ -68,17 +71,24 @@ module ActiveStorageValidations
 
         is_a_valid_active_storage_attribute? &&
           is_context_valid? &&
+          is_except_on_valid? &&
           is_allowing_blank? &&
           is_custom_message_valid? &&
           not_lower_than_min? &&
           higher_than_min? &&
           lower_than_max? &&
           not_higher_than_max? &&
-          equal_to_exact?
+          equal_to_exact? &&
+          is_timeout_valid?
       end
 
       protected
 
+      # Hook for ASVTimeoutable (Duration / Pages). Size / TotalSize leave this as-is.
+      def is_timeout_valid?
+        true
+      end
+
       def build_failure_message(message)
         return unless @failure_message_artefacts.present?