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

data/lib/validate/constraints/validation_context.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-module Validate
-  module Constraints
-    class ValidationContext
-      def self.none
-        @none ||= None.new
-      end
-
-      def self.root(value, violations = [])
-        new(value, Path.new, violations)
-      end
-
-      attr_reader :value
-
-      def initialize(value, path = Path.new, violations = [])
-        @value      = value
-        @path       = path
-        @violations = violations
-        @keys = Hash.new do |hash, key|
-          unless @value.respond_to?(:[]) || @value.respond_to_missing?(:[])
-            raise Error::KeyError,
-                  "#{key.inspect}: value doesn't respond to :[]"
-          end
-          begin
-            hash[key] = child_context(@value[key], KeyPath.new(key))
-          rescue => e
-            raise Error::KeyError,
-                  "#{key.inspect}: #{e.message}",
-                  cause: e
-          end
-        end
-        @attrs = Hash.new do |hash, attr|
-          unless @value.respond_to?(attr) || @value.respond_to_missing?(attr)
-            raise Error::NameError,
-                  "#{attr.inspect}: value doesn't respond to #{attr.inspect}"
-          end
-          hash[attr] = child_context(@value.send(attr), AttrPath.new(attr))
-        end
-      end
-
-      def [](key)
-        @keys[key]
-      end
-
-      def attr(name)
-        @attrs[name]
-      end
-
-      def add_violation(constraint)
-        @violations << create_violation(constraint)
-        self
-      end
-
-      def clear_violations
-        @violations.clear
-        self
-      end
-
-      def has_violations?
-        !@violations.empty?
-      end
-
-      def to_err
-        Error::ConstraintViolationError.new(@violations.freeze)
-      end
-
-      private
-
-      def create_violation(constraint)
-        Constraint::Violation.new(@value, @path, constraint)
-      end
-
-      def child_context(value, path)
-        ValidationContext.new(value, @path.child(path), @violations)
-      end
-
-      class Path
-        extend Forwardable
-
-        def_delegators(:@paths, :empty?, :length, :size, :each)
-
-        include Enumerable
-
-        def initialize(paths = [])
-          @paths = paths
-        end
-
-        def child(path)
-          Path.new(@paths.dup << path)
-        end
-
-        def to_s
-          return '.' if @paths.empty?
-
-          @paths.join
-        end
-
-        def at(index)
-          raise Error::IndexError if index.negative?
-
-          return nil if index.zero?
-          @paths.fetch(index - 1)
-        end
-
-        def inspect
-          return "#<#{self.class.name} <root>>" if @paths.empty?
-
-          "#<#{self.class.name} #{to_s}>"
-        end
-      end
-
-      class KeyPath
-        def initialize(key)
-          @key = key
-        end
-
-        def to_s
-          "[#{@key.inspect}]"
-        end
-
-        def inspect
-          "#<#{self.class.name} #{@key.inspect}>"
-        end
-      end
-
-      class AttrPath
-        def initialize(attr)
-          @attr = attr
-        end
-
-        def to_s
-          ".#{@attr}"
-        end
-
-        def inspect
-          "#<#{self.class.name} #{@attr.inspect}>"
-        end
-      end
-
-      class None < ValidationContext
-        def initialize
-        end
-
-        def [](_)
-          self
-        end
-
-        def attr(_)
-          self
-        end
-
-        def add_violation(_)
-          self
-        end
-
-        def clear_violations
-          self
-        end
-
-        def has_violations?
-          false
-        end
-      end
-    end
-  end
-end

data/lib/validate/constraints.rb

@@ -1,337 +0,0 @@
-# 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

data/lib/validate/errors.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Validate
-  module Error
-    class StandardError < ::StandardError
-      include Error
-    end
-
-    class ArgumentError < ::ArgumentError
-      include Error
-    end
-
-    class KeyError < ::KeyError
-      include Error
-    end
-
-    class IndexError < ::IndexError
-      include Error
-    end
-
-    class ValidationRuleError < StandardError
-    end
-
-    class ConstraintViolationError < StandardError
-      attr_reader :violations
-
-      def initialize(violations)
-        @violations = violations
-        super()
-      end
-
-      def message
-        @violations.group_by(&:path)
-            .transform_values { |violations| violations.map(&:message) }
-            .map { |path, messages| "#{path}: #{messages.join(' ')}" }
-            .join("\n")
-      end
-    end
-  end
-end

data/lib/validate/helpers.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Validate
-  module Helpers
-    module_function
-
-    def camelize(name)
-      name.to_s.split('_').collect(&:capitalize).join
-    end
-  end
-end

data/lib/validate/scope.rb

@@ -1,48 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Validate
-  class Scope
-    def self.current
-      @current ||= Scope.new
-    end
-
-    def initialize
-      @constraints = {}
-      @validators = {}
-    end
-
-    def register_validator(name, validator)
-      if @validators.include?(name)
-        raise Error::ArgumentError,
-              "duplicate validator :#{name}"
-      end
-
-      @validators[name] = validator
-    end
-
-    def validator?(name)
-      @validators.include?(name)
-    end
-
-    def validator(name)
-      validator_name.assert(name,
-                            message: "invalid validator #{name.inspect}",
-                            error_class: KeyError)
-
-      @validators.fetch(name) { name.validator }
-    end
-
-    private
-
-    def validator_name
-      @validator_name ||= Assertions.create(@validators) do |validators|
-        not_nil(message: 'name must not be nil')
-        (one_of(values: validators,
-                message: '%{value.inspect} must be an existing validator name') |
-            respond_to(:validator,
-                       message: '%{value.inspect} must respond to :validator'))
-      end
-    end
-  end
-end

data/lib/validate/validators/dsl.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Validate
-  module Validators
-    module DSL
-      include Arguments
-
-      arg(:name) { is_a(Module) | (is_a(Symbol) & not_blank) }
-      def define(name, &body)
-        Scope.current.register_validator(name, create(&body))
-      end
-
-      def create(&block)
-        Validator.new(&block)
-      end
-
-      def none
-        @none ||= Validator::None.new
-      end
-    end
-
-    class Validator
-      def initialize(&block)
-        @constraints = AST::DefinitionContext.create(&block)
-      end
-
-      def validate(ctx)
-        @constraints.evaluate(ctx)
-      end
-
-      private
-
-      class None < Validator
-        NO_VIOLATIONS = [].freeze
-
-        def initialize; end
-
-        def validate(*args)
-          NO_VIOLATIONS
-        end
-      end
-    end
-  end
-end

data/lib/validate/validators.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Validate
-  module Validators
-    extend DSL
-  end
-end