active_storage_validations 1.0.4 → 3.0.2

data/lib/active_storage_validations/analyzer/image_analyzer.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  # = ActiveStorageValidations Image \Analyzer
+  #
+  # This is an abstract base class for image analyzers, which extract width and height from an image attachable.
+  #
+  # If the image contains EXIF data indicating its angle is 90 or 270 degrees, its width and height are swapped for convenience.
+  #
+  # Example:
+  #
+  #   ActiveStorageValidations::Analyzer::ImageAnalyzer::ImageMagick.new(attachable).metadata
+  #   # => { width: 4104, height: 2736 }
+  class Analyzer::ImageAnalyzer < Analyzer
+    @@supported_analyzers = {}
+
+    def metadata
+      return {} unless analyzer_supported?
+
+      read_media do |media|
+        if rotated_image?(media)
+          { width: media.height, height: media.width }
+        else
+          { width: media.width, height: media.height }
+        end
+      end
+    end
+
+    private
+
+    def analyzer_supported?
+      if @@supported_analyzers.key?(self)
+        @@supported_analyzers.fetch(self)
+      else
+        @@supported_analyzers[self] = supported?
+      end
+    end
+
+    # Override this method in a concrete subclass. Have it return true if the image is rotated.
+    def rotated_image?(media)
+      raise NotImplementedError
+    end
+
+    # Override this method in a concrete subclass. Have it return true if the analyzer is supported.
+    def supported?
+      raise NotImplementedError
+    end
+  end
+end

data/lib/active_storage_validations/analyzer/null_analyzer.rb

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

data/lib/active_storage_validations/analyzer/pdf_analyzer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module ActiveStorageValidations
+  # = ActiveStorageValidations PDF \Analyzer
+  #
+  # Extracts the following from a pdf attachable:
+  #
+  # * Width (pts) => for the first page only
+  # * Height (pts) => for the first page only
+  # * Pages (integer) => number of pages in the pdf
+  #
+  # Example:
+  #
+  #   ActiveStorageValidations::Analyzer::PdfAnalyzer.new(attachable).metadata
+  #   # => { width: 150, height: 150, pages: 1 }
+  #
+  # 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
+    def metadata
+      read_media do |media|
+        {
+          width: width,
+          height: height,
+          pages: pages
+        }.compact
+      end
+    end
+
+    private
+
+    def read_media
+      Tempfile.create(binmode: true) do |tempfile|
+        begin
+          if media(tempfile).present?
+            yield media(tempfile)
+          else
+            logger.info "Skipping pdf file metadata analysis because poppler doesn't support the file"
+            {}
+          end
+        ensure
+          tempfile.close
+        end
+      end
+    rescue Errno::ENOENT
+      logger.info "Skipping pdf file metadata analysis because poppler isn't installed"
+      {}
+    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
+      end
+    end
+
+    def stdout_to_hash(stdout)
+      stdout.lines.each_with_object({}) do |line, hash|
+        key, value = line.strip.split(":", 2)
+        hash[normalize_stdout_key(key)] = value.strip if key && value
+      end
+    end
+
+    def normalize_stdout_key(key)
+      key.strip.underscore.gsub(/\s+/, "_").gsub(/"/, "")
+    end
+
+    def pdfinfo_path
+      ActiveStorage.paths[:pdfinfo] || "pdfinfo"
+    end
+
+    def width
+      @media["page_size"].scan(/\d+/)[0].to_i
+    end
+
+    def height
+      @media["page_size"].scan(/\d+/)[1].to_i
+    end
+
+    def pages
+      @media["pages"].to_i
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "shared/asv_attachable"
+require_relative "shared/asv_loggable"
+
+module ActiveStorageValidations
+  # = Active Storage Validations \Analyzer
+  #
+  # This is an abstract base class for analyzers, which extract metadata from attachables.
+  # See ActiveStorageValidations::Analyzer::VideoAnalyzer for an example of a concrete subclass.
+  #
+  # Heavily (not to say 100%) inspired by Rails own ActiveStorage::Analyzer
+  class Analyzer
+    include ASVAttachable
+    include ASVLoggable
+
+    attr_reader :attachable
+
+    def initialize(attachable)
+      @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
+    end
+
+    private
+
+    # Override this method in a concrete subclass. Have it yield a media object.
+    def read_media
+      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)
+      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
+  end
+end

