validate-rb 0.1.0.alpha.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ec9996734d51898a4f003a56c2cb45748c14d58b138ddb03d1291d9cf6a4ed28
+  data.tar.gz: 144941aa76f0db9224309d7b3614bc41e5e5fd59b37b7419f4785dd77498abf6
+SHA512:
+  metadata.gz: 3145f4f69e4eb2969d4eafc9c4f92faa4c3a63c2b15061bef8abea109fab30648ace5104c8e8c81314c7b63a1ee0452899d0074cb1ee8fef15ec000443a95f87
+  data.tar.gz: 7c2f705b8a0da5e05652491060462a783554429a5ea32ecc08e25364ec675e31aac769f23a4f6ec9fbca07e5317cfa9224e99a06820c051b60a8e761890beaea

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Gusto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,124 @@
+# Validate.rb ![CI](https://github.com/Gusto/validate-rb/workflows/CI/badge.svg)
+
+Yummy constraint validations for Ruby
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'validate-rb'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install validate-rb
+
+## Usage
+
+### Defining a validator
+
+Validators are a collection of constraints
+
+```ruby
+require 'validate'
+
+# validators can be named
+Validate::Validators.define(:create_user_request) do
+  # attr is a type of constraint that defines constraints on an attribute
+  attr(:username) { not_blank }
+  attr(:address) do
+    not_nil
+    # 'valid' constraint continues validation further down the object graph
+    valid
+  end
+end
+
+# validators can also be defined for a specific class
+Validate::Validators.define(Address) do
+  attr(:street) do
+    not_blank
+    is_a(String)
+    attr(:length) { max(255) }
+  end
+
+  attr(:zip) do
+    # constraints have default error messages, which can be changed
+    match(/[0-9]{5}\-[0-9]{4}/, message: '%{value.inspect} must be a zip')
+  end
+end
+
+address = Address.new(street: '123 Any Road', zip: '11223-3445')
+request = CreateUser.new(username: 'janedoe',
+                         address: address)
+
+violations = Validate.validate(request, as: :create_user_request)
+
+violations.group_by(&:path).each do |path, violations|
+  puts "#{path} is invalid:"
+  violations.each do |v|
+    puts "  #{v.message}"
+  end
+end
+```
+
+### Creating constraints
+
+Constraints have properties and can be evaluated
+
+```ruby
+# constraints must have a name
+Validate::Constraints.define(:not_blank) do
+  # evaluation can 'fail' or 'pass'
+  evaluate { |value| fail if value.nil? || value.empty? }
+end
+
+# 'attr' is just another constraint, like 'not_blank'
+Validate::Constraints.define(:attr) do
+  # constraints can have options
+  # every constraint at least has a :message option
+  # constraint options can have validation constraints
+  option(:name) { not_blank & is_a(Symbol) }
+  option(:validator) { is_a(Validate::Validators::Validator) }
+
+  # by default, constraints expect **kwargs for options
+  # initializer can be defined to translates from arbitrary args to options map
+  initialize do |name, &validation_block|
+    {
+      name: name,
+      # validators can be created anonymously
+      validator: Validate::Validators.create(&validation_block)
+    }
+  end
+
+  evaluate do |value, ctx|
+    # pass constraints on non-values to support optional validation
+    pass if value.nil?
+
+    # fetch an option
+    name = options[:name]
+    fail unless value.respond_to?(name)
+
+    # validation context can be used to traverse object graph
+    # `ValidationContext#attr(attribute)` creates a `ValidationContext` for object's `attribute`
+    # there is also `ValidationContext#key` to validate keys in a hash, useful for ENV validation
+    attr_ctx = ctx.attr(name)
+    options[:validator]&.validate(attr_ctx)
+  end
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/gusto/validate-rb.
+

