active_storage_validations 0.9.7 → 2.0.2

data/lib/active_storage_validations/matchers/shared/asv_rspecable.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module ActiveStorageValidations
+  module Matchers
+    module ASVRspecable
+      extend ActiveSupport::Concern
+
+      def initialize_rspecable
+        @failure_message_artefacts = []
+      end
+
+      def description
+        raise NotImplementedError, "#{self.class} did not define #{__method__}"
+      end
+
+      def failure_message
+        raise NotImplementedError, "#{self.class} did not define #{__method__}"
+      end
+
+      def failure_message_when_negated
+        failure_message.sub(/is expected to validate/, 'is expected not to validate')
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/shared/asv_validatable.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module ActiveStorageValidations
+  module Matchers
+    module ASVValidatable
+      extend ActiveSupport::Concern
+
+      private
+
+      def validate
+        @subject.validate(@context)
+      end
+
+      def validator_errors_for_attribute
+        @subject.errors.details[@attribute_name].select do |error|
+          error[:validator_type] == validator_class.to_sym
+        end
+      end
+
+      def is_valid?
+        validator_errors_for_attribute.none? do |error|
+          error[:error].in?(available_errors)
+        end
+      end
+
+      def available_errors
+        [
+          *validator_class::ERROR_TYPES,
+          *errors_from_custom_messages
+        ].compact
+      end
+
+      def validator_class
+        self.class.name.gsub(/::Matchers|Matcher/, '').constantize
+      end
+
+      def attribute_validator
+        @subject.class.validators_on(@attribute_name).find do |validator|
+          validator.class == validator_class
+        end
+      end
+
+      def attribute_validators
+        @subject.class.validators_on(@attribute_name).select do |validator|
+          validator.class == validator_class
+        end
+      end
+
+      def errors_from_custom_messages
+        attribute_validators.map { |validator| validator.options[:message] }
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers/size_validator_matcher.rb

@@ -1,91 +1,37 @@
 # frozen_string_literal: true
 
-# Big thank you to the paperclip validation matchers:
-# https://github.com/thoughtbot/paperclip/blob/v6.1.0/lib/paperclip/matchers/validate_attachment_size_matcher.rb
+require_relative 'base_comparison_validator_matcher'
+
 module ActiveStorageValidations
   module Matchers
-    def validate_size_of(name)
-      SizeValidatorMatcher.new(name)
+    def validate_size_of(attribute_name)
+      SizeValidatorMatcher.new(attribute_name)
     end
 
-    class SizeValidatorMatcher
-      def initialize(attribute_name)
-        @attribute_name = attribute_name
-        @low = @high = nil
-      end
-
+    class SizeValidatorMatcher < BaseComparisonValidatorMatcher
       def description
-        "validate file size of #{@attribute_name}"
-      end
-
-      def less_than(size)
-        @high = size - 1.byte
-        self
-      end
-
-      def less_than_or_equal_to(size)
-        @high = size
-        self
-      end
-
-      def greater_than(size)
-        @low = size + 1.byte
-        self
-      end
-
-      def greater_than_or_equal_to(size)
-        @low = size
-        self
-      end
-
-      def between(range)
-        @low, @high = range.first, range.last
-        self
-      end
-
-      def matches?(subject)
-        @subject = subject.is_a?(Class) ? subject.new : subject
-        responds_to_methods && lower_than_low? && higher_than_low? && lower_than_high? && higher_than_high?
+        "validate file size of :#{@attribute_name}"
       end
 
       def failure_message
-        "is expected to validate file size of #{@attribute_name} to be between #{@low} and #{@high} bytes"
+        message = ["is expected to validate file size of :#{@attribute_name}"]
+        build_failure_message(message)
+        message.join("\n")
       end
 
-      def failure_message_when_negated
-        "is expected to not validate file size of #{@attribute_name} to be between #{@low} and #{@high} bytes"
-      end
-
-      protected
-
-      def responds_to_methods
-        @subject.respond_to?(@attribute_name) &&
-          @subject.public_send(@attribute_name).respond_to?(:attach) &&
-          @subject.public_send(@attribute_name).respond_to?(:detach)
-      end
-
-      def lower_than_low?
-        @low.nil? || !passes_validation_with_size(@low - 1)
-      end
-
-      def higher_than_low?
-        @low.nil? || passes_validation_with_size(@low + 1)
-      end
+      private
 
-      def lower_than_high?
-        @high.nil? || @high == Float::INFINITY || passes_validation_with_size(@high - 1)
+      def failure_message_unit
+        "bytes"
       end
 
-      def higher_than_high?
-        @high.nil? || @high == Float::INFINITY || !passes_validation_with_size(@high + 1)
+      def smallest_measurement
+        1.byte
       end
 