data/lib/active_storage_validations/aspect_ratio_validator.rb

@@ -1,97 +1,157 @@
-# frozen_string_literal: true
-
-require_relative 'metadata.rb'
-
-module ActiveStorageValidations
-  class AspectRatioValidator < ActiveModel::EachValidator # :nodoc
-    include OptionProcUnfolding
-
-    AVAILABLE_CHECKS = %i[with].freeze
-    PRECISION = 3
-
-    def check_validity!
-      return true if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-      raise ArgumentError, 'You must pass :with to the validator'
-    end
-
-    if Rails.gem_version >= Gem::Version.new('6.0.0')
-      def validate_each(record, attribute, _value)
-        return true unless record.send(attribute).attached?
-
-        changes = record.attachment_changes[attribute.to_s]
-        return true if changes.blank?
-
-        files = Array.wrap(changes.is_a?(ActiveStorage::Attached::Changes::CreateMany) ? changes.attachables : changes.attachable)
-
-        files.each do |file|
-          metadata = Metadata.new(file).metadata
-          next if is_valid?(record, attribute, metadata)
-          break
-        end
-      end
-    else
-      # Rails 5
-      def validate_each(record, attribute, _value)
-        return true unless record.send(attribute).attached?
-
-        files = Array.wrap(record.send(attribute))
-
-        files.each do |file|
-          # Analyze file first if not analyzed to get all required metadata.
-          file.analyze; file.reload unless file.analyzed?
-          metadata = file.metadata
-
-          next if is_valid?(record, attribute, metadata)
-          break
-        end
-      end
-    end
-
-
-    private
-
-
-    def is_valid?(record, attribute, metadata)
-      flat_options = unfold_procs(record, self.options, AVAILABLE_CHECKS)
-      if metadata[:width].to_i <= 0 || metadata[:height].to_i <= 0
-        add_error(record, attribute, :image_metadata_missing, flat_options[:with])
-        return false
-      end
-
-      case flat_options[:with]
-      when :square
-        return true if metadata[:width] == metadata[:height]
-        add_error(record, attribute, :aspect_ratio_not_square, flat_options[:with])
-
-      when :portrait
-        return true if metadata[:height] > metadata[:width]
-        add_error(record, attribute, :aspect_ratio_not_portrait, flat_options[:with])
-
-      when :landscape
-        return true if metadata[:width] > metadata[:height]
-        add_error(record, attribute, :aspect_ratio_not_landscape, flat_options[:with])
-
-      else
-        if flat_options[:with] =~ /is_(\d*)_(\d*)/
-          x = $1.to_i
-          y = $2.to_i
-
-          return true if (x.to_f / y).round(PRECISION) == (metadata[:width].to_f / metadata[:height]).round(PRECISION)
-
-          add_error(record, attribute, :aspect_ratio_is_not, "#{x}x#{y}")
-        else
-          add_error(record, attribute, :aspect_ratio_unknown, flat_options[:with])
-        end
-      end
-      false
-    end
-
-
-    def add_error(record, attribute, default_message, interpolate)
-      message = options[:message].presence || default_message
-      return if record.errors.added?(attribute, message)
-      record.errors.add(attribute, message, aspect_ratio: interpolate)
-    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_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|
+        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_and_populate_error_options(options, attachable)
+      errors_options[:width] = metadata[:width]
+      errors_options[:height] = metadata[:height]
+      error_type = aspect_ratio_error_mapping
+      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_present?(record, attribute, attachable, metadata)
+      return true if metadata[:width].to_i > 0 && metadata[:height].to_i > 0
+
+      add_media_metadata_missing_error(record, attribute, attachable)
+      false
+    end
+
+    def initialize_and_populate_error_options(options, attachable)
+      errors_options = initialize_error_options(options, attachable)
+      errors_options[:authorized_aspect_ratios] = string_aspect_ratios
+      errors_options
+    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