fend 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f9f96fc948bc1fc0e30a18c67ce1597c6ab6388d
-  data.tar.gz: 85cdf09079a2a087c1be08703a7f203d6920b325
+  metadata.gz: 5d13258d558a3a951a5b468994dd43d71e5146cb
+  data.tar.gz: 961c725b800fee07ed70e6f937fab1b8e97c42f3
 SHA512:
-  metadata.gz: 595c8b6770e4ed1e28c63edb07b5745a130d0025810a926153e420729b107b2d9ac72ed927cba975416bcbd9b7e9168a0a374305381742428db1bb069799bf45
-  data.tar.gz: 010a595c487f5408a351d4679bf9b17d1d6722269a6f3b79a579ec53998313af8f7f9c2fdcd17cdaf3dbca912ae0e08b9a3f49bc57533d1272f8fcd4771af201
+  metadata.gz: 78062b89d15fb139ef304be7764a1e0f3bba18f3f8f53d58a7ae70456c8740e2cbf284e36e5e2b3696cf4693db73a4219ec12bddf043b826b4333ff9ef3b037c
+  data.tar.gz: 4849a34a6212b5495a4cad9aa3d6635564164f820669136791cdc36b5f0c1f4fd194feaabe41a6849a171c66ac5c45afc75338cf496f6c9552de5d9af539bbaa

data/README.md

@@ -1,4 +1,4 @@
-# Fend [![Build Status](https://travis-ci.org/aradunovic/fend.svg?branch=master)](https://travis-ci.org/aradunovic/fend)
+# Fend [![Gem Version](https://badge.fury.io/rb/fend.svg)](https://badge.fury.io/rb/fend) [![Build Status](https://travis-ci.org/aradunovic/fend.svg?branch=master)](https://travis-ci.org/aradunovic/fend)
 
 Fend is a small and extensible data validation toolkit.
 
