active_storage_validations 1.0.4 → 3.0.2

data/lib/active_storage_validations/shared/asv_attachable.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  # ActiveStorageValidations::ASVAttachable
+  #
+  # Validator methods for analyzing attachable.
+  #
+  # An attachable is a file representation such as ActiveStorage::Blob,
+  # ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile, Hash, String,
+  # File or Pathname
+  module ASVAttachable
+    extend ActiveSupport::Concern
+
+    private
+
+    # Loop through the newly submitted attachables to validate them. Using
+    # attachables is the only way to get the attached file io that is necessary
+    # to perform file analyses.
+    def validate_changed_files_from_metadata(record, attribute, metadata_keys)
+      attachables_and_blobs(record, attribute).each do |attachable, blob|
+        metadata = begin
+          metadata_for(blob, attachable, metadata_keys)
+        rescue ActiveStorage::FileNotFoundError
+          add_attachment_missing_error(record, attribute, attachable)
+          next
+        end
+
+        is_valid?(record, attribute, attachable, metadata)
+      end
+    end
+
+    # Retrieve an array-like of attachables and blobs. Unlike its name suggests,
+    # getting attachables from attachment_changes is not getting the changed
+    # attachables but all attachables from the `has_many_attached` relation.
+    # For the `has_one_attached` relation, it only yields the new attachable,
+    # but if we are validating previously attached file, we need to use the blob
+    # See #attach at: https://github.com/rails/rails/blob/main/activestorage/lib/active_storage/attached/many.rb
+    #
+    # Some file could be passed several times, we just need to perform the
+    # analysis once on the file, therefore the use of #uniq.
+    def attachables_and_blobs(record, attribute)
+      changes = changes_for(record, attribute)
+
+      return to_enum(:attachables_and_blobs, record, attribute) if changes.blank? || !block_given?
+
+      if changes.is_a?(ActiveStorage::Attached::Changes::CreateMany)
+        changes.attachables.uniq.zip(changes.blobs.uniq).each do |attachable, blob|
+          yield attachable, blob
+        end
+      else
+        yield changes.is_a?(ActiveStorage::Attached::Changes::CreateOne) ? changes.attachable : changes.blob, changes.blob
+      end
+    end
+
+    def changes_for(record, attribute)
+      if record.public_send(attribute).is_a?(ActiveStorage::Attached::One)
+        record.attachment_changes[attribute.to_s].presence || record.public_send(attribute)
+      else
+        record.attachment_changes[attribute.to_s]
+      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
+    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))
+    end
+
+    # Remove the potential mime type parameters from the content_type (e.g.
+    # 'application/x-rar-compressed;version=5')
+    def content_type_without_parameters(content_type)
+      content_type && content_type.downcase.split(/[;,\s]/, 2).first
+    end
+
+    # Retrieve the content_type from attachable using the same logic as Rails
+    # ActiveStorage::Blob::Identifiable#identify_content_type
+    def attachable_content_type_rails_like(attachable)
+      Marcel::MimeType.for(
+        attachable_io(attachable, max_byte_size: 4.kilobytes),
+        name: attachable_filename(attachable).to_s,
+        declared_type: full_attachable_content_type(attachable)
+      )
+    end
+
+    # Retrieve the media type of the attachable, which is the first part of the
+    # content type (or mime type).
+    # Possible values are: application/audio/example/font/image/model/text/video
+    def attachable_media_type(attachable)
+      (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 && supports_blob_download_chunk?) ? 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 && supports_blob_download_chunk?) ? 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)
+      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
+    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
+    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}"
+      )
+    end
+
+    # Check if the current Rails version supports File or Pathname attachment
+    #
+    # https://github.com/rails/rails/blob/7-1-stable/activestorage/CHANGELOG.md#rails-710rc1-september-27-2023
+    def supports_file_attachment?
+      Rails.gem_version >= Gem::Version.new("7.1.0.rc1")
+    end
+    alias :supports_pathname_attachment? :supports_file_attachment?
+
+    # Check if the current Rails version supports ActiveStorage::Blob#download_chunk
+    #
+    # https://github.com/rails/rails/blob/7-0-stable/activestorage/CHANGELOG.md#rails-700alpha1-september-15-2021
+    def supports_blob_download_chunk?
+      Rails.gem_version >= Gem::Version.new("7.0.0.alpha1")
+    end
+
+    # Retrieve the content_type from the file name only
+    def marcel_content_type_from_filename(attachable)
+      Marcel::MimeType.for(name: attachable_filename(attachable).to_s)
+    end
+
+    # Add a media metadata missing error when metadata is missing.
+    def add_media_metadata_missing_error(record, attribute, attachable, already_set_errors_options = nil)
+      errors_options = already_set_errors_options || initialize_error_options(options, attachable)
+      add_error(record, attribute, :media_metadata_missing, **errors_options)
+    end
+
+    # Add an attachment missing error when an ActiveStorage::FileNotFoundError
+    # is raised.
+    def add_attachment_missing_error(record, attribute, attachable)
+      errors_options = initialize_error_options(options, attachable)
+      add_error(record, attribute, :attachment_missing, **errors_options)
+    end
+  end
+end

