rulix 0.7.0 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3844bac00c8405d5f9b563f4ad3fffc7745c8295
-  data.tar.gz: 786e4e7088079f2124e2ec8cabcdd022119d9e7f
+  metadata.gz: d239e13723c2772e811664e150bd906d55809794
+  data.tar.gz: 25d0a4bd9361533cf142c6ba0ffc8689f38f94e9
 SHA512:
-  metadata.gz: 26a4ac9b1353fb14d1e0177af5e7089bc729b1bd3b1f5d44f390afbb1854041bd92d8af3f4a0b9bcfffba4aa89e0b7d3efef6cae2506359ecfaebd3f8b0761d2
-  data.tar.gz: 1c3eb703a716b2664f2799e32a4f82ef3eaf4ff1cdee24615f22f5ab953f23c791987eddb5b12c56cc715855e79812c572835be545608e683379db200a5eb6e7
+  metadata.gz: 8d37da7824088a88ca88b748ef38972e3514db928bf59bac6bf211984c2611bc7abb7f48695dfa40ae5c0f9ee1fcfd06295db448801b3f631368b21987b597a6
+  data.tar.gz: 5434eb4aeef2241513ee23d580cc3202d843a1e18fef7e248038f4316192bfd5c525bfb54f27f96175f4af28ab729a7eb49a7912493ebaf5715cb1d9d76c374c

data/README.md

