active_storage_validations 1.1.4 → 1.3.0

data/lib/active_storage_validations/matchers/size_validator_matcher.rb

@@ -1,38 +1,14 @@
 # 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 'concerns/active_storageable.rb'
-require_relative 'concerns/allow_blankable.rb'
-require_relative 'concerns/contextable.rb'
-require_relative 'concerns/messageable.rb'
-require_relative 'concerns/rspecable.rb'
-require_relative 'concerns/validatable.rb'
+require_relative 'base_size_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
-      include ActiveStorageable
-      include AllowBlankable
-      include Contextable
-      include Messageable
-      include Rspecable
-      include Validatable
-
-      def initialize(attribute_name)
-        initialize_allow_blankable
-        initialize_contextable
-        initialize_messageable
-        initialize_rspecable
-        @attribute_name = attribute_name
-        @min = @max = nil
-      end
-
+    class SizeValidatorMatcher < BaseSizeValidatorMatcher
       def description
         "validate file size of :#{@attribute_name}"
       end
@@ -42,117 +18,6 @@ module ActiveStorageValidations
         build_failure_message(message)
         message.join("\n")
       end
-
-      def less_than(size)
-        @max = size - 1.byte
-        self
-      end
-
-      def less_than_or_equal_to(size)
-        @max = size
-        self
-      end
-
-      def greater_than(size)
-        @min = size + 1.byte
-        self
-      end
-
-      def greater_than_or_equal_to(size)
-        @min = size
-        self
-      end
-
-      def between(range)
-        @min, @max = range.first, range.last
-        self
-      end
-
-      def matches?(subject)
-        @subject = subject.is_a?(Class) ? subject.new : subject
-
-        is_a_valid_active_storage_attribute? &&
-          is_context_valid? &&
-          is_allowing_blank? &&
-          is_custom_message_valid? &&
-          not_lower_than_min? &&
-          higher_than_min? &&
-          lower_than_max? &&
-          not_higher_than_max?
-      end
-
-      protected
-
-      def build_failure_message(message)
-        return unless @failure_message_artefacts.present?
-
-        message << "  but there seem to have issues with the matcher methods you used, since:"
-        @failure_message_artefacts.each do |error_case|
-          message << "  validation failed when provided with a #{error_case[:size]} bytes test file"
-        end
-        message << "  whereas it should have passed"
-      end
-
-      def not_lower_than_min?
-        @min.nil? || !passes_validation_with_size(@min - 1)
-      end
-
-      def higher_than_min?
-        @min.nil? || passes_validation_with_size(@min + 1)
-      end
-
-      def lower_than_max?
-        @max.nil? || @max == Float::INFINITY || passes_validation_with_size(@max - 1)
-      end
-
-      def not_higher_than_max?
-        @max.nil? || @max == Float::INFINITY || !passes_validation_with_size(@max + 1)
-      end
-
-      def passes_validation_with_size(size)
-        mock_size_for(io, size) do
-          attach_file
-          validate
-          is_valid? || add_failure_message_artefact(size)
-        end
-      end
-
-      def add_failure_message_artefact(size)
-        @failure_message_artefacts << { size: size }
-        false
-      end
-
-      def is_custom_message_valid?
-        return true unless @custom_message
-
-        mock_size_for(io, -1.kilobytes) do
-          attach_file
-          validate
-          has_an_error_message_which_is_custom_message?
-        end
-      end
-
-      def mock_size_for(io, size)
-        Matchers.stub_method(io, :size, size) do
-          yield
-        end
-      end
-
-      def attach_file
-        @subject.public_send(@attribute_name).attach(dummy_file)
-      end
-
-      def dummy_file
-        {
-          io: io,
-          filename: 'test.png',
-          content_type: 'image/png'
-        }
-      end
-
-      def io
-        @io ||= Tempfile.new('Hello world!')
-      end
     end
   end
 end

data/lib/active_storage_validations/matchers/total_size_validator_matcher.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'base_size_validator_matcher'
+
+module ActiveStorageValidations
+  module Matchers
+    def validate_total_size_of(attribute_name)
+      TotalSizeValidatorMatcher.new(attribute_name)
+    end
+
+    class TotalSizeValidatorMatcher < BaseSizeValidatorMatcher
+      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
+    end
+  end
+end

data/lib/active_storage_validations/matchers.rb

@@ -2,9 +2,12 @@
 
 require 'active_storage_validations/matchers/aspect_ratio_validator_matcher'
 require 'active_storage_validations/matchers/attached_validator_matcher'
+require 'active_storage_validations/matchers/processable_image_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/size_validator_matcher'
+require 'active_storage_validations/matchers/total_size_validator_matcher'
 
 module ActiveStorageValidations
   module Matchers
@@ -23,21 +26,9 @@ module ActiveStorageValidations
     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
+      mock = Struct.new(:metadata).new({ width: width, height: height })
+      stub_method(ActiveStorageValidations::Metadata, :new, mock) do
+        yield
       end
     end
   end

data/lib/active_storage_validations/metadata.rb

@@ -1,5 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'concerns/loggable'
+
 module ActiveStorageValidations
   class Metadata
+    include Loggable
+
     class InvalidImageError < StandardError; end
 
     attr_reader :file
@@ -34,7 +40,7 @@ module ActiveStorageValidations
     private
 
     def image_processor
-      # Rails returns nil for default image processor, because it is set in an after initiliaze callback
+      # Rails returns nil for default image processor, because it is set in an after initialize callback
       # https://github.com/rails/rails/blob/89d8569abe2564c8187debf32dd3b4e33d6ad983/activestorage/lib/active_storage/engine.rb
       Rails.application.config.active_storage.variant_processor || DEFAULT_IMAGE_PROCESSOR
     end