data/lib/active_storage_validations/shared/asv_errorable.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  module ASVErrorable
+    extend ActiveSupport::Concern
+
+    def initialize_error_options(options, file = nil)
+      not_explicitly_written_options = %i[with in]
+      curated_options = options.except(*not_explicitly_written_options)
+
+      active_storage_validations_options = {
+        validator_type: self.class.to_sym,
+        custom_message: (options[:message] if options[:message].present?),
+        filename: (get_filename(file) unless self.class.to_sym == :total_size)
+      }.compact
+
+      curated_options.merge(active_storage_validations_options)
+    end
+
+    def add_error(record, attribute, error_type, **errors_options)
+      return if record.errors.added?(attribute, error_type)
+
+      error = record.errors.add(attribute, error_type, **errors_options)
+
+      # Rails 8.0.2 introduced a new way to mark errors as nested
+      # https://github.com/igorkasyanchuk/active_storage_validations/issues/377
+      if Rails.gem_version >= Gem::Version.new("8.0.2")
+        # Mark errors as nested when they occur in a parent/child context
+        set_nested_error(record, error) if updating_through_parent?(record)
+      end
+
+      # You can read https://api.rubyonrails.org/classes/ActiveModel/Errors.html#method-i-add
+      # to better understand how Rails model errors work
+      error
+    end
+
+    private
+
+    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 Hash then file[:filename]
+      end.to_s
+    end
+
+    def updating_through_parent?(record)
+      record.instance_variable_defined?(:@marked_for_destruction) ||
+        record.instance_variable_defined?(:@_destroy) ||
+        (record.respond_to?(:parent) && record.parent.present?)
+    end
+
+    def set_nested_error(record, error)
+      reflection = record.class.reflect_on_association(:parent)
+
+      if reflection
+        association = record.association(reflection.name)
+        record.errors.objects.append(ActiveRecord::Associations::NestedError.new(association, error))
+      end
+    end
+  end
+end

data/lib/active_storage_validations/shared/asv_loggable.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  module ASVLoggable
+    extend ActiveSupport::Concern
+
+    def logger
+      Rails.logger
+    end
+  end
+end

data/lib/active_storage_validations/shared/asv_optionable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  # ActiveStorageValidations::ASVOptionable
+  #
+  # Helper method to flatten the validator options.
+  module ASVOptionable
+    extend ActiveSupport::Concern
+
+    private
+
+    def set_flat_options(record)
+      flatten_options(record, self.options)
+    end
+
+    def flatten_options(record, options, available_checks = self.class::AVAILABLE_CHECKS)
+      case options
+      when Hash
+        options.merge(options) do |key, value|
+          available_checks&.exclude?(key) ? {} : flatten_options(record, value, nil)
+        end
+      when Array
+        options.map { |option| flatten_options(record, option, available_checks) }
+      else
+        options.is_a?(Proc) ? options.call(record) : options
+      end
+    end
+  end
+end

data/lib/active_storage_validations/shared/asv_symbolizable.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  module ASVSymbolizable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def to_sym
+        validator_class = self.name.split("::").last
+        validator_class.sub(/Validator/, "").underscore.to_sym
+      end
+    end
+  end
+end

data/lib/active_storage_validations/size_validator.rb

@@ -1,60 +1,43 @@
 # frozen_string_literal: true
 
+require_relative "base_comparison_validator"
+
 module ActiveStorageValidations
-  class SizeValidator < ActiveModel::EachValidator # :nodoc:
-    include OptionProcUnfolding
+  class SizeValidator < BaseComparisonValidator
+    ERROR_TYPES = %i[
+      file_size_not_less_than
+      file_size_not_less_than_or_equal_to
+      file_size_not_greater_than
+      file_size_not_greater_than_or_equal_to
+      file_size_not_between
+      file_size_not_equal_to
+    ].freeze
 
     delegate :number_to_human_size, to: ActiveSupport::NumberHelper
 
