active_storage_validations 1.3.5 → 2.0.0

data/lib/active_storage_validations/analyzer/image_analyzer.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveStorageValidations
-  # = Active Storage Image \Analyzer
+  # = ActiveStorageValidations Image \Analyzer
   #
   # This is an abstract base class for image analyzers, which extract width and height from an image attachable.
   #
@@ -9,68 +9,40 @@ module ActiveStorageValidations
   #
   # Example:
   #
-  #   ActiveStorage::Analyzer::ImageAnalyzer::ImageMagick.new(attachable).metadata
+  #   ActiveStorageValidations::Analyzer::ImageAnalyzer::ImageMagick.new(attachable).metadata
   #   # => { width: 4104, height: 2736 }
   class Analyzer::ImageAnalyzer < Analyzer
+    @@supported_analyzers = {}
+
     def metadata
-      read_image do |image|
-        if rotated_image?(image)
-          { width: image.height, height: image.width }
+      return {} unless analyzer_supported?
+
+      read_media do |media|
+        if rotated_image?(media)
+          { width: media.height, height: media.width }
         else
-          { width: image.width, height: image.height }
+          { width: media.width, height: media.height }
         end
       end
     end
 
     private
 
-    def image(tempfile)
-      case @attachable
-      when ActiveStorage::Blob, String
-        blob = @attachable.is_a?(String) ? ActiveStorage::Blob.find_signed!(@attachable) : @attachable
-        image_from_tempfile_path(tempfile, blob)
-      when Hash
-        io = @attachable[:io]
-        if io.is_a?(StringIO)
-          image_from_tempfile_path(tempfile, io)
-        else
-          File.open(io) do |file|
-            image_from_path(file.path)
-          end
-        end
-      when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
-        image_from_path(@attachable.path)
-      when File
-        supports_file_attachment? ? image_from_path(@attachable.path) : raise_rails_like_error(@attachable)
-      when Pathname
-        supports_pathname_attachment? ? image_from_path(@attachable.to_s) : raise_rails_like_error(@attachable)
-      else
-        raise_rails_like_error(@attachable)
-      end
-    end
-
-    def image_from_tempfile_path(tempfile, file_representation)
-      if file_representation.is_a?(ActiveStorage::Blob)
-        file_representation.download { |chunk| tempfile.write(chunk) }
+    def analyzer_supported?
+      if @@supported_analyzers.key?(self)
+        @@supported_analyzers.fetch(self)
       else
-        IO.copy_stream(file_representation, tempfile)
-        file_representation.rewind
+        @@supported_analyzers[self] = supported?
       end
-
-      tempfile.flush
-      tempfile.rewind
-      image_from_path(tempfile.path)
-    end
-
-    def read_image
-      raise NotImplementedError
     end
 
-    def image_from_path(path)
+    # Override this method in a concrete subclass. Have it return true if the image is rotated.
+    def rotated_image?(media)
       raise NotImplementedError
     end
 
-    def rotated_image?(image)
+    # Override this method in a concrete subclass. Have it return true if the analyzer is supported.
+    def supported?
       raise NotImplementedError
     end
   end

data/lib/active_storage_validations/analyzer/null_analyzer.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 module ActiveStorageValidations
-  # = Active Storage Null Analyzer
+  # = ActiveStorageValidations Null Analyzer
   #
   # This is a fallback analyzer when the attachable media type is not supported
   # by our gem.
   #
   # Example:
   #
