apipie-dsl 2.0.0

data/lib/apipie_dsl/validator.rb

@@ -0,0 +1,479 @@
+# frozen_string_literal: true
+
+module ApipieDSL
+  module Validator
+    class Lazy
+      def initialize(param_description, argument, options, block)
+        @param_description = param_description
+        @argument = argument
+        @options = options
+        @block = block
+      end
+
+      def build
+        # TODO support for plain Ruby
+        return unless defined? Rails
+
+        BaseValidator.find(@param_description, @argument.constantize, @options, @block)
+      end
+    end
+    # To create a new validator, inherit from ApipieDSL::Validator::BaseValidator
+    # and implement class method 'build' and instance method 'validate'
+    class BaseValidator
+      attr_reader :param_description
+
+      def initialize(param_description)
+        @param_description = param_description
+      end
+
+      def self.build(_param_description, _argument, _options, &_block)
+        raise NotImplementedError
+      end
+
+      def validate(_value)
+        raise NotImplementedError
+      end
+
+      def description
+        raise NotImplementedError
+      end
+
+      def inspected_fields
+        [:param_description]
+      end
+
+      def inspect
+        string = "#<#{self.class.name}:#{object_id} "
+        fields = inspected_fields.map { |field| "#{field}: #{send(field)}" }
+        string << fields.join(', ') << '>'
+      end
+
+      def self.inherited(subclass)
+        @validators ||= []
+        @validators.unshift(subclass)
+      end
+
+      def self.find(param_description, argument, options, block)
+        @validators.each do |type|
+          validator = type.build(param_description, argument, options, block)
+          return validator if validator
+        end
+        nil
+      end
+
+      def valid?(value)
+        return true if validate(value)
+
+        raise ParamInvalid.new(@param_description.name, value, description)
+      end
+
+      def to_s
+        description
+      end
+
+      def docs
+        raise NotImplementedError
+      end
+
+      def expected_type
+        'string'
+      end
+
+      def sub_params
+        nil
+      end
+
+      def merge_with(other_validator)
+        return self if self == other_validator
+
+        raise NotImplementedError, "Don't know how to merge #{inspect} with #{other_validator.inspect}"
+      end
+
+      def ==(other)
+        return false unless self.class == other.class
+
+        param_description == other.param_description
+      end
+    end
+
+    class TypeValidator < BaseValidator
+      def initialize(param_description, argument)
+        super(param_description)
+        @type = argument
+      end
+
+      def self.build(param_description, argument, _options, block)
+        return unless argument.is_a?(::Class)
+        return if argument == Hash && !block.nil?
+
+        new(param_description, argument)
+      end
+
+      def validate(value)
+        return false if value.nil?
+
+        value.is_a?(@type)
+      end
+
+      def description
+        "Must be a #{@type}"
+      end
+
+      def expected_type
+        if @type.ancestors.include?(Hash)
+          'hash'
+        elsif @type.ancestors.include?(Array)
+          'array'
+        elsif @type.ancestors.include?(Numeric)
+          'numeric'
+        else
+          'string'
+        end
+      end
+    end
+
+    class RegexpValidator < BaseValidator
+      def initialize(param_description, argument)
+        super(param_description)
+        @regexp = argument
+      end
+
+      def self.build(param_description, argument, _options, _block)
+        new(param_description, argument) if argument.is_a?(Regexp)
+      end
+
+      def validate(value)
+        value =~ @regexp
+      end
+
+      def description
+        "Must match regular expression <code>/#{@regexp.source}/</code>."
+      end
+
+      def expected_type
+        'regexp'
+      end
+    end
+
+    # Arguments value must be one of given in array
+    class EnumValidator < BaseValidator
+      def initialize(param_description, argument)
+        super(param_description)
+        @array = argument
+      end
+
+      def self.build(param_description, argument, _options, _block)
+        new(param_description, argument) if argument.is_a?(Array)
+      end
+
+      def validate(value)
+        @array.include?(value)
+      end
+
+      def values
+        @array
+      end
+
+      def description
+        string = @array.map { |value| "<code>#{value}</code>" }.join(', ')
+        "Must be one of: #{string}."
+      end
+    end
+
+    class ArrayValidator < BaseValidator
+      def initialize(param_description, argument, options = {})
+        super(param_description)
+        @type = argument
+        @items_type = options[:of]
+        @items_enum = options[:in]
+      end
+
+      def self.build(param_description, argument, options, block)
+        return if argument != Array || block.is_a?(Proc)
+
+        new(param_description, argument, options)
+      end
+
+      def validate(values)
+        return false unless process_value(values).respond_to?(:each) &&
+                            !process_value(values).is_a?(String)
+
+        process_value(values).all? { |v| validate_item(v) }
+      end
+
+      def process_value(values)
+        values || []
+      end
+
+      def description
+        "Must be an array of #{items_type}"
+      end
+
+      def expected_type
+        'array'
+      end
+
+      private
+
+      def validate_item(value)
+        valid_type?(value) && valid_value?(value)
+      end
+
+      def valid_type?(value)
+        return true unless @items_type
+
+        item_validator = BaseValidator.find(nil, @items_type, nil, nil)
+
+        if item_validator
+          item_validator.valid?(value)
+        else
+          value.is_a?(@items_type)
+        end
+      end
+
+      def items_enum
+        @items_enum = Array(@items_enum.call) if @items_enum.is_a?(Proc)
+        @items_enum
+      end
+
+      def valid_value?(value)
+        if items_enum
+          items_enum.include?(value)
+        else
+          true
+        end
+      end
+
+      def items_type
+        return items_enum.inspect if items_enum
+
+        @items_type || 'any type'
+      end
+    end
+
+    class ArrayClassValidator < BaseValidator
+      def initialize(param_description, argument)
+        super(param_description)
+        @array = argument
+      end
+
+      def validate(value)
+        @array.include?(value.class)
+      end
+
+      def self.build(param_description, argument, _options, block)
+        return if !argument.is_a?(Array) || argument.first.class != ::Class || block.is_a?(Proc)
+
+        new(param_description, argument)
+      end
+
+      def description
+        "Must be one of: #{@array.join(', ')}."
+      end
+    end
+
+    class ProcValidator < BaseValidator
+      def initialize(param_description, argument)
+        super(param_description)
+        @proc = argument
+      end
+
+      def validate(value)
+        # The proc should return true if value is valid
+        # Otherwise it should return a string
+        !(@help = @proc.call(value)).is_a?(String)
+      end
+
+      def self.build(param_description, argument, _options, _block)
+        return if !argument.is_a?(Proc) || argument.arity != 1
+
+        new(param_description, argument)
+      end
+
+      def description
+        @help
+      end
+    end
+
+    class HashValidator < BaseValidator
+      include ApipieDSL::Base
+      include ApipieDSL::Parameter
+      include ApipieDSL::Klass
+
+      def initialize(param_description, argument, param_group)
+        super(param_description)
+        @param_group = param_group
+        instance_exec(&argument)
+        prepare_hash_params
+      end
+
+      def self.build(param_description, argument, options, block)
+        return if argument != Hash || !block.is_a?(Proc) || block.arity.positive?
+
+        new(param_description, block, options[:param_group])
+      end
+
+      def sub_params
+        @sub_params ||= dsl_data[:params].map do |args|
+          options = args.find { |arg| arg.is_a?(Hash) }
+          options[:parent] = param_description
+          ApipieDSL::ParameterDescription.from_dsl_data(param_description.method_description, args)
+        end
+      end
+
+      def validate(value)
+        return false unless value.is_a?(Hash)
+
+        @hash_params&.each do |name, param|
+          if ApipieDSL.configuration.validate_value?
+            param.validate(value[name]) if value.key?(name)
+          end
+        end
+        true
+      end
+
+      def description
+        'Must be a Hash'
+      end
+
+      def expected_type
+        'hash'
+      end
+
+      def default_param_group_scope
+        @param_group && @param_group[:scope]
+      end
+
+      def merge_with(other_validator)
+        if other_validator.is_a?(HashValidator)
+          @sub_params = ApipieDSL::ParameterDescription.unify(sub_params + other_validator.sub_params)
+          prepare_hash_params
+        else
+          super
+        end
+      end
+
+      private
+
+      def prepare_hash_params
+        @hash_params = sub_params.each_with_object({}) do |param, hash|
+          hash.update(param.name.to_sym => param)
+        end
+      end
+    end
+
+    class DecimalValidator < BaseValidator
+      def self.build(param_description, argument, _options, _block)
+        return if argument != :decimal
+
+        new(param_description)
+      end
+
+      def validate(value)
+        value.to_s =~ /\A^[-+]?[0-9]+([,.][0-9]+)?\Z$/
+      end
+
+      def description
+        'Must be a decimal number'
+      end
+    end
+
+    class NumberValidator < BaseValidator
+      def self.build(param_description, argument, _options, _block)
+        return if argument != :number
+
+        new(param_description)
+      end
+
+      def validate(value)
+        value.to_s =~ /\A(0|[1-9]\d*)\Z$/
+      end
+
+      def description
+        'Must be a number'
+      end
+
+      def expected_type
+        'numeric'
+      end
+    end
+
+    class BooleanValidator < BaseValidator
+      def self.build(param_description, argument, _options, _block)
+        return unless %i[bool boolean].include?(argument)
+
+        new(param_description)
+      end
+
+      def validate(value)
+        %w[true false 1 0].include?(value.to_s)
+      end
+
+      def description
+        string = %w[true false 1 0].map { |value| "<code>#{value}</code>" }.join(', ')
+        "Must be one of: #{string}"
+      end
+
+      def expected_type
+        'boolean'
+      end
+    end
+
+    class RestValidator < BaseValidator
+      def self.build(param_description, argument, _options, _block)
+        return unless %i[rest list splat].include?(argument)
+
+        new(param_description)
+      end
+
+      def validate(_value)
+        # In *rest param we don't care about passed values.
+        true
+      end
+
+      def description
+        'Must be a list of values'
+      end
+
+      def expected_type
+        'list'
+      end
+    end
+
+    class NestedValidator < BaseValidator
+      def initialize(param_description, argument, param_group)
+        super(param_description)
+        @validator = HashValidator.new(param_description, argument, param_group)
+        @type = argument
+      end
+
+      def self.build(param_description, argument, options, block)
+        return if argument != Array || !block.is_a?(Proc) || block.arity.positive?
+
+        new(param_description, block, options[:param_group])
+      end
+
+      def validate(value)
+        value ||= []
+        return false if value.class != Array
+
+        value.each do |child|
+          return false unless @validator.validate(child)
+        end
+        true
+      end
+
+      def expected_type
+        'array'
+      end
+
+      def description
+        'Must be an Array of nested elements'
+      end
+
+      def sub_params
+        @validator.sub_params
+      end
+    end
+  end
+end