active_storage_validations 1.0.4 → 3.0.2

data/lib/active_storage_validations/dimension_validator.rb

@@ -1,136 +1,226 @@
 # frozen_string_literal: true
 
-require_relative 'metadata.rb'
+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 DimensionValidator < ActiveModel::EachValidator # :nodoc
-    include OptionProcUnfolding
+    include ASVActiveStorageable
+    include ASVAnalyzable
+    include ASVAttachable
+    include ASVErrorable
+    include ASVOptionable
+    include ASVSymbolizable
 
     AVAILABLE_CHECKS = %i[width height min max].freeze
+    ERROR_TYPES = %i[
+      dimension_min_not_included_in
+      dimension_max_not_included_in
+      dimension_width_not_included_in
+      dimension_height_not_included_in
+      dimension_width_not_greater_than_or_equal_to
+      dimension_height_not_greater_than_or_equal_to
+      dimension_width_not_less_than_or_equal_to
+      dimension_height_not_less_than_or_equal_to
+      dimension_width_not_equal_to
+      dimension_height_not_equal_to
+      media_metadata_missing
+    ].freeze
+    METADATA_KEYS = %i[width height].freeze
 
-    def process_options(record)
-      flat_options = unfold_procs(record, self.options, AVAILABLE_CHECKS)
+    def check_validity!
+      ensure_at_least_one_validator_option
+      ensure_dimension_in_option_validity
+      ensure_min_max_option_validity
+    end
 
-      [:width, :height].each do |length|
-        if flat_options[length] and flat_options[length].is_a?(Hash)
-          if (range = flat_options[length][:in])
-            raise ArgumentError, ":in must be a Range" unless range.is_a?(Range)
-            flat_options[length][:min], flat_options[length][:max] = range.min, range.max
-          end
+    def validate_each(record, attribute, _value)
+      return if no_attachments?(record, attribute)
+
+      validate_changed_files_from_metadata(record, attribute, METADATA_KEYS)
+    end
+
+    private
+
+    def ensure_at_least_one_validator_option
+      unless AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
+        raise ArgumentError, "You must pass either :width, :height, :min or :max to the validator"
+      end
+    end
+
+    def ensure_dimension_in_option_validity
+      %i[width height].each do |dimension|
+        if options[dimension]&.is_a?(Hash) && options[dimension][:in].present?
+          raise ArgumentError, "{ #{dimension}: { in: value } } value must be a Range (min..max)" if !options[dimension][:in].is_a?(Range) && !options[dimension][:in].is_a?(Proc)
         end
       end
-      [:min, :max].each do |dim|
-        if (range = flat_options[dim])
-          raise ArgumentError, ":#{dim} must be a Range (width..height)" unless range.is_a?(Range)
-          flat_options[:width] = { dim => range.first }
-          flat_options[:height] = { dim => range.last }
+    end
+
+    def ensure_min_max_option_validity
+      %i[min max].each do |bound|
+        if options[bound].present?
+          raise ArgumentError, "{ #{bound}: value } value must be a Range (#{bound}_width..#{bound}_height)" if !options[bound]&.is_a?(Range) && !options[bound]&.is_a?(Proc)
         end
       end
+    end
 
-      flat_options
+    def is_valid?(record, attribute, file, metadata)
+      flat_options = process_options(record)
+      errors_options = initialize_error_options(options, file)
+
+      return add_media_metadata_missing_error(record, attribute, file, errors_options) unless valid_metadata?(metadata)
+
+      if min_max_validation?(flat_options)
+        validate_min_max(record, attribute, metadata, flat_options, errors_options)
+      else
+        validate_width_height(record, attribute, metadata, flat_options, errors_options)
+      end
     end
 
+    def valid_metadata?(metadata)
+      metadata[:width].to_i > 0 && metadata[:height].to_i > 0
+    end
 
-    def check_validity!
-      return true if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-      raise ArgumentError, 'You must pass either :width, :height, :min or :max to the validator'
+    def min_max_validation?(flat_options)
+      flat_options[:min] || flat_options[:max]
     end
 
+    def validate_min_max(record, attribute, metadata, flat_options, errors_options)
+      return false unless validate_min(record, attribute, metadata, flat_options, errors_options)
+      return false unless validate_max(record, attribute, metadata, flat_options, errors_options)
 