-  #   ActiveStorage::Analyzer::NullAnalyzer.new(attachable).metadata
+  #   ActiveStorageValidations::Analyzer::NullAnalyzer.new(attachable).metadata
   #   # => {}
   class Analyzer::NullAnalyzer < Analyzer
     def metadata

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  # ActiveStorageValidations:::ASVFFProbable
+  #
+  # Validator helper methods for analyzers using FFprobe.
+  module ASVFFProbable
+    extend ActiveSupport::Concern
+
+    private
+
+    def read_media
+      Tempfile.create(binmode: true) do |tempfile|
+        begin
+          if media(tempfile).present?
+            yield media(tempfile)
+          else
+            logger.info "Skipping file metadata analysis because ffprobe doesn't support the file"
+            {}
+          end
+        ensure
+          tempfile.close
+        end
+      end
+    rescue Errno::ENOENT
+      logger.info "Skipping file metadata analysis because ffprobe isn't installed"
+      {}
+    end
+
+    def media_from_path(path)
+      instrument(File.basename(ffprobe_path)) do
+        stdout, _stderr, status = Open3.capture3(
+          ffprobe_path,
+          "-print_format", "json",
+          "-show_streams",
+          "-show_format",
+          "-v", "error",
+          path
+        )
+
+        status.success? ? JSON.parse(stdout) : nil
+      end
+    end
+
+    def ffprobe_path
+      ActiveStorage.paths[:ffprobe] || "ffprobe"
+    end
+
+    def video_stream
+      @video_stream ||= streams.detect { |stream| stream["codec_type"] == "video" } || {}
+    end
+
+    def audio_stream
+      @audio_stream ||= streams.detect { |stream| stream["codec_type"] == "audio" } || {}
+    end
+
+    def streams
+      @streams ||= @media["streams"] || []
+    end
+  end
+end

data/lib/active_storage_validations/analyzer/video_analyzer.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'open3'
+require_relative 'shared/asv_ff_probable'
+
+module ActiveStorageValidations
+  # = ActiveStorageValidations Video \Analyzer
+  #
+  # Extracts the following from a video attachable:
+  #
+  # * Width (pixels)
+  # * Height (pixels)
+  # * Duration (seconds)
+  # * Angle (degrees)
+  # * Audio (true if file has an audio channel, false if not)
+  # * Video (true if file has an video channel, false if not)
+  #
+  # Example:
+  #
+  #   ActiveStorageValidations::Analyzer::VideoAnalyzer.new(attachable).metadata
+  #   # => { width: 640, height: 480, duration: 5.0, angle: 0, audio: true, video: true }
+  #
+  # When a video's angle is 90, -90, 270 or -270 degrees, its width and height are automatically swapped for convenience.
+  #
+  # This analyzer requires the {FFmpeg}[https://www.ffmpeg.org] system library, which is not provided by \Rails.
+  class Analyzer::VideoAnalyzer < Analyzer
+    include ASVFFProbable
+
+    def metadata
+      read_media do |media|
+        {
+          width: (Integer(width) if width),
+          height: (Integer(height) if height),
+          duration: duration,
+          angle: angle,
+          audio: audio?,
+          video: video?
+        }.compact
+      end
+    end
+
+    private
+
+    def width
+      if rotated?
+        computed_height || encoded_height
+      else
+        encoded_width
+      end
+    end
+
+    def height
+      if rotated?
+        encoded_width
+      else
+        computed_height || encoded_height
+      end
+    end
+
+    def duration
+      duration = video_stream["duration"] || container["duration"]
+      Float(duration).round(1) if duration
+    end
+
+    def angle
+      if tags["rotate"]
+        Integer(tags["rotate"])
+      elsif display_matrix && display_matrix["rotation"]
+        Integer(display_matrix["rotation"])
+      end
+    end
+
+    def display_matrix
+      side_data.detect { |data| data["side_data_type"] == "Display Matrix" }
+    end
+
+    def display_aspect_ratio
+      if descriptor = video_stream["display_aspect_ratio"]
+        if terms = descriptor.split(":", 2)
+          numerator   = Integer(terms[0])
+          denominator = Integer(terms[1])
+
+          [numerator, denominator] unless numerator == 0
+        end
+      end
+    end
+
+    def rotated?
+      angle == 90 || angle == 270 || angle == -90 || angle == -270
+    end
+
+    def audio?
+      audio_stream.present?
+    end
+
+    def video?
+      video_stream.present?
+    end
+
+    def computed_height
+      if encoded_width && display_height_scale
+        encoded_width * display_height_scale
+      end
+    end
+
+    def encoded_width
+      @encoded_width ||= Float(video_stream["width"]) if video_stream["width"]
+    end
+
+    def encoded_height
+      @encoded_height ||= Float(video_stream["height"]) if video_stream["height"]
+    end
+
+    def display_height_scale
+      @display_height_scale ||= Float(display_aspect_ratio.last) / display_aspect_ratio.first if display_aspect_ratio
+    end
+
+    def tags
+      @tags ||= video_stream["tags"] || {}
+    end
+
+    def side_data
+      @side_data ||= video_stream["side_data_list"] || {}
+    end
+
+    def container
+      @container ||= @media["format"] || {}
+    end
+  end
+end

