validate-rb 0.1.0.pre → 1.0.0.alpha.1

data/lib/validate/compare.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Validate
+  module Compare
+    module TransformUsing
+      def using(&transform_block)
+        @transform_block = transform_block
+        self
+      end
+
+      def <=>(other)
+        return super if @transform_block.nil?
+
+        super(@transform_block.call(other))
+      end
+    end
+
+    class WithAttributes
+      include Comparable
+      prepend TransformUsing
+
+      def initialize(attributes)
+        @attributes = attributes
+      end
+
+      def <=>(other)
+        @attributes.each do |attribute, value|
+          result = value <=> other.send(attribute)
+          return result unless result.zero?
+        end
+
+        0
+      end
+
+      def method_missing(symbol, *args)
+        return super unless args.empty? && respond_to_missing?(symbol)
+
+        @attributes[symbol]
+      end
+
+      def respond_to_missing?(attribute, _ = false)
+        @attributes.include?(attribute)
+      end
+
+      def to_s
+        '<attributes ' + @attributes.map { |attribute, value| "#{attribute}: #{value}"}
+                                    .join(', ') + '>'
+      end
+    end
+
+    class ToValue
+      include Comparable
+      prepend TransformUsing
+
+      def initialize(value_block)
+        @value_block = value_block
+      end
+
+      def <=>(other)
+        @value_block.call <=> other
+      end
+
+      def to_s
+        '<dynamic value>'
+      end
+    end
+
+    module_function
+
+    def attributes(**attributes)
+      WithAttributes.new(attributes)
+    end
+
+    def to(value = nil, &value_block)
+      value_block ||= value.is_a?(Proc) ? value : proc { value }
+      ToValue.new(value_block)
+    end
+  end
+end

data/lib/validate/constraint.rb