-      def passes_validation_with_size(new_size)
-        io = Tempfile.new('Hello world!')
-        Matchers.stub_method(io, :size, new_size) do
-          @subject.public_send(@attribute_name).attach(io: io, filename: 'test.png', content_type: 'image/pg')
-          @subject.validate
-          @subject.errors.details[@attribute_name].all? { |error| error[:error] != :file_size_out_of_range }
+      def mock_value_for(io, size)
+        Matchers.stub_method(io, :size, size) do
+          yield
         end
       end
     end

data/lib/active_storage_validations/matchers/total_size_validator_matcher.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'base_comparison_validator_matcher'
+
+module ActiveStorageValidations
+  module Matchers
+    def validate_total_size_of(attribute_name)
+      TotalSizeValidatorMatcher.new(attribute_name)
+    end
+
+    class TotalSizeValidatorMatcher < BaseComparisonValidatorMatcher
+      def description
+        "validate total file size of :#{@attribute_name}"
+      end
+
+      def failure_message
+        message = ["is expected to validate total file size of :#{@attribute_name}"]
+        build_failure_message(message)
+        message.join("\n")
+      end
+
+      protected
+
+      def attach_file
+        # has_many_attached relation
+        @subject.public_send(@attribute_name).attach([dummy_blob])
+        @subject.public_send(@attribute_name)
+      end
+
+      private
+
+      def failure_message_unit
+        "bytes"
+      end
+
+      def smallest_measurement
+        1.byte
+      end
+
+      def mock_value_for(io, size)
+        Matchers.stub_method(io, :size, size) do
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/active_storage_validations/matchers.rb

@@ -1,9 +1,14 @@
 # frozen_string_literal: true
 
+require 'active_storage_validations/matchers/aspect_ratio_validator_matcher'
 require 'active_storage_validations/matchers/attached_validator_matcher'
+require 'active_storage_validations/matchers/processable_file_validator_matcher'
+require 'active_storage_validations/matchers/limit_validator_matcher'
 require 'active_storage_validations/matchers/content_type_validator_matcher'
 require 'active_storage_validations/matchers/dimension_validator_matcher'
+require 'active_storage_validations/matchers/duration_validator_matcher'
 require 'active_storage_validations/matchers/size_validator_matcher'
+require 'active_storage_validations/matchers/total_size_validator_matcher'
 
 module ActiveStorageValidations
   module Matchers
@@ -21,22 +26,12 @@ module ActiveStorageValidations
       end
     end
 
-    def self.mock_metadata(attachment, width, height)
-      if Rails.gem_version >= Gem::Version.new('6.0.0')
-        # Mock the Metadata class for rails 6
-        mock = OpenStruct.new(metadata: { width: width, height: height })
-        stub_method(ActiveStorageValidations::Metadata, :new, mock) do
-          yield
-        end
-      else
-        # Stub the metadata analysis for rails 5
-        stub_method(attachment, :analyze, true) do
-          stub_method(attachment, :analyzed?, true) do
-            stub_method(attachment, :metadata, { width: width, height: height }) do
-              yield
-            end
-          end
-        end
+    def self.mock_metadata(attachment, metadata = {})
+      asv_metadata_available_keys = { width: nil, height: nil, duration: nil, content_type: nil }
+      mock = Struct.new(:metadata).new(asv_metadata_available_keys.merge(metadata)) # ensure all keys are present, and it does not raise while trying to access them
+
+      stub_method(ActiveStorageValidations::Analyzer, :new, mock) do
+        yield
       end
     end
   end

data/lib/active_storage_validations/processable_file_validator.rb

@@ -0,0 +1,37 @@
+# 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_symbolizable'
+
+module ActiveStorageValidations
+  class ProcessableFileValidator < ActiveModel::EachValidator # :nodoc
+    include ASVActiveStorageable
+    include ASVAnalyzable
+    include ASVAttachable
+    include ASVErrorable
+    include ASVSymbolizable
+
+    ERROR_TYPES = %i[
+      file_not_processable
+    ].freeze
+    METADATA_KEYS = %i[].freeze
+
+    def validate_each(record, attribute, _value)
+      return if no_attachments?(record, attribute)
+
+      validate_changed_files_from_metadata(record, attribute, METADATA_KEYS)
+    end
+
+    private
+
+    def is_valid?(record, attribute, attachable, metadata)
+      return if !metadata.empty?
+
+      errors_options = initialize_error_options(options, attachable)
+      add_error(record, attribute, ERROR_TYPES.first , **errors_options)
+    end
+  end
+end

data/lib/active_storage_validations/railtie.rb

@@ -2,5 +2,16 @@
 
 module ActiveStorageValidations
   class Railtie < ::Rails::Railtie