data/lib/active_storage_validations/analyzer.rb

@@ -7,7 +7,7 @@ module ActiveStorageValidations
   # = Active Storage Validations \Analyzer
   #
   # This is an abstract base class for analyzers, which extract metadata from attachables.
-  # See ActiveStorageValidations::Analyzer::ImageAnalyzer for an example of a concrete subclass.
+  # See ActiveStorageValidations::Analyzer::VideoAnalyzer for an example of a concrete subclass.
   #
   # Heavily (not to say 100%) inspired by Rails own ActiveStorage::Analyzer
   class Analyzer
@@ -20,6 +20,11 @@ module ActiveStorageValidations
       @attachable = attachable
     end
 
+    # Override this method in a concrete subclass. Have it return a String content type.
+    def content_type
+      raise NotImplementedError
+    end
+
     # Override this method in a concrete subclass. Have it return a Hash of metadata.
     def metadata
       raise NotImplementedError
@@ -27,6 +32,54 @@ module ActiveStorageValidations
 
     private
 
+    # Override this method in a concrete subclass. Have it yield a media object.
+    def read_media
+      raise NotImplementedError
+    end
+
+    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)
+                 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
+    end
+
     def instrument(analyzer, &block)
       ActiveSupport::Notifications.instrument("analyze.active_storage_validations", analyzer: analyzer, &block)
     end

data/lib/active_storage_validations/aspect_ratio_validator.rb