-    if Rails.gem_version >= Gem::Version.new('6.0.0')
-      def validate_each(record, attribute, _value)
-        return true unless record.send(attribute).attached?
+      true
+    end
 
-        changes = record.attachment_changes[attribute.to_s]
-        return true if changes.blank?
+    def validate_width_height(record, attribute, metadata, flat_options, errors_options)
+      %i[width height].each do |dimension|
+        next unless flat_options[dimension]
 
-        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 rescue {}
-          next if is_valid?(record, attribute, metadata)
-          break
+        if flat_options[dimension].is_a?(Hash)
+          validate_range(record, attribute, dimension, metadata, flat_options, errors_options)
+        else
+          validate_exact(record, attribute, dimension, metadata, flat_options, errors_options)
         end
       end
     end
 
-
-    def is_valid?(record, attribute, file_metadata)
-      flat_options = process_options(record)
-      # Validation fails unless file metadata contains valid width and height.
-      if file_metadata[:width].to_i <= 0 || file_metadata[:height].to_i <= 0
-        add_error(record, attribute, :image_metadata_missing)
-        return false
-      end
-
-      # Validation based on checks :min and :max (:min, :max has higher priority to :width, :height).
-      if flat_options[:min] || flat_options[:max]
-        if flat_options[:min] && (
-          (flat_options[:width][:min] && file_metadata[:width] < flat_options[:width][:min]) ||
-          (flat_options[:height][:min] && file_metadata[:height] < flat_options[:height][:min])
-          )
-          add_error(record, attribute, :dimension_min_inclusion, width: flat_options[:width][:min], height: flat_options[:height][:min])
-          return false
+    # rubocop:disable Metrics/BlockLength
+    %i[min max].each do |bound|
+      define_method("validate_#{bound}") do |record, attribute, metadata, flat_options, errors_options|
+        if send(:"invalid_#{bound}?", flat_options, metadata)
+          send(:"add_#{bound}_error", record, attribute, flat_options, errors_options)
+          false
+        else
+          true
         end
-        if flat_options[:max] && (
-          (flat_options[:width][:max] && file_metadata[:width] > flat_options[:width][:max]) ||
-          (flat_options[:height][:max] && file_metadata[:height] > flat_options[:height][:max])
-          )
-          add_error(record, attribute, :dimension_max_inclusion, width: flat_options[:width][:max], height: flat_options[:height][:max])
-          return false
+      end
+
+      define_method("validate_dimension_#{bound}") do |record, attribute, dimension, metadata, flat_options, errors_options|
+        if send(:"invalid_dimension_#{bound}?", flat_options, dimension, metadata)
+          send(:"add_dimension_#{bound}_error", record, attribute, dimension, flat_options, errors_options)
+          false
+        else
+          true
         end
+      end
+
+      define_method("invalid_#{bound}?") do |flat_options, metadata|
+        flat_options[bound] && (
+          send(:"invalid_dimension_#{bound}?", flat_options, :width, metadata) ||
+          send(:"invalid_dimension_#{bound}?", flat_options, :height, metadata)
+        )
+      end
+
+      define_method("invalid_dimension_#{bound}?") do |flat_options, dimension, metadata|
+        flat_options[dimension][bound] && metadata[dimension].public_send(bound == :min ? :< : :>, flat_options[dimension][bound])
+      end
+
+      define_method("add_#{bound}_error") do |record, attribute, flat_options, errors_options|
+        errors_options[:width] = flat_options[:width][bound]
+        errors_options[:height] = flat_options[:height][bound]
+        add_error(record, attribute, :"dimension_#{bound}_not_included_in", **errors_options)
+      end
 
-      # Validation based on checks :width and :height.
+      define_method("add_dimension_#{bound}_error") do |record, attribute, dimension, flat_options, errors_options|
+        error_type = bound == :min ? :not_greater_than_or_equal_to : :not_less_than_or_equal_to
+        errors_options[:length] = flat_options[dimension][bound]
+        add_error(record, attribute, :"dimension_#{dimension}_#{error_type}", **errors_options)
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+
+    def validate_range(record, attribute, dimension, metadata, flat_options, errors_options)
+      if in_option_used?(flat_options, dimension)
+        return false unless validate_in(record, attribute, dimension, metadata, flat_options, errors_options)
       else
