rulix 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d3a105f632d0c729e93bc8ed9cb1389f8a3386f5
-  data.tar.gz: 1b83a610f1aed3fe46d65ff75a459e155fb3827b
+  metadata.gz: 77d2eb6688f2010c1c5d0457fda19e1ef4becf75
+  data.tar.gz: 02d79ce8f98981bbac840758380bc89e8db7f3d8
 SHA512:
-  metadata.gz: b9e44f9296c40ccd8cfbcc5e822f30ba90b378a8e603791f3e786caedc3e0e2299c45b172913374fcffde163f7723cbc4b7694194279304d04d9d9a583c3e5b9
-  data.tar.gz: 3b7f4e2de34f8a6a8008f12cd9ede722a79f4f08af9b516237ca373eab509cbd25007ff121f6f59191bf95acfb7df4f0a8b758ca669ce6b944befdd0485f9ffb
+  metadata.gz: de1c6349f17be45abe08bd63c53484d5594c6a6ec226b62a1c67a4e8f199c363404dd8339dcc5ea4fc2776b30aae7e9b198765a398dd38db18a3fb725b31c77c
+  data.tar.gz: 160e46d5561b930ce12d451a1d4789ec735c3b37c896f57be41214fde7a79bcaac3e629c24b1403b4e840efa044ad979b9be21a71c91b095e72dc99244eb4aa4

data/README.md

@@ -88,7 +88,11 @@ Some rules may need additional definition or configuration based on context. If
 
 ```ruby
 # Configurable proc
--> (options, value) { value[0..options[:trim_to] - 1] }
+trimmer = -> (options, value) { value[0..options[:trim_to] - 1] }
+
+Rulix::Mutator.register :trim, trimmer
+
+{ first_name: { trim: { trim_to: 5 } } }
 
 # Configured procable object
 class CharacterRemover
@@ -176,6 +180,8 @@ Rulix::Mutator.run dataset, ruleset
 #=> { first_name: 'Bob', last_name: 'Johnson' }
 ```
 
