validate-rb 0.1.0.alpha.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec9996734d51898a4f003a56c2cb45748c14d58b138ddb03d1291d9cf6a4ed28
-  data.tar.gz: 144941aa76f0db9224309d7b3614bc41e5e5fd59b37b7419f4785dd77498abf6
+  metadata.gz: 2bac2b6ec6ca8d71becc3849cc26401c63a7939c2d9ee7618ccc022f5845080a
+  data.tar.gz: 995c743d5e16aa7a4239d0cd4e6eb500b6cd1541184eab44b7605c4f61494751
 SHA512:
-  metadata.gz: 3145f4f69e4eb2969d4eafc9c4f92faa4c3a63c2b15061bef8abea109fab30648ace5104c8e8c81314c7b63a1ee0452899d0074cb1ee8fef15ec000443a95f87
-  data.tar.gz: 7c2f705b8a0da5e05652491060462a783554429a5ea32ecc08e25364ec675e31aac769f23a4f6ec9fbca07e5317cfa9224e99a06820c051b60a8e761890beaea
+  metadata.gz: 80bcb6b3ef21a26dd8d39f0dd4666b1185c65011a9dc3cc4e57af6cb9f6329abe7dc9a83fd8aa415e2490d920f7dbdd2b1e950c9838b93b879ca655888944ff0
+  data.tar.gz: d687a04ae9a0c0b8a40f3ec4f851583b0edbe2014003f25196b7463beded4c970d6060b0aa79b767e3bb84d46c777103410de5331292220ce026cdb5c08d9b22

data/lib/validate.rb

@@ -2,6 +2,7 @@
 
 require 'forwardable'
 require 'monitor'
+require 'ipaddr'
 
 require_relative 'validate/version'
 require_relative 'validate/errors'

data/lib/validate/arguments.rb

@@ -3,32 +3,12 @@ module Validate
     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
+        guard_method(instance_method(method_name), @methods_guard)
       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
+        guard_method(singleton_method(method_name), @singleton_methods_guard)
       end
 
       def arg(name, &body)
@@ -39,6 +19,24 @@ module Validate
         @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)
@@ -46,6 +44,7 @@ module Validate
       base.instance_exec do
         @args = {}
         prepend(@methods_guard = Module.new)
+        singleton_class.prepend(@singleton_methods_guard = Module.new)
       end
     end
 
@@ -73,17 +72,19 @@ module Validate
           when :block
             signature << "&#{name}"
           else
-            raise Error::ArgumentError, "unsupported parameter type #{kind}"
+            raise Error::ArgumentError,
+                  "unsupported parameter type #{kind}"
           end
           next unless rules.include?(name)
 
-          assertions << "@rules[:#{name}].assert(#{name}, message: 'invalid argument #{name}')"
+          assertions <<
+            "@rules[:#{name}].assert(#{name}, message: '#{name}') unless #{name}.eql?(DEFAULT_VALUE)"
         end
 
-        singleton_class.class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            def #{method.name}(#{signature.join(', ')})
-              #{assertions.join("\n  ")}
-            end
+        singleton_class.class_eval(<<~RUBY, __FILE__, __LINE__)
+          def enforce!(#{signature.join(', ')})
+            #{assertions.join("\n  ")}
+          end
         RUBY
 
         @rules = rules

data/lib/validate/ast.rb

@@ -5,8 +5,8 @@ module Validate
   module AST
     def self.build(*args, &block)
       Generator.new
-          .generate(*args, &block)
-          .freeze
+               .generate(*args, &block)
+               .freeze
     end
 
     class DefinitionContext
@@ -65,8 +65,8 @@ module Validate
 
       def evaluate(ctx)
         @constraints.each_value
-            .reject { |c| catch(:pending) { c.valid?(ctx.value, ctx) } }
-            .each { |c| ctx.add_violation(c) }
+                    .reject { |c| catch(:pending) { c.valid?(ctx.value, ctx) } }
+                    .each { |c| ctx.add_violation(c) }
         ctx
       end
     end
@@ -156,7 +156,7 @@ module Validate
             args.map { |arg| [:value, arg] },
             block,
             ::Kernel.caller
-                .reject { |line| line.include?(__FILE__) }
+                    .reject { |line| line.include?(__FILE__) }
         ]
         self
       end