+    initializer 'active_storage_validations.configure', after: :load_config_initializers do
+      ActiveSupport.on_load(:active_record) do
+        send :include, ActiveStorageValidations
+      end
+    end
+
+    initializer 'active_storage_validations.extend_active_storage_blob' do
+      ActiveSupport.on_load(:active_storage_blob) do
+        include(ActiveStorageValidations::ASVBlobMetadatable)
+      end
+    end
   end
 end

data/lib/active_storage_validations/shared/asv_active_storageable.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  # ActiveStorageValidations::ASVActiveStorageable
+  #
+  # Validator helper methods to make our code more explicit.
+  module ASVActiveStorageable
+    extend ActiveSupport::Concern
+
+    private
+
+    # Retrieve either an `ActiveStorage::Attached::One` or an
+    # `ActiveStorage::Attached::Many` instance depending on attribute definition
+    def attached_files(record, attribute)
+      Array.wrap(record.send(attribute))
+    end
+
+    def attachments_present?(record, attribute)
+      record.send(attribute).attached?
+    end
+
+    def no_attachments?(record, attribute)
+      !attachments_present?(record, attribute)
+    end
+
+    def will_have_attachments_after_save?(record, attribute)
+      !Array.wrap(record.send(attribute)).all?(&:marked_for_destruction?)
+    end
+  end
+end

data/lib/active_storage_validations/shared/asv_analyzable.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  # ActiveStorageValidations::ASVAnalyzable
+  #
+  # Validator methods for choosing the right analyzer depending on the file
+  # media type and available third-party analyzers.
+  module ASVAnalyzable
+    extend ActiveSupport::Concern
+
+    DEFAULT_IMAGE_PROCESSOR = :mini_magick.freeze
+
+    private
+
+    # Retrieve the ASV metadata from the blob.
+    # If the blob has not been analyzed by our gem yet, the gem will analyze the
+    # attachable with the corresponding analyzer and set the metadata in the
+    # blob.
+    def metadata_for(blob, attachable, metadata_keys)
+      return blob.active_storage_validations_metadata if blob_has_asv_metadata?(blob, metadata_keys)
+
+      new_metadata = generate_metadata_for(attachable, metadata_keys)
+      blob.merge_into_active_storage_validations_metadata(new_metadata)
+    end
+
+    def blob_has_asv_metadata?(blob, metadata_keys)
+      return false unless blob.active_storage_validations_metadata.present?
+
+      metadata_keys.all? { |key| blob.active_storage_validations_metadata.key?(key) }
+    end
+
+    def generate_metadata_for(attachable, metadata_keys)
+      if metadata_keys == ActiveStorageValidations::ContentTypeValidator::METADATA_KEYS
+        content_type_analyzer_for(attachable).content_type
+      else
+        metadata_analyzer_for(attachable).metadata
+      end
+    end
+
+    def metadata_analyzer_for(attachable)
+      case attachable_media_type(attachable)
+      when "image" then image_analyzer_for(attachable)
+      when "video" then video_analyzer_for(attachable)
+      when "audio" then audio_analyzer_for(attachable)
+      else fallback_analyzer_for(attachable)
+      end
+    end
+
+    def image_analyzer_for(attachable)
+      case image_processor
+      when :mini_magick
+        ActiveStorageValidations::Analyzer::ImageAnalyzer::ImageMagick.new(attachable)
+      when :vips
+        ActiveStorageValidations::Analyzer::ImageAnalyzer::Vips.new(attachable)
+      end
+    end
+
+    def image_processor
+      # Rails returns nil for default image processor, because it is set in an after initialize callback
+      # https://github.com/rails/rails/blob/main/activestorage/lib/active_storage/engine.rb
+      ActiveStorage.variant_processor || DEFAULT_IMAGE_PROCESSOR
+    end
+
+    def video_analyzer_for(attachable)
+      ActiveStorageValidations::Analyzer::VideoAnalyzer.new(attachable)
+    end
+
+    def audio_analyzer_for(attachable)
+      ActiveStorageValidations::Analyzer::AudioAnalyzer.new(attachable)
+    end
+
+    def fallback_analyzer_for(attachable)
+      ActiveStorageValidations::Analyzer::NullAnalyzer.new(attachable)
+    end
+
+    def content_type_analyzer_for(attachable)
+      ActiveStorageValidations::Analyzer::ContentTypeAnalyzer.new(attachable)
+    end
+  end
+end

data/lib/active_storage_validations/shared/asv_attachable.rb

@@ -0,0 +1,204 @@
+# 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|
+        is_valid?(record, attribute, attachable, metadata_for(blob, attachable, metadata_keys))
+      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 = 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
+
+      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
+
+    # Retrieve the full declared content_type from attachable.
+    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
+
+    # 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))
+    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.
+    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
+
+    # 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.
+    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
+
+    # 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
+  end
+end