@@ -62,11 +68,7 @@ module ActiveStorageValidations
       if is_string || file.is_a?(ActiveStorage::Blob)
         blob =
           if is_string
-            if Rails.gem_version < Gem::Version.new('6.1.0')
-              ActiveStorage::Blob.find_signed(file)
-            else
-              ActiveStorage::Blob.find_signed!(file)
-            end
+            ActiveStorage::Blob.find_signed!(file)
           else
             file
           end
@@ -101,7 +103,7 @@ module ActiveStorageValidations
     end
 
     def new_image_from_path(path)
-      if vips_image_processor? && (Vips::get_suffixes.include?(File.extname(path).downcase) || !Vips::respond_to?(:vips_foreign_get_suffixes))
+      if vips_image_processor? && (supported_vips_suffix?(path) || vips_version_below_8_8? || open_uri_tempfile?(path))
         begin
           Vips::Image.new_from_file(path)
         rescue exception_class
@@ -116,6 +118,24 @@ module ActiveStorageValidations
       end
     end
 
+    def supported_vips_suffix?(path)
+      Vips::get_suffixes.include?(File.extname(path).downcase)
+    end
+
+    def vips_version_below_8_8?
+      # FYI, Vips 8.8 was released in 2019
+      # https://github.com/libvips/libvips/releases/tag/v8.8.0
+      !Vips::respond_to?(:vips_foreign_get_suffixes)
+    end
+
+    def open_uri_tempfile?(path)
+      # When trying to open urls for 'large' images, OpenURI will return a
+      # tempfile. That tempfile does not have an extension indicating the type
+      # of file. However, Vips will be able to process it anyway.
+      # The 'large' file value is derived from OpenUri::Buffer class (> 10ko)
+      path.split('/').last.starts_with?("open-uri")
+    end
+
     def valid_image?(image)
       return false unless image
 
@@ -156,10 +176,5 @@ module ActiveStorageValidations
         raise "Something wrong with params."
       end
     end
-
-    def logger
-      Rails.logger
-    end
-
   end
 end

data/lib/active_storage_validations/processable_image_validator.rb

@@ -1,49 +1,34 @@
 # frozen_string_literal: true
 
+require_relative 'concerns/active_storageable.rb'
 require_relative 'concerns/errorable.rb'
+require_relative 'concerns/metadatable.rb'
 require_relative 'concerns/symbolizable.rb'
-require_relative 'metadata.rb'
 
 module ActiveStorageValidations
   class ProcessableImageValidator < ActiveModel::EachValidator # :nodoc
-    include OptionProcUnfolding
+    include ActiveStorageable
     include Errorable
+    include Metadatable
     include Symbolizable
 
     ERROR_TYPES = %i[
       image_not_processable
     ].freeze
 
-    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|
-          if !Metadata.new(file).valid?
-            errors_options = initialize_error_options(options, file)
-            add_error(record, attribute, ERROR_TYPES.first , **errors_options) unless Metadata.new(file).valid?
-          end
-        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|
-          if !Metadata.new(file).valid?
-            errors_options = initialize_error_options(options, file)
-            add_error(record, attribute, ERROR_TYPES.first , **errors_options) unless Metadata.new(file).valid?
-          end
-        end
-      end
+    def validate_each(record, attribute, _value)
+      return if no_attachments?(record, attribute)
+
+      validate_changed_files_from_metadata(record, attribute)
+    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/size_validator.rb

@@ -1,23 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'concerns/errorable.rb'
-require_relative 'concerns/symbolizable.rb'
+require_relative 'base_size_validator.rb'
 
 module ActiveStorageValidations
-  class SizeValidator < ActiveModel::EachValidator # :nodoc:
-    include OptionProcUnfolding
-    include Errorable
-    include Symbolizable
-
-    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
+  class SizeValidator < BaseSizeValidator
     ERROR_TYPES = %i[
       file_size_not_less_than
       file_size_not_less_than_or_equal_to
@@ -26,58 +12,23 @@ module ActiveStorageValidations
       file_size_not_between
     ].freeze
 
-    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
-
     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 = unfold_procs(record, self.options, AVAILABLE_CHECKS)
 
-      files.each do |file|
+      attached_files(record, attribute).each do |file|
         next if is_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] = 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
 
         add_error(record, attribute, error_type, **errors_options)
-        break
-      end
-    end
-
-    private
-
-    def is_valid?(file_size, flat_options)
-      return false if file_size < 0
-
-      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
-
-    def max_size(flat_options)
-      flat_options[:between]&.max || flat_options[:less_than] || flat_options[:less_than_or_equal_to]
-    end
   end
 end

data/lib/active_storage_validations/total_size_validator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'base_size_validator.rb'
+
+module ActiveStorageValidations
+  class TotalSizeValidator < BaseSizeValidator
+    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
+    ].freeze
+
+    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 = unfold_procs(record, self.options, AVAILABLE_CHECKS)
+
+      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] = number_to_human_size(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
+  end
+end

data/lib/active_storage_validations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveStorageValidations
-  VERSION = '1.1.4'
+  VERSION = '1.3.0'
 end

data/lib/active_storage_validations.rb

@@ -8,11 +8,14 @@ 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_storage_validations/size_validator'
+require 'active_storage_validations/total_size_validator'
+
+require 'active_storage_validations/marcel_extensor'
 
 ActiveSupport.on_load(:active_record) do
   send :include, ActiveStorageValidations