@@ -286,10 +286,10 @@ module Validate
 
         def message
           'both ' + @constraints
-                        .size
-                        .times
-                        .map { |i| "[#{constraint_message(i)}]" }
-                        .join(', and ')
+                    .size
+                    .times
+                    .map { |i| "[#{constraint_message(i)}]" }
+                    .join(', and ')
         end
       end
 
@@ -327,10 +327,10 @@ module Validate
 
         def message
           'either ' + @constraints
-                          .size
-                          .times
-                          .map { |i| "[#{constraint_message(i)}]" }
-                          .join(', or ')
+                      .size
+                      .times
+                      .map { |i| "[#{constraint_message(i)}]" }
+                      .join(', or ')
         end
       end
 
@@ -364,10 +364,10 @@ module Validate
           return "not [#{constraint_message(0)}]" if @constraints.one?
 
           'neither ' + @constraints
-                           .size
-                           .times
-                           .map { |i| "[#{constraint_message(i)}]" }
-                           .join(', nor ')
+                       .size
+                       .times
+                       .map { |i| "[#{constraint_message(i)}]" }
+                       .join(', nor ')
         end
 
         def inspect

data/lib/validate/compare.rb

@@ -2,16 +2,34 @@
 
 module Validate
   module Compare
-    class ByAttributes
+    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.map { |attribute, value| value <=> other.send(attribute) }
-                   .find { |result| !result.zero? } || 0
+        @attributes.each do |attribute, value|
+          result = value <=> other.send(attribute)
+          return result unless result.zero?
+        end
+
+        0
       end
 
       def method_missing(symbol, *args)
@@ -23,12 +41,39 @@ module Validate
       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)
-      ByAttributes.new(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

@@ -116,13 +116,27 @@ module Validate
           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?
+        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
 
-          merged_options = {}.merge!(super(*args, &block), known_options)
+            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)
@@ -130,7 +144,7 @@ module Validate
 
           unless merged_options.empty?
             raise Error::ArgumentError,
-                  "undefined options #{merged_options.inspect}"
+                  "unexpected options #{merged_options.inspect}"
           end
 
           @options = options.freeze

data/lib/validate/constraints.rb

@@ -20,7 +20,7 @@ module Validate
       end
 
       @reserved_names[name] = name
-      constraint_class = Constraint.create_class(name, defaults, &body)
+      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)
@@ -104,6 +104,40 @@ module Validate
       key { "length_over_#{options[:min]}_under_#{options[:max]}" }
     end
 