data/lib/validate.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'monitor'
+
+require_relative 'validate/version'
+require_relative 'validate/errors'
+require_relative 'validate/constraint'
+require_relative 'validate/assertions'
+require_relative 'validate/arguments'
+require_relative 'validate/ast'
+require_relative 'validate/scope'
+require_relative 'validate/helpers'
+require_relative 'validate/constraints/validation_context'
+require_relative 'validate/constraints'
+require_relative 'validate/validators/dsl'
+require_relative 'validate/validators'
+require_relative 'validate/compare'
+
+# Validate.rb can be used independently by calling {Validate.validate}
+# or included in classes and modules.
+#
+# @example Validating an object using externally defined metadata
+#   Address = Struct.new(:street, :city, :state, :zip)
+#   Validate::Validators.define(Address) do
+#     attr(:street) { not_blank }
+#     attr(:city) { not_blank }
+#     attr(:state) { not_blank & length(2) }
+#     attr(:zip) { not_blank & match(/[0-9]{5}(\-[0-9]{4})?/) }
+#   end
+#   puts Validate.validate(Address.new)
+#
+# @example Validating an object using metdata defined in class
+#   class Address < Struct.new(:street, :city, :state, :zip)
+#     include Validate
+#     validate do
+#       attr(:street) { not_blank }
+#       attr(:city) { not_blank }
+#       attr(:state) { not_blank & length(2) }
+#       attr(:zip) { not_blank & match(/[0-9]{5}(\-[0-9]{4})?/) }
+#     end
+#   end
+#   puts Validate.validate(Address.new)
+module Validate
+  # Validate an object and get constraint violations list back
+  #
+  # @param object [Object] object to validate
+  # @param as [Symbol, Class] (object.class) validator to use, defaults to
+  #   object's class
+  #
+  # @return [Array<Constraint::Violation>] list of constraint violations
+  def self.validate(object, as: object.class)
+    violations = []
+    Scope.current
+         .validator(as)
+         .validate(Constraints::ValidationContext.root(object, violations))
+    violations.freeze
+  end
+
+  # Check if a given validator exists
+  #
+  # @param name [Symbol, Class] validator to check
+  #
+  # @return [Boolean] `true` if validator is present, `else` otherwise
+  def self.validator?(name)
+    Scope.current.validator?(name)
+  end
+
+  # Hook to allow for inclusion in class or module
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # @private
+  module ClassMethods
+    def validator(&body)
+      @validator ||= Validators.create(&body)
+    end
+  end
+end

data/lib/validate/arguments.rb

@@ -0,0 +1,93 @@
+module Validate
+  module Arguments
+    module ClassMethods
+      def method_added(method_name)
+        super
+        return if @args.empty?
+
+        method = instance_method(method_name)
+        guard = ArgumentsGuard.new(method, @args.dup)
+
+        @methods_guard.__send__(:define_method, method_name) do |*args, &block|
+          guard.send(method_name, *args, &block)
+          super(*args, &block)
+        end
+      ensure
+        @args.clear
+      end
+
+      def singleton_method_added(method_name)
+        super
+        return if @args.empty?
+
+        method = singleton_method(method_name)
+        guard = ArgumentsGuard.new(method, @args.dup)
+
+        @methods_guard.__send__(:define_singleton_method, method_name) do |*args, &block|
+          guard.send(method_name, *args, &block)
+          super(*args, &block)
+        end
+      ensure
+        @args.clear
+      end
+
+      def arg(name, &body)
+        if @args.include?(name)
+          raise Error::ArgumentError, "duplicate argument :#{name}"
+        end
+
+        @args[name] = Assertions.create(&body)
+        self
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.instance_exec do
+        @args = {}
+        prepend(@methods_guard = Module.new)
+      end
+    end
+
+    class ArgumentsGuard
+      DEFAULT_VALUE = BasicObject.new
+
+      def initialize(method, rules)
+        signature = []
+        assertions = []
+
+        method.parameters.each do |(kind, name)|
+          case kind
+          when :req
+            signature << name.to_s
+          when :opt
+            signature << "#{name} = DEFAULT_VALUE"
+          when :rest
+            signature << "*#{name}"
+          when :keyreq
+            signature << "#{name}:"
+          when :key
+            signature << "#{name}: DEFAULT_VALUE"
+          when :keyrest
+            signature << "**#{name}"
+          when :block
+            signature << "&#{name}"
+          else
+            raise Error::ArgumentError, "unsupported parameter type #{kind}"
+          end
+          next unless rules.include?(name)
+
+          assertions << "@rules[:#{name}].assert(#{name}, message: 'invalid argument #{name}')"
+        end
+
+        singleton_class.class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+            def #{method.name}(#{signature.join(', ')})
+              #{assertions.join("\n  ")}
+            end
+        RUBY
+
+        @rules = rules
+      end
+    end
+  end
+end

data/lib/validate/assertions.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Validate
+  module Assertions
+    module_function
+
+    def create(*args, &block)
+      Assertion.new(AST::DefinitionContext.create(*args, &block))
+    end
+
+    class Assertion
+      def initialize(validation_context)
+        @constraints = validation_context
+      end
+
+      def assert(value, error_class: Error::ArgumentError, message: 'invalid value')
+        ctx = Constraints::ValidationContext.root(value)
+        @constraints.evaluate(ctx)
+        return value unless ctx.has_violations?
+
+        raise error_class, message,
+              cause: ctx.to_err
+      end
+    end
+  end
+end

data/lib/validate/ast.rb

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