-    AVAILABLE_CHECKS = %i[less_than less_than_or_equal_to greater_than greater_than_or_equal_to between].freeze
-
-    def check_validity!
-      return true if AVAILABLE_CHECKS.any? { |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
-
     def validate_each(record, attribute, _value)
-      # only attached
-      return true unless record.send(attribute).attached?
+      return if no_attachments?(record, attribute)
 
-      files = Array.wrap(record.send(attribute))
+      flat_options = set_flat_options(record)
 
-      errors_options = {}
-      errors_options[:message] = options[:message] if options[:message].present?
-      flat_options = unfold_procs(record, self.options, AVAILABLE_CHECKS)
+      attached_files(record, attribute).each do |file|
+        next if is_valid?(file.blob.byte_size, flat_options)
 
-      files.each do |file|
-        next if content_size_valid?(file.blob.byte_size, flat_options)
+        errors_options = initialize_error_options(options, file)
+        populate_error_options(errors_options, flat_options)
+        errors_options[:file_size] = format_bound_value(file.blob.byte_size)
 
-        errors_options[:file_size] = number_to_human_size(file.blob.byte_size)
-        errors_options[:min_size] = number_to_human_size(min_size(flat_options))
-        errors_options[:max_size] = number_to_human_size(max_size(flat_options))
+        keys = AVAILABLE_CHECKS & flat_options.keys
+        error_type = "file_size_not_#{keys.first}".to_sym
 
-        record.errors.add(attribute, :file_size_out_of_range, **errors_options)
-        break
+        add_error(record, attribute, error_type, **errors_options)
       end
     end
 
-    def content_size_valid?(file_size, flat_options)
-      if flat_options[:between].present?
-        flat_options[:between].include?(file_size)
-      elsif flat_options[:less_than].present?
-        file_size < flat_options[:less_than]
-      elsif flat_options[:less_than_or_equal_to].present?
-        file_size <= flat_options[:less_than_or_equal_to]
-      elsif flat_options[:greater_than].present?
-        file_size > flat_options[:greater_than]
-      elsif flat_options[:greater_than_or_equal_to].present?
-        file_size >= flat_options[:greater_than_or_equal_to]
-      end
-    end
-
-    def min_size(flat_options)
-      flat_options[:between]&.min || flat_options[:greater_than] || flat_options[:greater_than_or_equal_to]
-    end
+    private
 
-    def max_size(flat_options)
-      flat_options[:between]&.max || flat_options[:less_than] || flat_options[:less_than_or_equal_to]
+    def format_bound_value(value)
+      number_to_human_size(value)
     end
   end
 end

data/lib/active_storage_validations/total_size_validator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "base_comparison_validator"
+
+module ActiveStorageValidations
+  class TotalSizeValidator < BaseComparisonValidator
+    ERROR_TYPES = %i[
+      total_file_size_not_less_than
+      total_file_size_not_less_than_or_equal_to
+      total_file_size_not_greater_than
+      total_file_size_not_greater_than_or_equal_to
+      total_file_size_not_between
+      total_file_size_not_equal_to
+    ].freeze
+
+    delegate :number_to_human_size, to: ActiveSupport::NumberHelper
+
+    def validate_each(record, attribute, _value)
+      custom_check_validity!(record, attribute)
+
+      return if no_attachments?(record, attribute)
+
+      total_file_size = attached_files(record, attribute).sum { |file| file.blob.byte_size }
+      flat_options = set_flat_options(record)
+
+      return if is_valid?(total_file_size, flat_options)
+
+      errors_options = initialize_error_options(options, nil)
+      populate_error_options(errors_options, flat_options)
+      errors_options[:total_file_size] = format_bound_value(total_file_size)
+
+      keys = AVAILABLE_CHECKS & flat_options.keys
+      error_type = "total_file_size_not_#{keys.first}".to_sym
+
+      add_error(record, attribute, error_type, **errors_options)
+    end
+
+    private
+
+    def custom_check_validity!(record, attribute)
+      # We can't perform this check in the #check_validity! hook because we do not
+      # have enough data (only options & attributes are accessible)
+      unless record.send(attribute).is_a?(ActiveStorage::Attached::Many)
+        raise ArgumentError, "This validator is only available for has_many_attached relations"
+      end
+    end
+
+    def format_bound_value(value)
+      number_to_human_size(value)
+    end
+  end
+end

data/lib/active_storage_validations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveStorageValidations
-  VERSION = '1.0.4'
+  VERSION = "3.0.2"
 end

data/lib/active_storage_validations.rb

@@ -1,16 +1,30 @@
 # frozen_string_literal: true
 
-require 'active_storage_validations/railtie'
-require 'active_storage_validations/engine'
-require 'active_storage_validations/option_proc_unfolding'
-require 'active_storage_validations/attached_validator'
-require 'active_storage_validations/content_type_validator'
-require 'active_storage_validations/size_validator'
-require 'active_storage_validations/limit_validator'
-require 'active_storage_validations/dimension_validator'
-require 'active_storage_validations/aspect_ratio_validator'
-require 'active_storage_validations/processable_image_validator'
+require "active_model"
+require "active_support/concern"
 
-ActiveSupport.on_load(:active_record) do
-  send :include, ActiveStorageValidations
-end
+require "active_storage_validations/analyzer"
+require "active_storage_validations/analyzer/image_analyzer"
+require "active_storage_validations/analyzer/image_analyzer/image_magick"
+require "active_storage_validations/analyzer/image_analyzer/vips"
+require "active_storage_validations/analyzer/null_analyzer"
+require "active_storage_validations/analyzer/video_analyzer"
+require "active_storage_validations/analyzer/audio_analyzer"
+require "active_storage_validations/analyzer/pdf_analyzer"
+
+require "active_storage_validations/extensors/asv_blob_metadatable"
+require "active_storage_validations/extensors/asv_marcelable"
+
+require "active_storage_validations/attached_validator"
+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/aspect_ratio_validator"
+require "active_storage_validations/processable_file_validator"
+require "active_storage_validations/size_validator"
+require "active_storage_validations/total_size_validator"
+require "active_storage_validations/pages_validator"
+
+require "active_storage_validations/engine"
+require "active_storage_validations/railtie"