+    define(:bytesize, message: 'have byte 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?(:bytesize)
+
+        bytesize = value.bytesize
+        fail if (options[:min]&.> bytesize) || (options[:max]&.< bytesize)
+      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 { "bytesize_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?')
@@ -309,6 +343,146 @@ module Validate
       end
     end
 
+    define(:each_key, message: 'have keys') 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_key)
+
+        constraints = options[:constraints]
+        collection.each_key do |key|
+          key_ctx = Constraints::ValidationContext.key(key)
+          constraints.evaluate(key_ctx)
+          ctx.merge(key_ctx) if key_ctx.has_violations?
+        end
+      end
+    end
+
+    define(:start_with, message: 'start with %{constraint.prefix}') do
+      option(:prefix) do
+        not_blank(message: 'prefix is required')
+        is_a(String, message: 'prefix must be a String')
+      end
+
+      initialize do |prefix = nil|
+        return {} if prefix.nil?
+
+        { prefix: prefix }
+      end
+      evaluate do |value|
+        pass if value.nil?
+        fail unless value.respond_to?(:start_with?) && value.start_with?(options[:prefix])
+      end
+      key do
+        "start_with_#{options[:prefix]}"
+      end
+    end
+
+    define(:end_with, message: 'end with %{constraint.suffix}') do
+      option(:suffix) do
+        not_blank(message: 'suffix is required')
+        is_a(String, message: 'suffix must be a String')
+      end
+
+      initialize do |suffix = nil|
+        return {} if suffix.nil?
+
+        { suffix: suffix }
+      end
+      evaluate do |value|
+        pass if value.nil?
+        fail unless value.respond_to?(:end_with?) && value.end_with?(options[:suffix])
+      end
+      key do
+        "end_with_#{options[:suffix]}"
+      end
+    end
+
+    define(:contain, message: 'contain %{constraint.substring}') do
+      option(:substring) do
+        not_blank(message: 'substring is required')
+        is_a(String, message: 'substring must be a String')
+      end
+
+      initialize do |substring = nil|
+        return {} if substring.nil?
+
+        { substring: substring }
+      end
+      evaluate do |value|
+        pass if value.nil?
+        fail unless value.respond_to?(:include?) && value.include?(options[:substring])
+      end
+      key do
+        "contain_#{options[:substring]}"
+      end
+    end
+
+    define(:uuid, message: 'be a uuid') do
+      UUID_REGEXP = %r{\b\h{8}\b-\h{4}-\h{4}-\h{4}-\b\h{12}\b}
+
+      evaluate do |value|
+        pass if value.nil?
+        fail unless UUID_REGEXP.match?(value.to_s)
+      end
+    end
+
+    define(:hostname, message: 'be a hostname') do
+      HOSTNAME_REGEXP = URI::HOST
+
+      evaluate do |value|
+        pass if value.nil?
+        fail unless HOSTNAME_REGEXP.match?(value.to_s)
+      end
+    end
+
+    define(:uri, message: 'be a uri') do
+      option(:absolute, default: true) do
+        one_of([true, false], message: ':absolute must be true or false')
+      end
+
+      evaluate do |value|
+        pass if value.nil?
+        uri = begin
+                URI.parse(value)
+              rescue URI::Error
+                fail
+              end
+        fail unless options[:absolute] == uri.absolute?
+      end
+    end
+
+    define(:ip_address, message: 'be an ip address') do
+      option(:version, default: nil) do
+        one_of([:v4, :v6], message: 'must be a valid ip version')
+      end
+
+      initialize do |version = nil|
+        return {} if version.nil?
+
+        { version: version }
+      end
+      evaluate do |value|
+        pass if value.nil?
+        addr = begin
+                 IPAddr.new(value)
+               rescue IPAddr::Error
+                 fail
+               end
+        version = options[:version]
+        fail unless version.nil? || addr.send(:"ip#{version}?")
+      end
+    end
+
     define(
         :unique,
         message: 'have unique %{constraint.describe_unique_attribute}'

data/lib/validate/constraints/validation_context.rb

@@ -11,7 +11,12 @@ module Validate
         new(value, Path.new, violations)
       end
 
-      attr_reader :value
+      def self.key(key, violations = [])
+        new(key, Path.new([KeyPath.new(key)]), violations)
+      end
+
+      attr_reader :value, :violations
+      protected :violations
 
       def initialize(value, path = Path.new, violations = [])
         @value      = value
@@ -61,8 +66,17 @@ module Validate
         !@violations.empty?
       end
 
-      def to_err
-        Error::ConstraintViolationError.new(@violations.freeze)
+      def to_err(backtrace = [])
+        err = Error::ConstraintViolationError.new(@violations.freeze)
+        err.set_backtrace(backtrace)
+        err
+      end
+
+      def merge(other)
+        other.violations.each do |violation|
+          @violations << Constraint::Violation.new(violation.value, @path.child(violation.path), violation.constraint)
+        end
+        self
       end
 
       private
@@ -87,7 +101,14 @@ module Validate
         end
 
         def child(path)
-          Path.new(@paths.dup << path)
+          case path
+          when KeyPath, AttrPath
+            Path.new(@paths.dup << path)
+          when Path
+            Path.new(@paths.dup << path.to_a)
+          else
+            raise ArgumentError, 'invalid path'
+          end
         end
 
         def to_s

data/lib/validate/errors.rb

@@ -31,9 +31,9 @@ module Validate
 
       def message
         @violations.group_by(&:path)
-            .transform_values { |violations| violations.map(&:message) }
-            .map { |path, messages| "#{path}: #{messages.join(' ')}" }
-            .join("\n")
+                   .transform_values { |violations| violations.map(&:message) }
+                   .map { |path, messages| "#{path}: #{messages.join(', ')}" }
+                   .join("\n")
       end
     end
   end

data/lib/validate/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Validate
-  VERSION = '0.1.0.alpha.1'
+  VERSION = '1.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: validate-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0.alpha.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Bulat Shakirzyanov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-20 00:00:00.000000000 Z
+date: 2020-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aruba
@@ -150,9 +150,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.0.3
 signing_key: