active_storage_validations 0.9.7 → 2.0.2

data/lib/active_storage_validations/analyzer.rb

@@ -0,0 +1,87 @@
+# 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
+
+    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,99 +1,154 @@
-# frozen_string_literal: true
-
-require_relative 'metadata.rb'
-
-module ActiveStorageValidations
-  class AspectRatioValidator < ActiveModel::EachValidator # :nodoc
-    AVAILABLE_CHECKS = %i[with].freeze
-    PRECISION = 3
-
-    def initialize(options)
-      super(options)
-    end
-
-
-    def check_validity!
-      return true if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-      raise ArgumentError, 'You must pass "aspect_ratio: :OPTION" option 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)
-      if metadata[:width].to_i <= 0 || metadata[:height].to_i <= 0
-        add_error(record, attribute, options[:message].presence || :image_metadata_missing)
-        return false
-      end
-
-      case options[:with]
-      when :square
-        return true if metadata[:width] == metadata[:height]
-        add_error(record, attribute, :aspect_ratio_not_square)
-
-      when :portrait
-        return true if metadata[:height] > metadata[:width]
-        add_error(record, attribute, :aspect_ratio_not_portrait)
-
-      when :landscape
-        return true if metadata[:width] > metadata[:height]
-        add_error(record, attribute, :aspect_ratio_not_landscape)
-
-      else
-        if 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)
-        end
-      end
-      false
-    end
-
-
-    def add_error(record, attribute, type, interpolate = options[:with])
-      key = options[:message].presence || type
-      return if record.errors.added?(attribute, key)
-      record.errors.add(attribute, key, 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_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

data/lib/active_storage_validations/attached_validator.rb

@@ -1,14 +1,31 @@
 # frozen_string_literal: true
 
+require_relative 'shared/asv_active_storageable'
+require_relative 'shared/asv_errorable'
+require_relative 'shared/asv_symbolizable'
+
 module ActiveStorageValidations
   class AttachedValidator < ActiveModel::EachValidator # :nodoc:
-    def validate_each(record, attribute, _value)
-      return if record.send(attribute).attached?
+    include ASVActiveStorageable
+    include ASVErrorable
+    include ASVSymbolizable
+
+    ERROR_TYPES = %i[blank].freeze
 
-      errors_options = {}
-      errors_options[:message] = options[:message] if options[:message].present?
+    def check_validity!
+      %i[allow_nil allow_blank].each do |not_authorized_option|
+        if options.include?(not_authorized_option)
+          raise ArgumentError, "You cannot pass the :#{not_authorized_option} option to the #{self.class.to_sym} validator"
+        end
+      end
+    end
+
+    def validate_each(record, attribute, _value)
+      return if attachments_present?(record, attribute) &&
+                will_have_attachments_after_save?(record, attribute)
 
-      record.errors.add(attribute, :blank, **errors_options)
+      errors_options = initialize_error_options(options)
+      add_error(record, attribute, ERROR_TYPES.first, **errors_options)
     end
   end
 end

data/lib/active_storage_validations/base_comparison_validator.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative 'shared/asv_active_storageable'
+require_relative 'shared/asv_errorable'
+require_relative 'shared/asv_optionable'
+require_relative 'shared/asv_symbolizable'
+
+module ActiveStorageValidations
+  class BaseComparisonValidator < ActiveModel::EachValidator # :nodoc:
+    include ASVActiveStorageable
+    include ASVErrorable
+    include ASVOptionable
+    include ASVSymbolizable
+
+    AVAILABLE_CHECKS = %i[
+      less_than
+      less_than_or_equal_to
+      greater_than
+      greater_than_or_equal_to
+      between
+    ].freeze
+
+    def initialize(*args)
+      if self.class == BaseComparisonValidator
+        raise NotImplementedError, 'BaseComparisonValidator is an abstract class and cannot be instantiated directly.'
+      end
+      super
+    end
+
+    def check_validity!
+      unless AVAILABLE_CHECKS.one? { |argument| options.key?(argument) }
+        raise ArgumentError, 'You must pass either :less_than(_or_equal_to), :greater_than(_or_equal_to), or :between to the validator'
+      end
+    end
+
+    private
+
+    def is_valid?(value, flat_options)
+      return false if value < 0
+
+      if flat_options[:between].present?
+        flat_options[:between].include?(value)
+      elsif flat_options[:less_than].present?
+        value < flat_options[:less_than]
+      elsif flat_options[:less_than_or_equal_to].present?
+        value <= flat_options[:less_than_or_equal_to]
+      elsif flat_options[:greater_than].present?
+        value > flat_options[:greater_than]
+      elsif flat_options[:greater_than_or_equal_to].present?
+        value >= flat_options[:greater_than_or_equal_to]
+      end
+    end
+
+    def populate_error_options(errors_options, flat_options)
+      errors_options[:min] = format_bound_value(min(flat_options))
+      errors_options[:max] = format_bound_value(max(flat_options))
+    end
+
+    def format_bound_value
+      raise NotImplementedError
+    end
+
+    def min(flat_options)
+      flat_options[:between]&.min || flat_options[:greater_than] || flat_options[:greater_than_or_equal_to]
+    end
+
+    def max(flat_options)
+      flat_options[:between]&.max || flat_options[:less_than] || flat_options[:less_than_or_equal_to]
+    end
+  end
+end