-        width_or_height_invalid = false
-        [:width, :height].each do |length|
-          next unless flat_options[length]
-          if flat_options[length].is_a?(Hash)
-            if flat_options[length][:in] && (file_metadata[length] < flat_options[length][:min] || file_metadata[length] > flat_options[length][:max])
-              add_error(record, attribute, :"dimension_#{length}_inclusion", min: flat_options[length][:min], max: flat_options[length][:max])
-              width_or_height_invalid = true
-            else
-              if flat_options[length][:min] && file_metadata[length] < flat_options[length][:min]
-                add_error(record, attribute, :"dimension_#{length}_greater_than_or_equal_to", length: flat_options[length][:min])
-                width_or_height_invalid = true
-              end
-              if flat_options[length][:max] && file_metadata[length] > flat_options[length][:max]
-                add_error(record, attribute, :"dimension_#{length}_less_than_or_equal_to", length: flat_options[length][:max])
-                width_or_height_invalid = true
-              end
-            end
-          else
-            if file_metadata[length] != flat_options[length]
-              add_error(record, attribute, :"dimension_#{length}_equal_to", length: flat_options[length])
-              width_or_height_invalid = true
-            end
-          end
-        end
+        return false unless validate_dimension_min_max(record, attribute, dimension, metadata, flat_options, errors_options)
+      end
 
-        return false if width_or_height_invalid
+      true
+    end
+
+    def validate_in(record, attribute, dimension, metadata, flat_options, errors_options)
+      if outside_range?(metadata[dimension], flat_options[dimension])
+        add_range_error(record, attribute, dimension, flat_options, errors_options)
+        false
+      else
+        true
       end
+    end
 
-      true # valid file
+    def in_option_used?(flat_options, dimension)
+      flat_options[dimension][:in]
     end
 
-    def add_error(record, attribute, default_message, **attrs)
-      message = options[:message].presence || default_message
-      return if record.errors.added?(attribute, message)
-      record.errors.add(attribute, message, **attrs)
+    def outside_range?(value, options)
+      value < options[:min] || value > options[:max]
     end
 
+    def add_range_error(record, attribute, dimension, flat_options, errors_options)
+      errors_options[:min] = flat_options[dimension][:min]
+      errors_options[:max] = flat_options[dimension][:max]
+      add_error(record, attribute, :"dimension_#{dimension}_not_included_in", **errors_options)
+    end
+
+    def validate_dimension_min_max(record, attribute, dimension, metadata, flat_options, errors_options)
+      %i[min max].each do |bound|
+        send(:"validate_dimension_#{bound}", record, attribute, dimension, metadata, flat_options, errors_options)
+      end
+    end
+
+    def validate_exact(record, attribute, dimension, metadata, flat_options, errors_options)
+      if metadata[dimension] != flat_options[dimension]
+        errors_options[:length] = flat_options[dimension]
+        add_error(record, attribute, :"dimension_#{dimension}_not_equal_to", **errors_options)
+        false
+      else
+        true
+      end
+    end
+
+    def process_options(record)
+      flat_options = set_flat_options(record)
+
+      %i[width height].each do |dimension|
+        if flat_options[dimension] and flat_options[dimension].is_a?(Hash)
+          if (range = flat_options[dimension][:in])
+            flat_options[dimension][:min], flat_options[dimension][:max] = range.min, range.max
+          end
+        end
+      end
+
+      %i[min max].each do |bound|
+        if (range = flat_options[bound])
+          flat_options[:width] = { bound => range.first }
+          flat_options[:height] = { bound => range.last }
+        end
+      end
+
+      flat_options
+    end
   end
 end