@@ -16,12 +16,13 @@ Fend is a small and extensible data validation toolkit.
     * [Value helpers](#value-helpers)
     * [Validation helpers](#validation-helpers)
     * [Validation options](#validation-options)
-    * [Collective params](#collective-params)
+    * [Contexts](#contexts)
     * [Data processing](#data-processing)
     * [Dependencies](#dependencies)
     * [Coercions](#coercions)
     * [External validation](#external-validation)
     * [Full messages](#full-messages)
+    * [Object validation](#object-validation)
 * [**Code of Conduct**](#code-of-conduct)
 * [**License**](#license)
 
@@ -34,6 +35,8 @@ Some of the features include:
 * Dependency management
 * Custom/external validation support
 * Data processing
+* Contextual validations
+* Object validation
 
 ## Documentation
 
@@ -80,14 +83,31 @@ class UserValidation < Fend
   # define validation block
   validation do |i|
     # specify :username param that needs to be validated
-    i.param(:username) do |username|
+    i.params(:username, :email) do |username, email|
       # append error if username value is not string
       username.add_error("must be string") unless username.value.is_a?(String)
 
+      email.add_error("is not a valid email address") unless email.match?(EMAIL_REGEX)
+      email.add_error("must be unique") if email.valid? && !unique?(email: email.value)
+
       username.valid? #=> false
-      username.invalid? #=> true
+      email.invalid? #=> true
     end
   end
+
+  # you have full access to the constructor
+  def initialize(user_model)
+    @user_model = user_model
+  end
+
+  # custom methods are available in validation block
+  def unique?(args)
+    user_model.exists?(args)
+  end
+
+  def user_model
+    @user_model
+  end
 end
 ```
 
@@ -98,7 +118,7 @@ Let's run the validation:
 
 ```ruby
 # run the validation and store the result
-result = UserValidation.call(username: 1234)
+result = UserValidation.new(User).call(username: 1234, email: "invalid@email")
 
 # check if result is a success
 result.success? #=> false
@@ -107,13 +127,13 @@ result.success? #=> false
 result.failure? #=> true
 
 # get validation input
-result.input #=> { username: 1234 }
+result.input #=> { username: 1234, email: "invalid@email" }
 
 # get result output
-result.input #=> { username: 1234 }
+result.input #=> { username: 1234, email: "invalid@email" }
 
 # get error messages
-result.messages #=> { username: ["must be string"] }
+result.messages #=> { username: ["must be string"], email: ["is not a valid email address"] }
 ```
 
 `result` is an instance of `Result` class.
@@ -123,14 +143,11 @@ result.messages #=> { username: ["must be string"] }
 Nested params are defined in the same way as regular params:
 
 ```ruby
-i.param(:address) do |address|
+i.params(:address) do |address|
   address.add_error("must be hash") unless address.value.is_a?(Hash)
 
-  address.param(:city) do |city|
+  address.params(:city, :street) do |city, :street|
     city.add_error("must be string") unless city.value.is_a?(String)
-  end
-
-  address.param(:street) do |street|
     street.add_error("must be string") unless street.value.is_a?(String)
   end
 end
@@ -196,8 +213,6 @@ The `value_helpers` plugin provides additional `Param` methods that can be used
 check or fetch param values.
 
 ```ruby
-plugin :collective_params
-
 plugin :value_helpers
 
 validate do |i|
@@ -231,21 +246,17 @@ The `validation_helpers` plugin provides methods for some common validation case
 plugin :validation_helpers
 
 validation do |i|
-  i.param(:username) do |username|
+  i.params(:username, :address, :tags) do |username, address, tags|
     username.validate_presence
     username.validate_type(String)
-  end
 
-  i.param(:address) do |address|
     address.validate_type(Hash)
 
     address.param(:city) do |city|
       city.validate_presence
       city.validate_type(String)
     end
-  end
 
-  i.param(:tags) do |tags|
     tags.validate_type(Array)
     tags.validate_min_length(1)
 
@@ -266,17 +277,13 @@ can be used in order to specify all validations as options.
 plugin :validation_options
 
 validation do |i|
-  i.param(:username) { |username| username.validate(presence: true, type: String) }
+  i.params(:username, :address, :tags) do |username, address, tags|
+    username.validate(presence: true, type: String)
 
-  i.param(:address) do |address|
     address.validate_type(Hash)
+    address.params(:city) { |city| city.validate(presence: true, type: String) }
 
-    address.param(:city) { |city| city.validate(presence: true, type: String) }
-  end
-
-  i.param(:tags) do |tags|
     tags.validate(type: Array, min_length: 1)
-
     tags.each do |tag|
       tag.validate(type: String,
                    inclusion: { in: %w(ruby js elixir), message: "#{tag.value} is not a valid tag" })
@@ -285,35 +292,45 @@ validation do |i|
 end
 ```
 
-### Collective params
+`:allow_nil` and `:allow_blank` options are also supported:
+
+```ruby
+username.validate(type: String, allow_nil: true)
+```
+
+### Contexts
 
-Specifying params one by one can be tedious in some/most cases.
-With `collective_params` plugin, you can specify multiple params at once, by
-using `#params` method, instead of `#param`:
+`contexts` plugin adds support for contextual validation, which basically
+means you can branch validation logic depending on provided context.
 
 ```ruby
-plugin :validation_options
-plugin :collective_params
+class UserValidation < Fend
+  plugin :contexts
 
-validation do |i|
-  i.params(:username, :address, :tags) do |username, address, tags|
-    username.validate(presence: true, type: String)
+  validate do |i|
+    i.params(:account_type) do |acc_type|
+      context(:admin) do
+        acc_type.validate_equality("admin")
+      end
 
-    address.validate_type(Hash)
-    address.params(:city, :street) do |street, city|
-      city.validate(presence: true, type: String) }
-      street.validate(presence: true, type: String)
-    end
+      context(:editor) do
+        acc_type.validate_equality("editor")
+      end
 
-    tags.validate(type: Array, min_length: 1)
-    tags.each do |tag|
-      tag.validate(type: String,
-                   inclusion: { in: %w(ruby js elixir), message: "#{tag.value} is not a valid tag" })
+      # you can check context against multiple values
+      context(:visitor, :demo) do
+        acc_type.validate_equality(nil)
+      end
     end
   end
 end
+
+user_validation = UserValidation.new(context: :editor)
+user_validation.call(account_type: "invalid").messages #=> { account_type: ["must be equal to 'editor'"] }
 ```
 
+If no context is provided, context will be set to `:default`.
+
 ### Data processing
 
 With `data_processing` plugin you can process input/output data.
@@ -358,51 +375,29 @@ result.output #=> { username: "john", timestamp: 2018-01-01 00:00:00 UTC }
 
 ### Dependencies
 
-The `dependencies` plugin enables you to register and resolve dependencies.
-
-There are two types of dependencies:
-
-1. Inheritable - Available in subclasses also
-2. Local - registered under a key in `deps` registry. Available only in the current
-class
+The `dependencies` plugin enables you to register and resolve global dependencies.
 
 To resolve dependencies, pass `:inject` option with dependency list
 to `.validate` method:
 
 ```ruby
-plugin :collective_params
 plugin :validation_options
-
 plugin :dependencies, user_model: User
 
-validate(inject: [:user_model, :context]) do |i, user_model, context|
-
+validate(inject: [:user_model]) do |i, user_model|
   i.params(:email, :password, :password_confirmation) do |email, password, password_confirmation|
-
-    email.add_error("not found") if email.present? && !user_model.exists?(email: email.value)
-
-    if context == :password_change
-      password.validate(type: String, min_length: 6)
-      if password.valid?
-        password.add_error("must be confirmed") unless password.value == password_confirmation.value
-      end
+    if email.present? && !user_model.exists?(email: email.value)
+      email.add_error("not found")
     end
   end
 end
-
-def initialize(context)
-  deps[:context] = context
-end
 ```
 
-Here, `:user_model` is an inheritable dependency, while `:context` is local.
-
-As you can see, we're expecting for `context` to be passed in the initializer:
+Here, `:user_model` is an inheritable dependency, which means it will be
+available in subclasses also. Global dependencies can be defined on `Fend` directly:
 
 ```ruby
-result = UserValidation.new(:password_change).call(email: "foo@bar.com", password: :invalid)
-
-result.messages #=> { email: ["not found"], password: ["must be string", "must be confirmed"] }
+Fend.plugin :dependencies, user_model: User
 ```
 
 ### Coercions
@@ -411,8 +406,6 @@ result.messages #=> { email: ["not found"], password: ["must be string", "must b
 By default, incoercible values are returned unmodified.
 
 ```ruby
-plugin :collective_params
-
 plugin :coercions
 
 coerce username: :string,
@@ -458,7 +451,6 @@ end
 
 class AddressValidation < Fend
   plugin :validation_options
-  plugin :collective_params
 
   validate do |i|
     i.params(:city, :street) do |city, street|
@@ -469,7 +461,6 @@ class AddressValidation < Fend
 end
 
 class UserValidation < Fend
-  plugin :collective_params
   plugin :external_validation
 
   validate do |i|
@@ -504,6 +495,43 @@ result.full_messages
 # }
 ```
 
+### Object validation
+
+`object_validation` plugin adds support for validating object attributes
+and methods.
+
+```ruby
+class UserModelValidation < Fend
+  plugin :object_validation
+  plugin :validation_options
+
+  validate do |user|
+    # use #attrs when validating object attributes/methods
+    user.attrs(:username, :email, :address) do |username, email, address|
+      username.validate(presence: true, max_length: 20, type: String)
+      email.validate(presence: true, format: EMAIL_REGEX, type: String)
+
+      # keep using #params if attribute value is expected to be hash
+      address.params(:city, :street) do |city, street|
+        city.validate(presence: true)
+        street.validate(presence: true)
+      end
+    end
+  end
+end
+
+user = User.new(username: "", email: "invalid@email", address: {})
+validation = UserModelValidation.call(user)
+
+validation.success? #=> false
+validation.messages
+#=> {
+#      username: ["must be present"],
+#      email: ["is in invalid format"],
+#      address: { city: ["must be present"], street: ["must be present"] }
+#   }
+```
+
 ## Code of Conduct
 
 Everyone interacting in the Fend project’s codebases, issue trackers, chat rooms

data/fend.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |gem|
   gem.homepage     = "https://fend.radunovic.io"
   gem.license      = "MIT"
 
-  gem.files        = Dir["README.md", "LICENSE.txt", "lib/**/*.rb", "fend.gemspec"]
+  gem.files        = Dir["README.md", "LICENSE.txt", "lib/**/*.rb", "fend.gemspec", "doc/*.md"]
   gem.require_path = "lib"
 
   gem.required_ruby_version = ">= 2.0"

data/lib/fend.rb

@@ -85,7 +85,7 @@ class Fend
         # Store validation block for later execution:
         #
         #   validate do |i|
-        #     i.param(:foo) do |foo|
+        #     i.params(:foo) do |foo|
         #       # foo validation logic
         #     end
         #   end
@@ -96,6 +96,11 @@ class Fend
         def call(input)
           new.call(input)
         end
+
+        # Prints a deprecation warning to standard error.
+        def deprecation(message)
+          warn "FEND DEPRECATION WARNING: #{message}"
+        end
       end
 
       module InstanceMethods
@@ -116,7 +121,7 @@ class Fend
           @_raw_data    = raw_data
           @_input_data  = process_input(raw_data) || raw_data
           @_output_data = process_output(@_input_data) || @_input_data
-          @_input_param  = param_class.new(@_input_data)
+          @_input_param = param_class.new(:input, @_input_data)
         end
 
         # Returns validation block set on class level
@@ -140,9 +145,9 @@ class Fend
         # Process output data
         def process_output(output); end
 
-        # Start validation
+        # Execute validation block
         def validate(&block)
-          yield(@_input_param) if block_given?
+          instance_exec(@_input_param, &block) if block_given?
         end
 
         # Instantiate and return result
@@ -160,37 +165,61 @@ class Fend
         # Get param value
         attr_reader :value
 
+        # Get param name
+        attr_reader :name
+
         # Get param validation errors
         attr_reader :errors
 
-        def initialize(value)
+        def initialize(name, value)
+          @name = name
           @value = value
           @errors = []
         end
 
         # Fetch nested value
         def [](name)
+          fetch(name)
+        end
+
+        def fetch(name)
           @value.fetch(name, nil) if @value.respond_to?(:fetch)
         end
 
         # Define child param and execute validation block
         def param(name, &block)
+          Fend.deprecation("Calling Param#param to specify params is deprecated and will not be supported in Fend 0.3.0. Use Param#params method instead.")
+
           return if flat? && invalid?
 
           value = self[name]
-          param = _build_param(value)
+          param = _build_param(name, value)
 
           yield(param)
 
           _nest_errors(name, param.errors) if param.invalid?
         end
 
+        # Define child params and execute validation block
+        def params(*names, &block)
+          return if flat? && invalid?
+
+          params = names.each_with_object({}) do |name, result|
+            param = _build_param(name, self[name])
+            result[name] = param
+          end
+
+          yield(*params.values)
+
+          params.each { |name, param| _nest_errors(name, param.errors) if param.invalid? }
+        end
+
         # Define array member param and execute validation block
         def each(&block)
-          return if (flat? && invalid?) || !@value.is_a?(Array)
+          return if (flat? && invalid?) || !@value.is_a?(Enumerable)
 
           @value.each_with_index do |value, index|
-            param = _build_param(value)
+            param = _build_param(index, value)
 
             yield(param, index)
 
@@ -218,7 +247,7 @@ class Fend
         end
 
         def to_s
-          "#{fend_class.inspect}::Param"
+          "#{fend_class.inspect}::Param #{super}"
         end
 
         # Return Fend class under which Param class is namespaced

data/lib/fend/plugins/collective_params.rb

@@ -2,7 +2,7 @@
 
 class Fend
   module Plugins
-    # `collective_params` plugin allows you to specify multiple params at once,
+    # *[DEPRECATED] `collective_params` plugin allows you to specify multiple params at once,
     # instead of defining each one separately.
     #
     # Example:
@@ -40,11 +40,13 @@ class Fend
     #     end
     module CollectiveParams
       module ParamMethods
+        warn("collective_params plugin is deprecated and will be removed in Fend 0.3.0. #params method is now provided out of the box.")
+
         def params(*names, &block)
           return if flat? && invalid?
 
           params = names.each_with_object({}) do |name, result|
-            param = _build_param(self[name])
+            param = _build_param(name, self[name])
             result[name] = param
           end
 

data/lib/fend/plugins/contexts.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+class Fend
+  module Plugins
+    # `contexts` plugin adds support for contextual validation, which basically
+    # means you can branch validation logic depending on provided context.
+    #
+    #     class UserValidation < Fend
+    #       plugin :contexts
+    #
+    #       validate do |i|
+    #         i.params(:account_type) do |acc_type|
+    #           context(:admin) do
+    #             acc_type.validate_equality("admin")
+    #           end
+    #
+    #           context(:editor) do
+    #             acc_type.validate_equality("editor")
+    #           end
+    #
+    #           # you can check context against multiple values
+    #           context(:visitor, :demo) do
+    #             acc_type.validate_equality(nil)
+    #           end
+    #         end
+    #       end
+    #     end
+    #
+    # You can pass the context on initialization
+    #
+    #     user_validation = UserValidation.new(context: :editor)
+    #     user_validation.call(account_type: "invalid").messages
+    #     #=> { account_type: ["must be equal to 'editor'"] }
+    #
+    # `#context` can be called anywhere in the validation block. You can also
+    # specify contextual params
+    #
+    #     validate do |i|
+    #       context(:admin) do
+    #         i.params(:admin_specific_param) do |asp|
+    #           # ...
+    #         end
+    #       end
+    #
+    #       context(:editor) do
+    #         i.params(:editor_specific_param) do |esp|
+    #           # ...
+    #         end
+    #       end
+    #     end
+    #
+    # ## Default context
+    #
+    # If no context is provided, context will be set to `:default`
+    #
+    #     context(:default) do
+    #       # default validation logic
+    #     end
+    #
+    # ## Overriding constructor
+    #
+    # Since context value is set in the constructor, you should always call
+    # `super` when/if overriding it.
+    module Contexts
+      module InstanceMethods
+        def initialize(*args)
+          opts = if (_opts = args.last) && _opts.is_a?(Hash)
+                   _opts
+                 else
+                   {}
+                 end
+
+          @_context = opts.fetch(:context, :default)
+        end
+
+        def context(*values, &block)
+          values = Array(values)
+
+          yield if values.include?(@_context)
+        end
+      end
+    end
+
+    register_plugin(:contexts, Contexts)
+  end
+end

data/lib/fend/plugins/dependencies.rb

@@ -13,7 +13,7 @@ class Fend
     #
     # 1. **Inheritable dependencies** - available in current validation class
     #                                   and in subclasses
-    # 2. **Local dependencies** - available only in current validation class
+    # 2. *[DEPRECATED] **Local dependencies** - available only in current validation class
     #
     # ### Inheritable dependencies
     #
@@ -30,7 +30,7 @@ class Fend
     #
     # Now, all `Fend` subclasses will be able to resolve `address_checker`
     #
-    # ### Local dependencies
+    # ### Local dependencies *[DEPRECATED]
     #
     # Local dependencies can be registered in `deps` registry, on instance level.
     # Recommended place to do this is the initializer.
@@ -59,13 +59,17 @@ class Fend
     #     class UserValidation < Fend
     #       plugin :dependencies, user_model: User
     #
-    #       validate(inject: [:user_model, :address_checker]) do |i, user_model, address_checker|
+    #       validate(inject: [:user_model]) do |i, user_model|
     #         user_model #=> User
     #         address_checker #=> #<AddressChecker ...>
     #       end
     #
     #       def initialize(address_checker)
-    #         deps[:address_checker] = address_checker
+    #         @address_checker = address_checker
+    #       end
+    #
+    #       def address_checker
+    #         @address_checker
     #       end
     #     end
     #
@@ -87,7 +91,7 @@ class Fend
     # Here's an example of email uniqueness validation:
     #
     #     validate(inject: [:user_model]) do |i, user_model|
-    #       i.param(:email) do |email|
+    #       i.params(:email) do |email|
     #         email.add_error("must be unique") if user_model.exists?(email: email.value)
     #       end
     #     end
@@ -112,6 +116,8 @@ class Fend
 
       module InstanceMethods
         def deps
+          Fend.deprecation("Local dependencies are deprecated and will not be supported in Fend 0.3.0. Instead, you can set attributes or define custom methods which will be available in validation block.")
+
           @_deps ||= self.class.opts[:dependencies].dup
         end
 

data/lib/fend/plugins/external_validation.rb

@@ -30,7 +30,6 @@ class Fend
     #
     #     class AddressValidation < Fend
     #       plugin :validation_options
-    #       plugin :collective_params
     #
     #       validate do |i|
     #         i.params(:city, :street) do |city, street|
@@ -42,7 +41,6 @@ class Fend
     #
     #     class UserValidation < Fend
     #       plugin :external_validation
-    #       plugin :collective_params
     #
     #       validate do |i|
     #         i.params(:email, :address) do |email, address|

data/lib/fend/plugins/object_validation.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+class Fend
+  module Plugins
+    # `object_validation` plugin adds support for validating object attributes
+    # and methods.
+    #
+    #     class UserModelValidation < Fend
+    #       plugin :object_validation
+    #       plugin :validation_options
+    #
+    #       validate do |user|
+    #         user.attrs(:username, :email) do |username, email|
+    #           username.validate(presence: true, max_length: 20, type: String)
+    #           email.validate(presence: true, format: EMAIL_REGEX, type: String)
+    #         end
+    #       end
+    #     end
+    #
+    #     user = User.new(username: "", email: "invalid@email")
+    #     validation = UserModelValidation.call(user)
+    #
+    #     validation.success? #=> false
+    #     validation.messages #=> { username: ["must be present"], email: ["is in invalid format"] }
+    #
+    # As the example shows, the only change is that instread of the `#params` you
+    # should use `#attrs` method.
+    #
+    # ## Handling hash values
+    #
+    # If attribute value should be a hash, you can still use the `#params`
+    # method:
+    #
+    #     # user.address #=> { city: "My city", street: "My street" }
+    #     user.attrs(:address) do |address|
+    #       address.params(:city, :street) do |city, street|
+    #         # ...
+    #       end
+    #     end
+    module ObjectValidation
+      module ParamMethods
+        def attrs(*names, &block)
+          return if flat? && invalid?
+
+          attrs = names.each_with_object({}) do |name, result|
+            attr = _build_param(name, @value.public_send(name))
+            result[name] = attr
+          end
+
+          yield(*attrs.values)
+
+          attrs.each { |name, attr| _nest_errors(name, attr.errors) if attr.invalid? }
+        end
+      end
+    end
+
+    register_plugin(:object_validation, ObjectValidation)
+  end
+end

data/lib/fend/plugins/validation_helpers.rb

@@ -8,7 +8,7 @@ class Fend
     #     plugin :validation_helpers
     #
     #     validate do |i|
-    #       i.param(:username) do |username|
+    #       i.params(:username) do |username|
     #         username.validate_presence
     #         username.validate_max_length(20)
     #         username.validate_type(String)

data/lib/fend/plugins/validation_options.rb

@@ -9,7 +9,7 @@ class Fend
     #     plugin :validation_options
     #
     #     validate do |i|
-    #       i.param(:email) do |email|
+    #       i.params(:email) do |email|
     #         email.validate(presence: true, type: String, format: EMAIL_REGEX)
     #       end
     #     end
@@ -34,6 +34,20 @@ class Fend
     #
     #     email.validate type: { value: String }, format: { value: EMAIL_REGEX }
     #
+    # ## Allowing nil and blank values
+    #
+    # You can skip validation if param value is `nil` or blank by passing
+    # `:allow_nil` or `:allow_blank` options:
+    #
+    #     # will skip type validation if name.value.nil?
+    #     name.validate(type: String, allow_nil: true)
+    #
+    #     # will skip type validation if email.blank?
+    #     email.validate(type: String, allow_blank: true)
+    #
+    # To see what values are considered as blank,
+    # check ValueHelpers::ParamMethods#blank?.
+    #
     # `validation_options` supports ExternalValidation plugin:
     #
     #     plugin :external_validation
@@ -41,6 +55,7 @@ class Fend
     #     # ...
     #
     #     email.validate(with: CustomEmailValidator)
+
     module ValidationOptions
       NO_ARG_METHODS = [:absence, :presence, :acceptance].freeze
       ARRAY_ARG_METHODS = [:exclusion, :inclusion, :length_range].freeze
@@ -75,6 +90,11 @@ class Fend
         def validate(opts = {})
           return if opts.empty?
 
+          allow_nil   = opts.delete(:allow_nil)
+          allow_blank = opts.delete(:allow_blank)
+
+          return if (allow_nil == true && value.nil?) || (allow_blank == true && blank?)
+
           opts.each do |validator_name, args|
             method_name = "validate_#{validator_name}"
 
@@ -89,9 +109,6 @@ class Fend
                 validation_method_args = [args]
               end
             elsif args.is_a?(Hash)
-              next if args[:allow_nil] == true && value.nil?
-              next if args[:allow_blank] == true && blank?
-
               mandatory_arg_key = MANDATORY_ARG_KEYS[validator_name]
 
               unless args.key?(mandatory_arg_key) || args.key?(DEFAULT_ARG_KEY)

data/lib/fend/version.rb

@@ -5,7 +5,7 @@ class Fend
 
   module VERSION
     MAJOR = 0
-    MINOR = 1
+    MINOR = 2
     PATCH = 0
 
     STRING = [MAJOR, MINOR, PATCH].compact.join(".")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fend
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Aleksandar Radunovic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-18 00:00:00.000000000 Z
+date: 2018-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -51,10 +51,12 @@ files:
 - lib/fend.rb
 - lib/fend/plugins/coercions.rb
 - lib/fend/plugins/collective_params.rb
+- lib/fend/plugins/contexts.rb
 - lib/fend/plugins/data_processing.rb
 - lib/fend/plugins/dependencies.rb
 - lib/fend/plugins/external_validation.rb
 - lib/fend/plugins/full_messages.rb
+- lib/fend/plugins/object_validation.rb
 - lib/fend/plugins/validation_helpers.rb
 - lib/fend/plugins/validation_options.rb
 - lib/fend/plugins/value_helpers.rb