@@ -184,7 +184,7 @@ See the wiki for a [list of included mutator functions](https://github.com/blars
 
 ## Validation
 
-Use `Rulix::Validator` to validate a dataset. You can test if a dataset is valid with `Rulix::Validator.valid?(dataset, ruleset)`. If your dataset fails validation, you can extract errors with `Rulix::Validator.errors(dataset, ruleset)`
+Use `Rulix::Validator` to validate a dataset. `Rulix::Validator.run` will return a `Rulix::Validation` object, which is just hash with a few extra helpful methods (like `valid?` and `error_messages`).
 
 ```ruby
 dataset = {
@@ -199,10 +199,14 @@ ruleset = {
   }
 }
 
-Rulix::Validator.valid? dataset, ruleset
+result = Rulix::Validator.run dataset, ruleset
+
+result.valid?
 #=> false
-Rulix::Validator.errors dataset, ruleset
+result
 #=> { phone: { number: ['does not match format'] } }
+result.error_messages
+#=> ['Number does not match format']
 ```
 
 See the wiki for a [list of included validation functions](https://github.com/blarshk/rulix/wiki/List-of-Included-Validation-Functions). If you have a validation function that you like that you think should be included in Rulix's base set, submit a pull request!
@@ -272,6 +276,25 @@ Rulix::Validator.run data, rules
 #=> { my_field: ['is not a number', 'ends in oo'] }
 ```
 
+The `error_message` compontent of your validations can be anything you want; the results will be concatenated into a single array.
+
+```ruby
+Rulix::Validator.register :has_a_digit do |val|
+  /\d/.match(val) ? true : [false, { code: '001', message: 'The value supplied does not contain a digit!' }]
+end
+
+data = {
+  my_field: 'bar'
+}
+
+rules = {
+  my_field: [:has_a_digit]
+}
+
+Rulix::Validator.run data, rules
+#=> { my_field: [{ code: '001', message: 'The value supplied does not contain a digit!' }] }
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/blarshk/rulix/fork )

data/lib/rulix.rb

@@ -1,5 +1,8 @@
+require 'delegate'
+
 require_relative './rulix/version'
 require_relative './rulix/errors'
+require_relative './rulix/validation'
 require_relative './rulix/registry'
 require_relative './rulix/base'
 require_relative './rulix/mutator'

data/lib/rulix/active_record_validator.rb

@@ -9,12 +9,12 @@ module Rulix
     end
 
     def validate record
-      if Rulix::Validator.valid? record, ruleset
+      result = Rulix::Validator.run record, ruleset
+
+      if result.valid?
         true
       else
-        errors = Rulix::Validator.errors record, ruleset
-
-        reduce_errors_into record, errors
+        reduce_errors_into record, result
 
         false
       end

data/lib/rulix/base.rb

@@ -2,20 +2,18 @@ module Rulix
   class Base
     include Rulix::Registry
 
+    # This will ALWAYS return a hash with symbolized keys
+    # This was a design decision to reduce the potential for dependencies
+    # by introducing HashWithIndifferentAccess or edge cases in rule
+    # registration and such
     def self.run dataset, ruleset
       return to_enum(__callee__) unless block_given?
 
-      coercion = -> (result) { result }
-
-      if dataset.is_a?(Hash)
-        coercion = -> (result) { result.deep_stringify_keys } if String === dataset.keys.first
-
-        dataset = dataset.deep_symbolize_keys
-      end
+      dataset = dataset.deep_symbolize_keys if dataset.is_a?(Hash)
 
       dataset = data_for_ruleset dataset, ruleset
 
-      result = dataset.deep_merge ruleset do |key, data_obj, operation_obj|
+      dataset.deep_merge ruleset do |key, data_obj, operation_obj|
         if (data_obj.is_a?(Array) && data_obj.all? { |o| o.respond_to?(:deep_merge) })
           data_obj.map do |data|
             data.deep_merge operation_obj.first do |k, d, o|
@@ -30,8 +28,6 @@ module Rulix
           yield *handle_merge(data_obj, operation_obj)
         end
       end
-
-      coercion.call(result)
     end
 
     def self.handle_merge data_obj, operation_obj

data/lib/rulix/validation.rb

@@ -0,0 +1,43 @@
+module Rulix
+  class Validation < SimpleDelegator
+    def valid?
+      deep_compact.empty?
+    end
+
+    def error_messages
+      extract_error_messages self
+    end
+
+    def extract_error_messages hash
+      hash.map do |key, val|
+        if data_remaining?(val)
+          extract_error_messages val
+        else
+          format_val(key, val)
+        end
+      end.flatten
+    end
+
+    def data_remaining? val
+      # If val is a hash and any of its children are hashes,
+      # or all of them are arrays
+      # we assume that we haven't yet reached the deepest point
+      # of the result set
+      val.is_a?(Hash) &&
+        (
+          val.values.any? { |v| v.is_a?(Hash)} ||
+          val.values.all? { |v| v.is_a?(Array)}
+        )
+    end
+
+    def format_val key, val
+      if val.is_a?(Array) && val.all? { |v| v.is_a?(String) }
+        val.map do |v|
+          "#{key.to_s.capitalize} #{v}"
+        end
+      else
+        val
+      end
+    end
+  end
+end

data/lib/rulix/validator.rb

@@ -2,34 +2,32 @@ module Rulix
   class Validator < Rulix::Base
     include Rulix::Registry
 
-    def self.run dataset, ruleset
-      super dataset, ruleset do |value, operations|
-        begin
-          success, errors = operations.reduce([true, []]) do |result, op|
-            success, errors = result
-
-            new_success, *new_errors = op.call(value)
-
-            [success && new_success, errors.concat(new_errors)]
+    class << self
+      def run dataset, ruleset
+        result = super dataset, ruleset do |value, operations|
+          begin
+            success, errors = operations.reduce([true, []]) do |result, op|
+              success, errors = result
+
+              new_success, *new_errors = op.call(value)
+
+              [success && new_success, errors.concat(new_errors)]
+            end
+          rescue AllowableNil
+            errors = []
           end
-        rescue AllowableNil
-          errors = []
+
+          errors
         end
 
-        errors
+        Rulix::Validation.new(result.deep_compact)
       end
-    end
 
-    def self.valid? dataset, ruleset
-      run = run dataset, ruleset
+      def valid? dataset, ruleset
+        run = run dataset, ruleset
 
-      run.deep_compact.empty?
-    end
-
-    def self.errors dataset, ruleset
-      run = run dataset, ruleset
-
-      run.deep_compact
+        run.empty?
+      end
     end
   end
 end

data/lib/rulix/version.rb

@@ -1,3 +1,3 @@
 module Rulix
-  VERSION = "0.7.0"
+  VERSION = "0.8.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rulix
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.2
 platform: ruby
 authors:
 - Mitch Monsen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-30 00:00:00.000000000 Z
+date: 2016-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -79,6 +79,7 @@ files:
 - lib/rulix/mutators/strip.rb
 - lib/rulix/mutators/truncate.rb
 - lib/rulix/registry.rb
+- lib/rulix/validation.rb
 - lib/rulix/validator.rb
 - lib/rulix/validators/allow_nil_validator.rb
 - lib/rulix/validators/alpha_numeric_validator.rb