data/lib/active_storage_validations/duration_validator.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "base_comparison_validator"
+
+module ActiveStorageValidations
+  class DurationValidator < BaseComparisonValidator
+    include ASVAnalyzable
+    include ASVAttachable
+
+    ERROR_TYPES = %i[
+      duration_not_less_than
+      duration_not_less_than_or_equal_to
+      duration_not_greater_than
+      duration_not_greater_than_or_equal_to
+      duration_not_between
+      duration_not_equal_to
+    ].freeze
+    METADATA_KEYS = %i[duration].freeze
+
+    def validate_each(record, attribute, _value)
+      return if no_attachments?(record, attribute)
+
+      flat_options = set_flat_options(record)
+
+      attachables_and_blobs(record, attribute).each do |attachable, blob|
+        duration = begin
+          metadata_for(blob, attachable, METADATA_KEYS)&.fetch(:duration, nil)
+        rescue ActiveStorage::FileNotFoundError
+          add_attachment_missing_error(record, attribute, attachable)
+          next
+        end
+
+        if duration.to_i <= 0
+          add_media_metadata_missing_error(record, attribute, attachable)
+          next
+        end
+
+        is_valid?(duration, flat_options) || populate_error_options_and_add_error(record, attribute, attachable, flat_options, duration)
+      end
+    end
+
+    private
+
+    def populate_error_options_and_add_error(record, attribute, attachable, flat_options, duration)
+      errors_options = initialize_error_options(options, attachable)
+      populate_error_options(errors_options, flat_options, duration)
+
+      error_type = set_error_type(flat_options)
+
+      add_error(record, attribute, error_type, **errors_options)
+    end
+
+    def format_bound_value(value)
+      return nil unless value
+
+      custom_value = value == value.to_i ? value.to_i : value
+      ActiveSupport::Duration.build(custom_value).inspect
+    end
+
+    def populate_error_options(errors_options, flat_options, duration)
+      super(errors_options, flat_options)
+      errors_options[:duration] = format_bound_value(duration)
+    end
+
+    def set_error_type(flat_options)
+      keys = AVAILABLE_CHECKS & flat_options.keys
+      "duration_not_#{keys.first}".to_sym
+    end
+  end
+end

data/lib/active_storage_validations/extensors/asv_blob_metadatable.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  module ASVBlobMetadatable
+    extend ActiveSupport::Concern
+
+    # rubocop:disable Metrics/BlockLength
+    included do
+      # This method returns the metadata that has been set by our gem.
+      # The metadata is stored in the blob's custom metadata. All keys are prefixed with 'asv_'
+      # to avoid conflicts with other metadata.
+      # It is not to set a active_storage_validation key equal to a a hash of our gem's metadata,
+      # because this would result in errors down the road with services such as S3.
+      #
+      # Because of how the metadata is stored, we need to convert the values from String
+      # to Integer or Boolean.
+      def active_storage_validations_metadata
+        metadata.dig("custom")
+                &.select { |key, _| key.to_s.start_with?("asv_") }
+                &.transform_keys { |key| key.to_s.delete_prefix("asv_") }
+                &.transform_values do |value|
+                  case value
+                  when /\A\d+\z/ then value.to_i
+                  when /\A\d+\.\d+\z/ then value.to_f
+                  when "true" then true
+                  when "false" then false
+                  else value
+                  end
+                end || {}
+      end
+
+      # This method sets the metadata that has been detected by our gem.
+      # The metadata is stored in the blob's custom metadata. All keys are prefixed with 'asv_'.
+      # We need to store values as String, because services such as S3 will not accept other types.
+      def merge_into_active_storage_validations_metadata(hash)
+        aws_compatible_metadata = normalize_active_storage_validations_metadata_for_aws(hash)
+
+        metadata["custom"] ||= {}
+        metadata["custom"].merge!(aws_compatible_metadata)
+
+        active_storage_validations_metadata
+      end
+
+      def normalize_active_storage_validations_metadata_for_aws(hash)
+        hash.transform_keys { |key, _| key.to_s.start_with?("asv_") ? key : "asv_#{key}" }
+            .transform_values(&:to_s)
+      end
+
+      def remove_active_storage_validations_metadata!
+        metadata["custom"] ||= {}
+        metadata["custom"].delete_if { |key, _| key.to_s.start_with?("asv_") }
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+  end
+end