@@ -0,0 +1,231 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Validate
+  class Constraint
+    class Violation
+      attr_reader :value, :path, :constraint
+
+      def initialize(value, path, constraint)
+        @value = value
+        @path = path
+        @constraint = constraint
+      end
+
+      def message(template = @constraint.message)
+        (template % parameters).strip
+      end
+
+      alias to_s message
+
+      private
+
+      def parameters
+        @parameters ||= Hash.new do |_, key|
+          String(instance_eval(key.to_s))
+        end
+      end
+    end
+
+    class Option
+      attr_reader :name
+
+      def initialize(name, default:, assertion: nil, &assert_block)
+        @name = name
+        @default = default.is_a?(Proc) ? default : -> { default }
+        @assertion = assertion || assert_block && Assertions.create(&assert_block)
+      end
+
+      def replace_default(default)
+        Option.new(@name, default: default, assertion: @assertion)
+      end
+
+      def get_or_default(options)
+        value = options.delete(@name) { return @default&.call }
+        @assertion&.assert(value, message: "invalid option #{@name}")
+        value
+      end
+    end
+
+    def self.inherited(child)
+      child.extend DSL
+    end
+
+    def self.create_class(name, **defaults, &constraint_block)
+      Class.new(self) do
+        @supported_options = common_options.transform_values do |option|
+          defaults.include?(option.name) ? option.replace_default(defaults[option.name]) : option
+        end
+        include(@constraint_user_methods = Module.new)
+        @constraint_user_methods.define_method(:name) { name.to_s }
+        class_eval(&constraint_block)
+        if instance_variable_defined?(:@supported_options)
+          initialize { |**options| options }
+        end
+      end
+    end
+
+    module DSL
+      def constraint_name
+        @constraint_name ||= Assertions.create do
+          not_nil(message: 'constraint name must not be nil')
+          is_a(Symbol, message: 'constraint name must be a Symbol')
+        end
+      end
+      module_function :constraint_name
+
+      def common_options
+        @common_options ||= {
+            message: Option.new(:message, default: 'be %{constraint.name}') do
+              not_blank
+              is_a(String)
+            end
+        }.freeze
+      end
+      module_function :common_options
+
+      def option(
+          name,
+          default: lambda do
+            raise Error::KeyError,
+                  "option #{name.inspect} is required for #{self.name}"
+          end,
+          &assert_block
+      )
+        constraint_name.assert(name)
+        if @supported_options.include?(name)
+          raise Error::ArgumentError, "duplicate option :#{name}"
+        end
+
+        @supported_options[name] = Option.new(
+            name,
+            default: default,
+            &assert_block
+        )
+        self
+      end
+
+      def initialize(&initialize_block)
+        supported_options = @supported_options
+        expects_kwargs = false
+        initialize_block.parameters.each do |(kind, name)|
+          if %i(keyreq key).include?(kind) && supported_options.include?(name)
+            raise Error::ArgumentError,
+                  "key name #{name}: conflicts with an existing option"
+          end
+          expects_kwargs = true if kind == :keyrest
+        end
+
+        define_constraint_method(:initialize, initialize_block) do |*args, &block|
+          if args.last.is_a?(Hash)
+            known_options, kwargs =
+                args.pop
+                    .partition { |k, _| supported_options.include?(k) }
+                    .map { |h| Hash[h] }
+
+            if !expects_kwargs && !kwargs.empty?
+              args << kwargs
+              kwargs = {}
+            end
+
+            if expects_kwargs
+              merged_options = {}.merge!(super(*args, **kwargs, &block), known_options)
+            else
+              args << kwargs unless kwargs.empty?
+              merged_options = {}.merge!(super(*args, &block), known_options)
+            end
+          else
+            merged_options = super(*args, &block)
+          end
+
+          options = supported_options.each_with_object({}) do |(n, opt), opts|
+            opts[n] = opt.get_or_default(merged_options)
+          end
+
+          unless merged_options.empty?
+            raise Error::ArgumentError,
+                  "unexpected options #{merged_options.inspect}"
+          end
+
+          @options = options.freeze
+        end
+        remove_instance_variable(:@supported_options)
+      end
+
+      def evaluate(&validation_block)
+        define_constraint_method(:valid?, validation_block) do |*args|
+          catch(:result) do
+            super(*args[0...validation_block.arity])
+            :pass
+          end == :pass
+        end
+        self
+      end
+
+      def describe(&describe_block)
+        define_method(:to_s, &describe_block)
+        self
+      end
+
+      def key(&key_block)
+        define_method(:name, &key_block)
+        self
+      end
+
+      private
+
+      def define_constraint_method(name, body, &override)
+        @constraint_user_methods.__send__(:define_method, name, &body)
+        define_method(name, &override)
+        self
+      end
+    end
+
+    attr_reader :options
+    protected :options
+
+    def initialize(**options)
+      @options = options
+    end
+
+    def name
+      raise ::NotImplementedError
+    end
+
+    def valid?(value, ctx = Constraints::ValidationContext.none)
+      raise ::NotImplementedError
+    end
+
+    def to_s
+      name.to_s.gsub('_', ' ')
+    end
+
+    def inspect
+      "#<#{self.class.name} #{@options.map { |name, value| "#{name}: #{value.inspect}" }.join(', ')}>"
+    end
+
+    def ==(other)
+      other.is_a?(Constraint) && other.name == name && other.options == options
+    end
+
+    def respond_to_missing?(method, _ = false)
+      @options.include?(method)
+    end
+
+    def method_missing(method, *args)
+      return super unless args.empty? || respond_to_missing?(method)
+
+      @options[method]
+    end
+
+    private
+
+    def fail
+      throw(:result, :fail)
+    end
+
+    def pass
+      throw(:result, :pass)
+    end
+  end
+end