+See the wiki for a [list of included mutator functions](https://github.com/blarshk/rulix/wiki/List-of-Included-Mutator-Functions).
+
 ## 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)`
@@ -199,6 +205,31 @@ Rulix::Validator.errors dataset, ruleset
 #=> { phone: { 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!
+
+### Validating with ActiveRecord
+
+Rulix comes with a plugin class that you can use to validate ActiveRecord models.
+
+```ruby
+class User < ActiveRecord::Base
+  validates :email, uniqueness: true
+
+  validates_with Rulix::ActiveRecordValidator, ruleset: {
+    email: { format: /.*@.*/, message: 'is not an email address' }
+  }
+end
+
+user = User.new email: 'foobar'
+
+user.valid?
+#=> false
+user.errors.full_messages
+#=> ['Email is not an email address']
+```
+
+The adapter can be used alongside ActiveRecord's own validators, so you can keep using ActiveRecord to validate the things it's good at, and delegate the rest to Rulix!
+
 ## Custom Validators and Mutators
 
 You can write your own mutators and validators and make them available to Rulix for building rulesets as long as they implement their respective interfaces.
@@ -229,20 +260,16 @@ Rulix::Validator.register :doesnt_end_in_oo do |val|
   val.end_with?('oo') ? [false, 'ends in oo'] : true
 end
 
-Rulix::Validator.register :digits_only do |val|
-  /^[0-9]+$/ === val ? true : [false, 'contains non-digits']
-end
-
 data = {
   my_field: 'foo'
 }
 
 rules = {
-  my_field: [:digits_only, :doesnt_end_in_oo]
+  my_field: [:number, :doesnt_end_in_oo]
 }
 
 Rulix::Validator.run data, rules
-#=> { my_field: ['contains non-digits', 'ends in oo'] }
+#=> { my_field: ['is not a number', 'ends in oo'] }
 ```
 
 ## Contributing

data/lib/rulix/base.rb

@@ -0,0 +1,56 @@
+module Rulix
+  class Base
+    include Rulix::Registry
+
+    def self.run dataset, ruleset
+      return to_enum(__callee__) unless block_given?
+
+      dataset = data_for_ruleset dataset, ruleset
+
+      dataset.deep_merge ruleset do |key, val1, val2|
+        val2 = [val2] unless val2.is_a? Array
+
+        ops = get_operations val2
+
+        yield val1, ops
+      end
+    end
+
+    def self.data_for_ruleset dataset, ruleset
+      seed = {}
+
+      reduce_into_hash seed, dataset, ruleset
+    end
+
+    def self.reduce_into_hash hash, dataset, ruleset
+      ruleset.reduce(hash) do |data_hash, values|
+        key, rule_val = values
+
+        nested_value = value_from_dataset dataset, key
+
+        if rule_val.is_a?(Hash) && (nested_value.is_a?(Hash) || rule_val.keys.all? { |k| nested_value.respond_to?(k) })
+          seed = {}
+
+          data_hash[key] = reduce_into_hash seed, nested_value, rule_val
+        else
+          data_hash[key] = nested_value
+        end
+
+        data_hash
+      end
+    end
+
+    def self.value_from_dataset dataset, key
+      # Not a fan of type-checking here, would rather do a :respond_to? :[]
+      # However, that scenario breaks when validating sensitive data
+      # on an ActiveRecord model (like password) or any other attribute
+      # that is manipulated in the biz logic layer before being set on
+      # the db (e.g.: Model(:ssn) -> Database(:encrypted_ssn))
+      if dataset.is_a? Hash
+        dataset[key]
+      else
+        dataset.public_send(key)
+      end
+    end
+  end
+end

data/lib/rulix/mutator.rb

@@ -1,16 +1,46 @@
-require_relative './registry'
-
 module Rulix
-  class Mutator
+  class Mutator < Rulix::Base
     include Rulix::Registry
 
     def self.run dataset, ruleset
-      dataset.deep_merge ruleset do |key, val1, val2|
-        val2 = [val2] unless val2.is_a? Array
+      super dataset, ruleset do |value, operations|
+        operations.reduce(value) { |val, op| op.call(val) }
+      end
+    end
+
+    def self.reduce_into_hash hash, dataset, ruleset
+      # Migrate over any keys the ruleset has that the dataset doesn't
+      # so we can set defaults and handle cases where no data exists
+      if dataset.respond_to? :keys
+        key_diff = ruleset.keys - dataset.keys
+
+        key_diff.each do |key|
+          hash[key] = nil
+        end
+      end
 
-        ops = get_operations val2
+      new_ruleset = ruleset.reduce(hash) do |data_hash, values|
+        key, rule_val = values
+
+        nested_value = value_from_dataset dataset, key
+
+        if rule_val.is_a?(Hash) && (nested_value.is_a?(Hash) || rule_val.keys.all? { |k| nested_value.respond_to?(k) })
+          seed = {}
+
+          data_hash[key] = reduce_into_hash seed, nested_value, rule_val
+        else
+          data_hash[key] = nested_value
+        end
+
+        data_hash
+      end
 
-        ops.reduce(val1) { |val, op| op.call(val) }
+      # For mutation, we need to ensure that the resulting dataset
+      # contains all original, unmodified values as well as mutated values
+      if dataset.is_a? Hash
+        new_ruleset.deep_merge dataset
+      else
+        new_ruleset
       end
     end
   end

data/lib/rulix/mutators/default.rb

@@ -0,0 +1,25 @@
+module Rulix
+  module Mutators
+    class Default
+      attr_accessor :default_val
+
+      def initialize default_val
+        self.default_val = default_val
+      end
+
+      def to_proc
+        method(:call)
+      end
+
+      def call string
+        if string
+          string
+        else
+          default_val
+        end
+      end
+    end
+  end
+end
+
+Rulix::Mutator.register :default, Rulix::Mutators::Default

data/lib/rulix/validator.rb

@@ -1,19 +1,13 @@
 module Rulix
-  class Validator
+  class Validator < Rulix::Base
     include Rulix::Registry
 
     def self.run dataset, ruleset
-      dataset = data_for_ruleset dataset, ruleset
-
-      dataset.deep_merge ruleset do |key, val1, val2|
-        val2 = [val2] unless val2.is_a? Array
-
-        ops = get_operations val2
-
-        success, errors = ops.reduce([true, []]) do |result, op|
+      super dataset, ruleset do |value, operations|
+        success, errors = operations.reduce([true, []]) do |result, op|
           success, errors = result
 
-          new_success, *new_errors = op.call(val1)
+          new_success, *new_errors = op.call(value)
 
           [success && new_success, errors.concat(new_errors)]
         end
@@ -33,44 +27,5 @@ module Rulix
 
       run.deep_compact
     end
-
-    private
-
-    def self.data_for_ruleset dataset, ruleset
-      seed = {}
-
-      reduce_into_hash seed, dataset, ruleset
-    end
-
-    def self.reduce_into_hash hash, dataset, ruleset
-      ruleset.reduce(hash) do |data_hash, values|
-        key, rule_val = values
-
-        nested_value = value_from_dataset dataset, key
-
-        if rule_val.is_a?(Hash) && (nested_value.is_a?(Hash) || rule_val.keys.all? { |k| nested_value.respond_to?(k) })
-          seed = {}
-
-          data_hash[key] = reduce_into_hash seed, nested_value, rule_val
-        else
-          data_hash[key] = nested_value
-        end
-
-        data_hash
-      end
-    end
-
-    def self.value_from_dataset dataset, key
-      # Not a fan of type-checking here, would rather do a :respond_to? :[]
-      # However, that scenario breaks when validating sensitive data
-      # on an ActiveRecord model (like password) or any other attribute
-      # that is manipulated in the biz logic layer before being set on
-      # the db (e.g.: Model(:ssn) -> Database(:encrypted_ssn))
-      if dataset.is_a? Hash
-        dataset[key]
-      else
-        dataset.public_send(key)
-      end
-    end
   end
 end

data/lib/rulix/validators/date_validator.rb

@@ -0,0 +1,31 @@
+require 'date'
+
+module Rulix
+  module Validators
+    class DateValidator
+      def self.to_proc
+        new.method(:call)
+      end
+
+      def call date
+        if date
+          begin
+            Date.parse date
+
+            true
+          rescue ArgumentError
+            [false, "is not a date"]
+          end
+        else
+          [false, 'is not a date']
+        end
+      end
+
+      def error_message value = nil
+        "is not a date"
+      end
+    end
+  end
+end
+
+Rulix::Validator.register :date, Rulix::Validators::DateValidator

data/lib/rulix/validators/length_validator.rb

@@ -6,7 +6,7 @@ module Rulix
       def initialize options = nil
         options ||= {}
         min = options[:min] || 0
-        max = options[:max] || min + 1
+        max = options[:max]
 
         self.exactly = options[:exactly]
         self.min = min
@@ -17,7 +17,13 @@ module Rulix
         return [false, "can't be nil"] unless string
 
         if exactly.nil?
-          (min..max).cover?(string.length) || [false, error_message(string)]
+          if min && max
+            (min..max).cover?(string.length) || [false, error_message(string)]
+          elsif min && !max
+            string.length >= min || [false, error_message(string)]
+          elsif max && !min
+            string.length <= max || [false, error_message(string)]
+          end
         else
           exactly == string.length || [false, exact_error_message]
         end

data/lib/rulix/validators/number_validator.rb

@@ -9,10 +9,10 @@ module Rulix
         return [false, error_message] unless value
 
         case value
-        when Integer, Fixnum
+        when Integer, Float, Bignum, Fixnum
           true
         when String
-          /^[\d]*$/ === value || [false, error_message(value)]
+          /^\d+$/ === value || [false, error_message(value)]
         else
           [false, error_message(value)]
         end

data/lib/rulix/validators/required_validator.rb

@@ -2,7 +2,9 @@ module Rulix
   module Validators
     class RequiredValidator
       def call value
-        (value && !value.nil?) || [false, 'is required']
+        return [false, 'is required'] unless value
+
+        true
       end
 
       def to_proc

data/lib/rulix/version.rb

@@ -1,3 +1,3 @@
 module Rulix
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/rulix.rb

@@ -1,5 +1,6 @@
 require_relative './rulix/version'
 require_relative './rulix/registry'
+require_relative './rulix/base'
 require_relative './rulix/mutator'
 require_relative './rulix/validator'
 require_relative './rulix/active_record_validator'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rulix
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Mitch Monsen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-24 00:00:00.000000000 Z
+date: 2016-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -69,8 +69,10 @@ files:
 - bin/setup
 - lib/rulix.rb
 - lib/rulix/active_record_validator.rb
+- lib/rulix/base.rb
 - lib/rulix/core_ext/hash.rb
 - lib/rulix/mutator.rb
+- lib/rulix/mutators/default.rb
 - lib/rulix/mutators/replace.rb
 - lib/rulix/mutators/squeeze_spaces.rb
 - lib/rulix/mutators/strip.rb
@@ -79,6 +81,7 @@ files:
 - lib/rulix/validator.rb
 - lib/rulix/validators/alpha_numeric_validator.rb
 - lib/rulix/validators/alpha_validator.rb
+- lib/rulix/validators/date_validator.rb
 - lib/rulix/validators/email_validator.rb
 - lib/rulix/validators/format_validator.rb
 - lib/rulix/validators/length_validator.rb