@@ -1,120 +1,154 @@
-# 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_optionable'
-require_relative 'shared/asv_symbolizable'
-
-module ActiveStorageValidations
-  class AspectRatioValidator < ActiveModel::EachValidator # :nodoc
-    include ASVActiveStorageable
-    include ASVAnalyzable
-    include ASVAttachable
-    include ASVErrorable
-    include ASVOptionable
-    include ASVSymbolizable
-
-    AVAILABLE_CHECKS = %i[with].freeze
-    NAMED_ASPECT_RATIOS = %i[square portrait landscape].freeze
-    ASPECT_RATIO_REGEX = /is_([1-9]\d*)_([1-9]\d*)/.freeze
-    ERROR_TYPES = %i[
-      image_metadata_missing
-      aspect_ratio_not_square
-      aspect_ratio_not_portrait
-      aspect_ratio_not_landscape
-      aspect_ratio_is_not
-    ].freeze
-    PRECISION = 3.freeze
-
-    def check_validity!
-      ensure_at_least_one_validator_option
-      ensure_aspect_ratio_validity
-    end
-
-    def validate_each(record, attribute, _value)
-      return if no_attachments?(record, attribute)
-
-      validate_changed_files_from_metadata(record, attribute)
-    end
-
-    private
-
-    def is_valid?(record, attribute, attachable, metadata)
-      flat_options = set_flat_options(record)
-
-      return if image_metadata_missing?(record, attribute, attachable, flat_options, metadata)
-
-      case flat_options[:with]
-      when :square then validate_square_aspect_ratio(record, attribute, attachable, flat_options, metadata)
-      when :portrait then validate_portrait_aspect_ratio(record, attribute, attachable, flat_options, metadata)
-      when :landscape then validate_landscape_aspect_ratio(record, attribute, attachable, flat_options, metadata)
-      when ASPECT_RATIO_REGEX then validate_regex_aspect_ratio(record, attribute, attachable, flat_options, metadata)
-      end
-    end
-
-    def image_metadata_missing?(record, attribute, attachable, flat_options, metadata)
-      return false if metadata.present? && metadata[:width].to_i > 0 && metadata[:height].to_i > 0
-
-      errors_options = initialize_error_options(options, attachable)
-      errors_options[:aspect_ratio] = flat_options[:with]
-      add_error(record, attribute, :image_metadata_missing, **errors_options)
-      true
-    end
-
-    def validate_square_aspect_ratio(record, attribute, attachable, flat_options, metadata)
-      return if metadata[:width] == metadata[:height]
-
-      errors_options = initialize_error_options(options, attachable)
-      errors_options[:aspect_ratio] = flat_options[:with]
-      add_error(record, attribute, :aspect_ratio_not_square, **errors_options)
-    end
-
-    def validate_portrait_aspect_ratio(record, attribute, attachable, flat_options, metadata)
-      return if metadata[:width] < metadata[:height]
-
-      errors_options = initialize_error_options(options, attachable)
-      errors_options[:aspect_ratio] = flat_options[:with]
-      add_error(record, attribute, :aspect_ratio_not_portrait, **errors_options)
-    end
-
-    def validate_landscape_aspect_ratio(record, attribute, attachable, flat_options, metadata)
-      return if metadata[:width] > metadata[:height]
-
-      errors_options = initialize_error_options(options, attachable)
-      errors_options[:aspect_ratio] = flat_options[:with]
-      add_error(record, attribute, :aspect_ratio_not_landscape, **errors_options)
-    end
-
-    def validate_regex_aspect_ratio(record, attribute, attachable, flat_options, metadata)
-      flat_options[:with] =~ ASPECT_RATIO_REGEX
-      x = $1.to_i
-      y = $2.to_i
-
-      return if x > 0 && y > 0 && (x.to_f / y).round(PRECISION) == (metadata[:width].to_f / metadata[:height]).round(PRECISION)
-
-      errors_options = initialize_error_options(options, attachable)
-      errors_options[:aspect_ratio] = "#{x}:#{y}"
-      add_error(record, attribute, :aspect_ratio_is_not, **errors_options)
-    end
-
-    def ensure_at_least_one_validator_option
-      unless AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-        raise ArgumentError, 'You must pass :with to the validator'
-      end
-    end
-
-    def ensure_aspect_ratio_validity
-      return true if options[:with]&.is_a?(Proc)
-
-      unless NAMED_ASPECT_RATIOS.include?(options[:with]) || options[:with] =~ ASPECT_RATIO_REGEX
-        raise ArgumentError, <<~ERROR_MESSAGE
-          You must pass a valid aspect ratio to the validator
-          It should either be a named aspect ratio (#{NAMED_ASPECT_RATIOS.join(', ')})
-          Or an aspect ratio like 'is_16_9' (matching /#{ASPECT_RATIO_REGEX.source}/)
-        ERROR_MESSAGE
-      end
-    end
-  end
-end
+# 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_optionable'
+require_relative 'shared/asv_symbolizable'
+
+module ActiveStorageValidations
+  class AspectRatioValidator < ActiveModel::EachValidator # :nodoc
+    include ASVActiveStorageable
+    include ASVAnalyzable
+    include ASVAttachable
+    include ASVErrorable
+    include ASVOptionable
+    include ASVSymbolizable
+
+    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
+    ERROR_TYPES = %i[
+      aspect_ratio_not_square
+      aspect_ratio_not_portrait
+      aspect_ratio_not_landscape
+      aspect_ratio_not_x_y
+      aspect_ratio_invalid
+      media_metadata_missing
+    ].freeze
+    PRECISION = 3.freeze
+    METADATA_KEYS = %i[width height].freeze
+
+    def check_validity!
+      ensure_at_least_one_validator_option
+      ensure_aspect_ratio_validity
+    end
+
+    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?
+
+      validate_changed_files_from_metadata(record, attribute, METADATA_KEYS)
+    end
+
+    private
+
+    def is_valid?(record, attribute, attachable, metadata)
+      !media_metadata_missing?(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|
+        case authorized_aspect_ratio
+        when :square then valid_square_aspect_ratio?(metadata)
+        when :portrait then valid_portrait_aspect_ratio?(metadata)
+        when :landscape then valid_landscape_aspect_ratio?(metadata)
+        when ASPECT_RATIO_REGEX then valid_regex_aspect_ratio?(authorized_aspect_ratio, metadata)
+        end
+      end
+
+      return true if attachable_aspect_ratio_is_authorized
+
+      errors_options = initialize_error_options(options, attachable)
+      error_type = aspect_ratio_error_mapping
+      errors_options[:authorized_aspect_ratios] = string_aspect_ratios
+      errors_options[:width] = metadata[:width]
+      errors_options[:height] = metadata[:height]
+      add_error(record, attribute, error_type, **errors_options)
+      false
+    end
+
+    def aspect_ratio_error_mapping
+      return :aspect_ratio_invalid if @authorized_aspect_ratios.many?
+
+      aspect_ratio = @authorized_aspect_ratios.first
+      NAMED_ASPECT_RATIOS.include?(aspect_ratio) ? :"aspect_ratio_not_#{aspect_ratio}" : :aspect_ratio_not_x_y
+    end
+
+    def media_metadata_missing?(record, attribute, attachable, metadata)
+      return false if metadata[:width].to_i > 0 && metadata[:height].to_i > 0
+
+      errors_options = initialize_error_options(options, attachable)
+      errors_options[:authorized_aspect_ratios] = string_aspect_ratios
+      add_error(record, attribute, :media_metadata_missing, **errors_options)
+      true
+    end
+
+    def valid_square_aspect_ratio?(metadata)
+      metadata[:width] == metadata[:height]
+    end
+
+    def valid_portrait_aspect_ratio?(metadata)
+      metadata[:width] < metadata[:height]
+    end
+
+    def valid_landscape_aspect_ratio?(metadata)
+      metadata[:width] > metadata[:height]
+    end
+
+    def valid_regex_aspect_ratio?(aspect_ratio, metadata)
+      aspect_ratio =~ ASPECT_RATIO_REGEX
+      x = ::Regexp.last_match(1).to_i
+      y = ::Regexp.last_match(2).to_i
+
+      x > 0 && y > 0 && (x.to_f / y).round(PRECISION) == (metadata[:width].to_f / metadata[:height]).round(PRECISION)
+    end
+
+    def ensure_at_least_one_validator_option
+      return if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
+
+      raise ArgumentError, 'You must pass either :with or :in to the validator'
+    end
+
+    def ensure_aspect_ratio_validity
+      return true if options[:with]&.is_a?(Proc) || options[:in]&.is_a?(Proc)
+
+      authorized_aspect_ratios_from_options(options).each do |aspect_ratio|
+        unless NAMED_ASPECT_RATIOS.include?(aspect_ratio) || aspect_ratio =~ ASPECT_RATIO_REGEX
+          raise ArgumentError, invalid_aspect_ratio_message
+        end
+      end
+    end
+
+    def invalid_aspect_ratio_message
+      <<~ERROR_MESSAGE
+        You must pass a valid aspect ratio to the validator
+        It should either be a named aspect ratio (#{NAMED_ASPECT_RATIOS.join(', ')})
+        Or an aspect ratio like 'is_16_9' (matching /#{ASPECT_RATIO_REGEX.source}/)
+      ERROR_MESSAGE
+    end
+
+    def authorized_aspect_ratios_from_options(flat_options)
+      (Array.wrap(flat_options[:with]) + Array.wrap(flat_options[:in]))
+    end
+
+    def string_aspect_ratios
+      @authorized_aspect_ratios.map do |aspect_ratio|
+        if NAMED_ASPECT_RATIOS.include?(aspect_ratio)
+          aspect_ratio
+        else
+          aspect_ratio =~ ASPECT_RATIO_REGEX
+          x = ::Regexp.last_match(1).to_i
+          y = ::Regexp.last_match(2).to_i
+
+          "#{x}:#{y}"
+        end
+      end.join(', ')
+    end
+  end
+end