data/lib/active_storage_validations/extensors/asv_marcelable.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "marcel"
+
+Marcel::MimeType.extend "application/x-rar-compressed", parents: %(application/x-rar)
+Marcel::MimeType.extend "audio/x-hx-aac-adts", parents: %(audio/x-aac)
+Marcel::MimeType.extend "audio/x-m4a", parents: %(audio/mp4)
+Marcel::MimeType.extend "text/xml", parents: %(application/xml) # alias
+Marcel::MimeType.extend "video/theora", parents: %(video/ogg)
+
+# Add empty content type
+Marcel::MimeType.extend "inode/x-empty", extensions: %w[empty]

data/lib/active_storage_validations/limit_validator.rb

@@ -1,25 +1,43 @@
 # 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 LimitValidator < ActiveModel::EachValidator # :nodoc:
-    include OptionProcUnfolding
+    include ASVActiveStorageable
+    include ASVErrorable
+    include ASVOptionable
+    include ASVSymbolizable
 
     AVAILABLE_CHECKS = %i[max min].freeze
+    ERROR_TYPES = %i[
+      limit_out_of_range
+      limit_min_not_reached
+      limit_max_exceeded
+    ].freeze
 
     def check_validity!
-      return true if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-      raise ArgumentError, 'You must pass either :max or :min to the validator'
+      ensure_at_least_one_validator_option
+      ensure_arguments_validity
     end
 
-    def validate_each(record, attribute, _)
-      files = Array.wrap(record.send(attribute)).compact.uniq
-      flat_options = unfold_procs(record, self.options, AVAILABLE_CHECKS)
-      errors_options = { min: flat_options[:min], max: flat_options[:max] }
+    def validate_each(record, attribute, _value)
+      files = attached_files(record, attribute).reject(&:blank?)
+      flat_options = set_flat_options(record)
+      count = files.count
+
+      return if files_count_valid?(count, flat_options)
 
-      return true if files_count_valid?(files.count, flat_options)
-      record.errors.add(attribute, options[:message].presence || :limit_out_of_range, **errors_options)
+      errors_options = initialize_and_populate_error_options(options, flat_options, count)
+      error_type = set_error_type(flat_options, count)
+      add_error(record, attribute, error_type, **errors_options)
     end
 
+    private
+
     def files_count_valid?(count, flat_options)
       if flat_options[:max].present? && flat_options[:min].present?
         count >= flat_options[:min] && count <= flat_options[:max]
@@ -29,5 +47,54 @@ module ActiveStorageValidations
         count >= flat_options[:min]
       end
     end
+
+    def ensure_at_least_one_validator_option
+      unless AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
+        raise ArgumentError, "You must pass either :max or :min to the validator"
+      end
+    end
+
+    def ensure_arguments_validity
+      return true if min_max_are_proc? || min_or_max_is_proc_and_other_not_present?
+
+      raise ArgumentError, "You must pass integers to :min and :max" if min_or_max_defined_and_not_integer?
+      raise ArgumentError, "You must pass a higher value to :max than to :min" if min_higher_than_max?
+    end
+
+    def min_max_are_proc?
+      options[:min]&.is_a?(Proc) && options[:max]&.is_a?(Proc)
+    end
+
+    def min_or_max_is_proc_and_other_not_present?
+      (options[:min]&.is_a?(Proc) && options[:max].nil?) ||
+        (options[:min].nil? && options[:max]&.is_a?(Proc))
+    end
+
+    def min_or_max_defined_and_not_integer?
+      (options.key?(:min) && !options[:min].is_a?(Integer)) ||
+        (options.key?(:max) && !options[:max].is_a?(Integer))
+    end
+
+    def min_higher_than_max?
+      options[:min] > options[:max] if options[:min].is_a?(Integer) && options[:max].is_a?(Integer)
+    end
+
+    def initialize_and_populate_error_options(options, flat_options, count)
+      errors_options = initialize_error_options(options)
+      errors_options[:min] = flat_options[:min]
+      errors_options[:max] = flat_options[:max]
+      errors_options[:count] = count
+      errors_options
+    end
+
+    def set_error_type(flat_options, count)
+      if flat_options[:min] && flat_options[:max]
+        :limit_out_of_range
+      elsif flat_options[:min] && count < flat_options[:min]
+        :limit_min_not_reached
+      else
+        :limit_max_exceeded
+      end
+    end
   end
 end