active_storage_validations 1.0.4 → 3.0.2

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module ActiveStorageValidations
+  module Matchers
+    module ASVMessageable
+      extend ActiveSupport::Concern
+
+      def initialize_messageable
+        @custom_message = nil
+      end
+
+      def with_message(custom_message)
+        @custom_message = custom_message
+        self
+      end
+
+      private
+
+      def has_an_error_message_which_is_custom_message?
+        validator_errors_for_attribute.one? do |error|
+          error[:custom_message] == @custom_message
+        end
+      end
+    end
+  end
+end

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,15 @@
 # frozen_string_literal: true
 
-require 'active_storage_validations/matchers/attached_validator_matcher'
-require 'active_storage_validations/matchers/content_type_validator_matcher'
-require 'active_storage_validations/matchers/dimension_validator_matcher'
-require 'active_storage_validations/matchers/size_validator_matcher'
+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"
+require "active_storage_validations/matchers/pages_validator_matcher"
 
 module ActiveStorageValidations
   module Matchers
@@ -17,26 +23,16 @@ module ActiveStorageValidations
         RSpec::Mocks.allow_message(object, method) { result }
         yield
       else
-        raise 'Need either Minitest::Mock or RSpec::Mocks to run this validator matcher'
+        raise "Need either Minitest::Mock or RSpec::Mocks to run this validator matcher"
       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/pages_validator.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "base_comparison_validator"
+require_relative "shared/asv_analyzable"
+require_relative "shared/asv_attachable"
+
+module ActiveStorageValidations
+  class PagesValidator < BaseComparisonValidator
+    include ASVAnalyzable
+    include ASVAttachable
+
+    ERROR_TYPES = %i[
+      pages_not_less_than
+      pages_not_less_than_or_equal_to
+      pages_not_greater_than
+      pages_not_greater_than_or_equal_to
+      pages_not_between
+      pages_not_equal_to
+    ].freeze
+    METADATA_KEYS = %i[pages].freeze
+
+    delegate :number_to_delimited, to: ActiveSupport::NumberHelper
+
+    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, file, metadata)
+      flat_options = set_flat_options(record)
+      errors_options = initialize_error_options(options, file)
+
+      unless valid_metadata?(metadata)
+        add_media_metadata_missing_error(record, attribute, file, errors_options)
+        return false
+      end
+
+      return true if super(metadata[:pages], flat_options)
+
+      populate_error_options(errors_options, flat_options)
+      errors_options[:pages] = format_bound_value(metadata[:pages])
+
+      keys = AVAILABLE_CHECKS & flat_options.keys
+      error_type = "pages_not_#{keys.first}".to_sym
+
+      add_error(record, attribute, error_type, **errors_options)
+      false
+    end
+
+    def valid_metadata?(metadata)
+      metadata[:pages].to_i > 0
+    end
+
+    def format_bound_value(value)
+      number_to_delimited(value)
+    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,19 @@
 
 module ActiveStorageValidations
   class Railtie < ::Rails::Railtie
+    # Using after: :load_config_initializers would cause a stack level too deep error
+    # See: https://github.com/igorkasyanchuk/active_storage_validations/issues/364
+
+    initializer "active_storage_validations.configure" do
+      ActiveSupport.on_load(:active_record) do
+        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,89 @@
+# 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)
+      blob.save!
+
+      blob.active_storage_validations_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)
+      return pdf_analyzer_for(attachable) if attachable_content_type(attachable) == "application/pdf"
+
+      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 pdf_analyzer_for(attachable)
+      ActiveStorageValidations::Analyzer::PdfAnalyzer.new(attachable)
+    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