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

data/lib/validate/ast.rb

@@ -1,381 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Validate
-  module AST
-    def self.build(*args, &block)
-      Generator.new
-          .generate(*args, &block)
-          .freeze
-    end
-
-    class DefinitionContext
-      module Builder
-        module_function
-
-        def all_constraints(*constraints)
-          Rules::Unanimous.new(constraints.map { |node| send(*node) })
-        end
-
-        def at_least_one_constraint(*constraints)
-          Rules::Affirmative.new(constraints.map { |node| send(*node) })
-        end
-
-        def no_constraints(*constraints)
-          Rules::Negative.new(constraints.map { |node| send(*node) })
-        end
-
-        def constraint(name, args, block, trace)
-          if defined?(Constraints) && Constraints.respond_to?(name)
-            begin
-              return Constraints.send(name, *(args.map { |node| send(*node) }), &block)
-            rescue => e
-              ::Kernel.raise Error::ValidationRuleError, e.message, trace
-            end
-          end
-
-          Rules::Pending.new(name, args.map { |node| send(*node) }, block, trace)
-        end
-
-        def value(value)
-          value
-        end
-      end
-
-      def self.create(*args, &block)
-        ast = AST.build(*args, &block)
-        context = new
-        ast.each { |node| context.add_constraint(Builder.send(*node)) }
-        context
-      end
-
-      def initialize
-        @constraints = {}
-      end
-
-      def add_constraint(constraint)
-        if @constraints.include?(constraint.name)
-          raise Error::ValidationRuleError,
-                "duplicate constraint #{constraint.name}"
-        end
-
-        @constraints[constraint.name] = constraint
-        self
-      end
-
-      def evaluate(ctx)
-        @constraints.each_value
-            .reject { |c| catch(:pending) { c.valid?(ctx.value, ctx) } }
-            .each { |c| ctx.add_violation(c) }
-        ctx
-      end
-    end
-
-    CORE_CONSTRAINTS = %i[
-        not_nil not_blank not_empty
-        is_a one_of validate
-        min max equal match
-        valid each_value unique
-        length
-      ].freeze
-
-    class Generator < ::BasicObject
-      def initialize
-        @stack = []
-      end
-
-      def generate(*args, &block)
-        instance_exec(*args, &block)
-
-        if @stack.one? && @stack.first[0] == :all_constraints
-          return @stack.first[1..-1]
-        end
-
-        @stack
-      end
-
-      def &(other)
-        unless other == self
-          ::Kernel.raise(
-            Error::ValidationRuleError,
-            'bad rule, only constraints and &, |, and ! operators allowed'
-          )
-        end
-
-        right = @stack.pop
-        left = @stack.pop
-        if right[0] == :all_constraints
-          right.insert(1, left)
-          @stack << right
-        else
-          @stack << [:all_constraints, left, right]
-        end
-        self
-      end
-
-      def |(other)
-        unless other == self
-          ::Kernel.raise(
-            Error::ValidationRuleError,
-            'bad rule, only constraints and &, |, and ! operators allowed'
-          )
-        end
-
-        right = @stack.pop
-        left = @stack.pop
-        if right[0] == :at_least_one_constraint
-          right.insert(1, left)
-          @stack << right
-        else
-          @stack << [:at_least_one_constraint, left, right]
-        end
-        self
-      end
-
-      def !
-        prev = @stack.pop
-        if prev[0] == :no_constraints
-          @stack << prev[1]
-        elsif prev[0] == :all_constraints
-          prev[0] = :no_constraints
-          @stack << prev
-        else
-          @stack << [:no_constraints, prev]
-        end
-        self
-      end
-
-      private
-
-      def method_missing(method, *args, &block)
-        return super unless respond_to_missing?(method)
-
-        @stack << [
-            :constraint,
-            method,
-            args.map { |arg| [:value, arg] },
-            block,
-            ::Kernel.caller
-                .reject { |line| line.include?(__FILE__) }
-        ]
-        self
-      end
-
-      def respond_to_missing?(method, _ = false)
-        (defined?(Constraints) && Constraints.respond_to?(method)) || CORE_CONSTRAINTS.include?(method)
-      end
-    end
-
-    module Combinator
-      extend Forwardable
-      def_delegators :@constraints, :[]
-
-      def respond_to_missing?(_, _ = false)
-        false
-      end
-
-      private
-
-      def constraint_message(index)
-        @constraints[index].message % Hash.new do |_, key|
-          if key.to_s.start_with?('constraint')
-            "%{#{key.to_s.gsub('constraint', "constraint[#{index}]")}}"
-          else
-            "%{#{key}}"
-          end
-        end
-      end
-    end
-
-    module Rules
-      class Pending < Constraint
-        include MonitorMixin
-
-        def initialize(name, args, block, caller)
-          @name = name
-          @args = args
-          @block = block
-          @caller = caller
-          @constraint = nil
-
-          extend SingleForwardable
-          mon_initialize
-        end
-
-        def name
-          load_constraint { return @name }.name
-        end
-
-        def valid?(value, ctx = Constraints::ValidationContext.none)
-          load_constraint { throw(:pending, true) }.valid?(value, ctx)
-        end
-
-        def to_s
-          load_constraint { return "[pending #{@name}]" }.to_s
-        end
-
-        def inspect
-          load_constraint { return "[pending #{@name}]" }.inspect
-        end
-
-        def ==(other)
-          load_constraint { return false } == other
-        end
-
-        def method_missing(method, *args)
-          load_constraint { return NameError }.__send__(method, *args)
-        end
-
-        def respond_to_missing?(method, pvt = false)
-          load_constraint { return false }.__send__(:respond_to_missing?, method, pvt)
-        end
-
-        private
-
-        def load_constraint
-          yield unless defined?(Constraints) && Constraints.respond_to?(@name)
-
-          synchronize do
-            return @constraint if @constraint
-
-            begin
-              @constraint = Constraints.send(@name, *@args, &@block)
-            rescue => e
-              ::Kernel.raise Error::ValidationRuleError, e.message, @caller
-            end
-
-            def_delegators(:@constraint, :name, :valid?, :to_s,
-                           :inspect, :==, :message)
-
-            @name = @args = @block = @caller = nil
-            @constraint
-          end
-        end
-      end
-
-      class Unanimous < Constraint
-        include Combinator
-        include Arguments
-
-        arg(:constraints) do
-          not_nil
-          length(min: 2)
-          each_value { is_a(Constraint) }
-          unique(:name)
-        end
-        def initialize(constraints)
-          @constraints = constraints.freeze
-        end
-
-        def valid?(value, _ = Constraints::ValidationContext.none)
-          ctx = Constraints::ValidationContext.root(value)
-          @constraints.all? do |c|
-            c.valid?(value, ctx) && !ctx.has_violations?
-          end
-        end
-
-        def name
-          'both_' + @constraints.map(&:name).sort.join('_and_')
-        end
-
-        def inspect
-          return @constraints.first.inspect if @constraints.one?
-
-          "(#{@constraints.map(&:inspect).join(' & ')})"
-        end
-
-        def message
-          'both ' + @constraints
-                        .size
-                        .times
-                        .map { |i| "[#{constraint_message(i)}]" }
-                        .join(', and ')
-        end
-      end
-
-      class Affirmative < Constraint
-        include Combinator
-        include Arguments
-
-        arg(:constraints) do
-          not_nil
-          length(min: 2)
-          each_value { is_a(Constraint) }
-          unique(:name)
-        end
-        def initialize(constraints)
-          @constraints = constraints.freeze
-        end
-
-        def valid?(value, _ = Constraints::ValidationContext.none)
-          ctx = Constraints::ValidationContext.root(value)
-          @constraints.any? do |c|
-            ctx.clear_violations
-            c.valid?(value, ctx) && !ctx.has_violations?
-          end
-        end
-
-        def name
-          'either_' + @constraints.map(&:name).sort.join('_or_')
-        end
-
-        def inspect
-          return @constraints.first.inspect if @constraints.one?
-
-          "(#{@constraints.map(&:inspect).join(' | ')})"
-        end
-
-        def message
-          'either ' + @constraints
-                          .size
-                          .times
-                          .map { |i| "[#{constraint_message(i)}]" }
-                          .join(', or ')
-        end
-      end
-
-      class Negative < Constraint
-        include Combinator
-        include Arguments
-
-        arg(:constraints) do
-          not_nil
-          not_empty
-          each_value { is_a(Constraint) }
-          unique(:name)
-        end
-        def initialize(constraints)
-          @constraints = constraints.freeze
-        end
-
-        def valid?(value, _ = Constraints::ValidationContext.none)
-          ctx = Constraints::ValidationContext.root(value)
-          @constraints.none? do |c|
-            ctx.clear_violations
-            c.valid?(value, ctx) && !ctx.has_violations?
-          end
-        end
-
-        def name
-          'neither_' + @constraints.map(&:name).sort.join('_nor_')
-        end
-
-        def message
-          return "not [#{constraint_message(0)}]" if @constraints.one?
-
-          'neither ' + @constraints
-                           .size
-                           .times
-                           .map { |i| "[#{constraint_message(i)}]" }
-                           .join(', nor ')
-        end
-
-        def inspect
-          return "!#{@constraints.first.inspect}" if @constraints.one?
-
-          "!(#{@constraints.map(&:inspect).join(' & ')})"
-        end
-      end
-    end
-  end
-end

data/lib/validate/compare.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Validate
-  module Compare
-    class ByAttributes
-      include Comparable
-
-      def initialize(attributes)
-        @attributes = attributes
-      end
-
-      def <=>(other)
-        @attributes.map { |attribute, value| value <=> other.send(attribute) }
-                   .find { |result| !result.zero? } || 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
-    end
-
-    module_function
-
-    def attributes(**attributes)
-      ByAttributes.new(attributes)
-    end
-  end
-end

data/lib/validate/constraint.rb

@@ -1,217 +0,0 @@
-# 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, **kwargs, &block|
-          known_options, extra_kwargs =
-              kwargs.partition { |k, _| supported_options.include?(k) }
-                  .map { |h| Hash[h] }
-          args << extra_kwargs if expects_kwargs || !extra_kwargs.empty?
-
-          merged_options = {}.merge!(super(*args, &block), known_options)
-
-          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,
-                  "undefined 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