validate-rb 0.1.0.pre → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d7f65479ecf94e4e15474fd5f86ca4bd8b46a4260b0a1e77b3d666ca0e52e8d
-  data.tar.gz: dec398c1f408cd2bfdee3281e386c313f19d67d9cfc5ade0c3c22bf16c3b764c
+  metadata.gz: 950214c76f33653b36c70bf0ac8a5bd9e639823b394317f4d433c16796ca1e10
+  data.tar.gz: 4a41af1288c617845258471dafb59efde0d63d6d89afc8f020cfd7fce7b49fc2
 SHA512:
-  metadata.gz: 32b614ffea7a9909f64a3ced25f761347b19358771f9b6579d0eaa55e7bda35c6cf30650026faa3e4149b7205cb77f5fdcfb574516ac6ad78eac59bf076e9b15
-  data.tar.gz: 897066f58c0f7f7197b1821902a5039279a34ac1cb3c196448a3d4a5caf2bc1e3fc45fa8fdf0919ad5ba45a09363a087afac3715d7201189b1127f31f3d6a8f9
+  metadata.gz: 2a28334e266467a7a3de84b4cfd06c5d64a8c016dd4150de9ec5d0d9dc910342f7be0829556def6686c73d3a8c7fd281ac2648ac8cdaadd34de02cd74ca69f99
+  data.tar.gz: 75e60c01c7a1d51f424fc0194aae5771ead30dc739fddf75f673b480c5e3459d22c1e74491b7806098553aabce50feadfc5f22fec14507a14ba7ce18c13821f6

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

@@ -1,4 +1,4 @@
-# Validate.rb
+# Validate.rb ![CI](https://github.com/Gusto/validate-rb/workflows/CI/badge.svg)
 
 Yummy constraint validations for Ruby
 
@@ -7,7 +7,7 @@ Yummy constraint validations for Ruby
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'validaterb'
+gem 'validate-rb'
 ```
 
 And then execute:
@@ -16,7 +16,7 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install validaterb
+    $ gem install validate-rb
 
 ## Usage
 
@@ -120,5 +120,5 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/gusto-validation.
+Bug reports and pull requests are welcome on GitHub at https://github.com/gusto/validate-rb.
 

data/lib/validate.rb

@@ -1,6 +1,81 @@
 # frozen_string_literal: true
 
-require "validaterb/version"
+require 'forwardable'
+require 'monitor'
+require 'ipaddr'
 
+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,94 @@
+module Validate
+  module Arguments
+    module ClassMethods
+      def method_added(method_name)
+        super
+        guard_method(instance_method(method_name), @methods_guard)
+      end
+
+      def singleton_method_added(method_name)
+        super
+        guard_method(singleton_method(method_name), @singleton_methods_guard)
+      end
+
+      def arg(name, &body)
+        if @args.include?(name)
+          raise Error::ArgumentError, "duplicate argument :#{name}"
+        end
+
+        @args[name] = Assertions.create(&body)
+        self
+      end
+
+      private
+
+      def guard_method(method, guard_module)
+        return if @args.empty?
+        guard = ArgumentsGuard.new(method, @args)
+        guard_module.__send__(:define_method, method.name) do |*args, **kwargs, &block|
+          if kwargs.empty?
+            guard.enforce!(*args, &block)
+            super(*args, &block)
+          else
+            guard.enforce!(*args, **kwargs, &block)
+            super(*args, **kwargs, &block)
+          end
+        end
+      ensure
+        @args = {}
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.instance_exec do
+        @args = {}
+        prepend(@methods_guard = Module.new)
+        singleton_class.prepend(@singleton_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: '#{name}') unless #{name}.eql?(DEFAULT_VALUE)"
+        end
+
+        singleton_class.class_eval(<<~RUBY, __FILE__, __LINE__)
+          def enforce!(#{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