data/lib/validate/constraints.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+module Validate
+  module Constraints
+    include Validate::Arguments
+
+    @reserved_names = Hash[%i[define validation_context].map { |n| [n, n] }]
+
+    arg(:name) do
+      not_blank(message: 'constraint name must not be blank')
+      is_a(Symbol, message: 'constraint name must be a Symbol')
+    end
+    arg(:body) do
+      not_nil(message: 'constraint body is required')
+    end
+    def self.define(name, **defaults, &body)
+      if @reserved_names.include?(name)
+        raise Error::ArgumentError,
+              "#{name} is already defined"
+      end
+
+      @reserved_names[name] = name
+      constraint_class = Constraint.create_class(name, **defaults, &body)
+      Constraints.const_set(Helpers.camelize(name), constraint_class)
+      define_method(name, &constraint_class.method(:new))
+      module_function(name)
+    end
+
+    define(:not_nil, message: 'not be nil') do
+      evaluate { |value| fail if value.nil? }
+    end
+
+    define(:not_blank, message: 'not be blank') do
+      evaluate do |value|
+        fail if value.nil? || !value.respond_to?(:empty?) || value.empty?
+      end
+    end
+
+    define(:not_empty, message: 'not be empty') do
+      evaluate { |value| fail if value&.empty? }
+    end
+
+    define(:is_a, message: 'be a %{constraint.klass}') do
+      option(:klass) do
+        not_nil(message: 'klass is required')
+      end
+
+      initialize { |klass| { klass: klass } }
+      evaluate do |value|
+        pass if value.nil?
+
+        klass = options[:klass]
+        fail unless klass === value
+      end
+    end
+
+    define(:respond_to, message: 'respond to %{constraint.method_name.inspect}') do
+      option(:method_name) do
+        not_blank(message: 'method_name is required')
+        is_a(Symbol, message: 'method_name must be a Symbol')
+      end
+
+      initialize do |method_name|
+        method_name.nil? ? {} : { method_name: method_name }
+      end
+      evaluate do |instance|
+        pass if instance.nil?
+        fail unless instance.respond_to?(options[:method_name])
+      end
+      key { "respond_to_#{options[:method_name]}" }
+    end
+
+    define(:length, message: 'have length of %{constraint.describe_length}') do
+      option(:min) { respond_to(:>, message: 'min must respond to :>') }
+      option(:max) { respond_to(:<, message: 'max must respond to :<') }
+
+      initialize do |range = nil|
+        case range
+        when ::Range
+          { min: range.min, max: range.max }
+        else
+          { min: range, max: range }
+        end
+      end
+      evaluate do |value|
+        pass if value.nil?
+        fail unless value.respond_to?(:length)
+
+        length = value.length
+        fail if (options[:min]&.> length) || (options[:max]&.< length)
+      end
+
+      def describe_length
+        if options[:max] == options[:min]
+          options[:max].to_s
+        elsif options[:max].nil?
+          "at least #{options[:min]}"
+        elsif options[:min].nil?
+          "at most #{options[:max]}"
+        else
+          "at least #{options[:min]} and at most #{options[:max]}"
+        end
+      end
+      key { "length_over_#{options[:min]}_under_#{options[:max]}" }
+    end
+
+    define(:one_of, message: 'be %{constraint.describe_presence}') do
+      option(:values) do
+        respond_to(:include?, message: 'values must respond to :include?')
+      end
+
+      initialize do |*values|
+        if values.one? && values.first.respond_to?(:include?)
+          { values: values.first }
+        else
+          { values: values }
+        end
+      end
+      evaluate do |value|
+        pass if value.nil?
+
+        values = options[:values]
+        pass if values.respond_to?(:cover?) && values.cover?(value)
+        fail unless values.include?(value)
+      end
+
+      def describe_presence
+        case options[:values]
+        when ::Hash
+          "one of #{options[:values].keys}"
+        when ::Range
+          "covered by #{options[:values]}"
+        else
+          "one of #{options[:values]}"
+        end
+      end
+    end
+
+    define(:validate, message: 'pass validation') do
+      option(:using) do
+        not_nil(message: 'using is required')
+        is_a(Proc, message: 'using must be a Proc')
+      end
+
+      initialize { |&validate_block| { using: validate_block } }
+      evaluate do |value|
+        pass if value.nil?
+        fail unless instance_exec(value, &options[:using])
+      end
+    end
+
+    define(:attr, message: 'have attribute %{constraint.attribute}') do
+      option(:attribute) do
+        not_nil(message: 'attribute is required')
+        is_a(Symbol, message: 'attribute must be a Symbol')
+      end
+      option(:constraints) do
+        is_a(AST::DefinitionContext, message: 'constraints must be a DefinitionContext')
+      end
+
+      initialize do |attribute, &block|
+        { attribute: attribute,
+          constraints: block && AST::DefinitionContext.create(&block) }
+      end
+      evaluate do |value, ctx|
+        pass if value.nil?
+
+        attribute = options[:attribute]
+        begin
+          options[:constraints].evaluate(ctx.attr(attribute))
+        rescue NameError
+          fail
+        end
+      end
+      key { "attr_#{options[:attribute]}" }
+    end
+
+    define(:key, message: 'have key %{constraint.key.inspect}') do
+      option(:key) do
+        not_nil(message: 'key is required')
+      end
+      option(:constraints) do
+        is_a(AST::DefinitionContext, message: 'constraints must be a DefinitionContext')
+      end
+
+      initialize do |key, &block|
+        { key: key,
+          constraints: block && AST::DefinitionContext.create(&block) }
+      end
+
+      evaluate do |instance, ctx|
+        pass if instance.nil?
+        fail unless instance.respond_to?(:[])
+
+        key = options[:key]
+        begin
+          options[:constraints]&.evaluate(ctx[key])
+        rescue KeyError
+          fail
+        end
+      end
+      key { "key_#{options[:key]}" }
+    end
+
+    define(:min, message: 'be at least %{constraint.min}') do
+      option(:min) do
+        not_nil(message: 'min is required')
+        respond_to(:>, message: 'min must respond to :>')
+      end
+
+      initialize do |min = nil|
+        min.nil? ? {} : { min: min }
+      end
+      evaluate do |value|
+        pass if value.nil?
+        fail if options[:min] > value
+      end
+    end
+
+    define(:max, message: 'be at most %{constraint.max}') do
+      option(:max) do
+        not_nil(message: 'max is required')
+        respond_to(:<, message: 'max must respond to :<')
+      end
+
+      initialize do |max = nil|
+        max.nil? ? {} : { max: max }
+      end
+      evaluate do |value|
+        pass if value.nil?
+        fail if options[:max] < value
+      end
+    end
+
+    define(:equal, message: 'be equal to %{constraint.equal}') do
+      option(:equal) do
+        not_nil(message: 'equal is required')
+        respond_to(:==, message: 'equal must respond to :==')
+      end
+
+      initialize do |equal = nil|
+        equal.nil? ? {} : { equal: equal }
+      end
+      evaluate do |value|
+        pass if value.nil?
+        fail unless options[:equal] == value
+      end
+    end
+
+    define(:match, message: 'match %{constraint.regexp}') do
+      option(:regexp) do
+        not_nil(message: 'regexp is required')
+        respond_to(:=~, message: 'regexp must respond to :=~')
+      end
+
+      initialize do |regexp = nil|
+        regexp.nil? ? {} : { regexp: regexp }
+      end
+      evaluate do |value|
+        pass if value.nil?
+        fail unless value.is_a?(String) && options[:regexp] =~ value
+      end
+    end
+
+    define(:valid, message: 'be valid %{constraint.validator || value.class}') do
+      option(:validator, default: nil)
+
+      initialize do |validator = nil|
+        validator.nil? ? {} : { validator: validator }
+      end
+      evaluate do |value, ctx|
+        pass if value.nil?
+
+        Scope.current
+            .validator(options[:validator] || value.class)
+            .validate(ctx)
+      end
+      key { options[:validator] && "valid_#{options[:validator]}" || 'valid' }
+    end
+
+    define(:each_value, message: 'have values') do
+      option(:constraints) do
+        not_nil(message: 'constraints are required')
+        is_a(AST::DefinitionContext, message: 'constraints must be a DefinitionContext')
+      end
+
+      initialize do |&block|
+        return {} if block.nil?
+
+        { constraints: AST::DefinitionContext.create(&block) }
+      end
+      evaluate do |collection, ctx|
+        pass if collection.nil?
+        fail unless collection.respond_to?(:each)
+
+        constraints = options[:constraints]
+        case collection
+        when ::Hash
+          collection.each do |key, value|
+            constraints.evaluate(ctx[key])
+          end
+        else
+          i = 0
+          collection.each do |value|
+            constraints.evaluate(ctx[i])
+            i += 1
+          end
+        end
+      end
+    end
+
+    define(
+        :unique,
+        message: 'have unique %{constraint.describe_unique_attribute}'
+    ) do
+      option(:attribute, default: nil) do
+        is_a(Symbol, message: 'attribute %{value.inspect} must be a Symbol')
+      end
+
+      initialize do |attribute = nil|
+        attribute.nil? ? {} : { attribute: attribute }
+      end
+      evaluate do |value|
+        pass if value.nil?
+        fail unless value.respond_to?(:uniq) && value.respond_to?(:size)
+        fail unless value.size == value.uniq(&options[:attribute]).size
+      end
+      key do
+        options[:attribute] && "unique_#{options[:attribute]}" || 'unique'
+      end
+
+      def describe_unique_attribute
+        options[:attribute] || 'values'
+      end
+    end
+  end
+end