rulix 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e084df3e38d1b62de41b00ff6c877f355df97bc
-  data.tar.gz: 259180456844ce65f3cb529bf9acf5d412739718
+  metadata.gz: 3844bac00c8405d5f9b563f4ad3fffc7745c8295
+  data.tar.gz: 786e4e7088079f2124e2ec8cabcdd022119d9e7f
 SHA512:
-  metadata.gz: ec4bab9011252a286da382652e8d123be64141c25dca8c68e2b20b98f82d5fbc0e780a59d9ace47b940e49ed7185d823de9f3e332f81a02eb01490a02bb36bd0
-  data.tar.gz: 7f47d35bb94f3b1e9ae4658ade9b55849a5a6a4b03e412d4488cfb2888c9c08b7a3a08903a3b2ae39930ff5515f253cc135e0afb7bb7f98a4fc61756005ff870
+  metadata.gz: 26a4ac9b1353fb14d1e0177af5e7089bc729b1bd3b1f5d44f390afbb1854041bd92d8af3f4a0b9bcfffba4aa89e0b7d3efef6cae2506359ecfaebd3f8b0761d2
+  data.tar.gz: 1c3eb703a716b2664f2799e32a4f82ef3eaf4ff1cdee24615f22f5ab953f23c791987eddb5b12c56cc715855e79812c572835be545608e683379db200a5eb6e7

data/lib/rulix/base.rb

@@ -5,9 +5,17 @@ module Rulix
     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 = data_for_ruleset dataset, ruleset
 
-      dataset.deep_merge ruleset do |key, data_obj, operation_obj|
+      result = 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|
@@ -22,6 +30,8 @@ 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/core_ext/hash.rb

@@ -1,64 +1,227 @@
 # Stole this from Rails; rather copy the source than introduce
 # ActiveSupport as a dependency
-class Hash
-  # Returns a new hash with +self+ and +other_hash+ merged recursively.
-  #
-  #   h1 = { a: true, b: { c: [1, 2, 3] } }
-  #   h2 = { a: false, b: { x: [3, 4, 5] } }
-  #
-  #   h1.deep_merge(h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
-  #
-  # Like with Hash#merge in the standard library, a block can be provided
-  # to merge values:
-  #
-  #   h1 = { a: 100, b: 200, c: { c1: 100 } }
-  #   h2 = { b: 250, c: { c1: 200 } }
-  #   h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
-  #   # => { a: 100, b: 450, c: { c1: 300 } }
-  def deep_merge(other_hash, &block)
-    dup.deep_merge!(other_hash, &block)
-  end
 
-  # Same as +deep_merge+, but modifies +self+.
-  def deep_merge!(other_hash, &block)
-    other_hash.each_pair do |current_key, other_value|
-      this_value = self[current_key]
+unless Hash.instance_methods.include? :deep_merge
+  class Hash
+    # Returns a new hash with +self+ and +other_hash+ merged recursively.
+    #
+    #   h1 = { a: true, b: { c: [1, 2, 3] } }
+    #   h2 = { a: false, b: { x: [3, 4, 5] } }
+    #
+    #   h1.deep_merge(h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+    #
+    # Like with Hash#merge in the standard library, a block can be provided
+    # to merge values:
+    #
+    #   h1 = { a: 100, b: 200, c: { c1: 100 } }
+    #   h2 = { b: 250, c: { c1: 200 } }
+    #   h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
+    #   # => { a: 100, b: 450, c: { c1: 300 } }
+    def deep_merge(other_hash, &block)
+      dup.deep_merge!(other_hash, &block)
+    end
 
-      self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
-        this_value.deep_merge(other_value, &block)
-      else
-        if block_given? && key?(current_key)
-          block.call(current_key, this_value, other_value)
+    # Same as +deep_merge+, but modifies +self+.
+    def deep_merge!(other_hash, &block)
+      other_hash.each_pair do |current_key, other_value|
+        this_value = self[current_key]
+
+        self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+          this_value.deep_merge(other_value, &block)
         else
-          other_value
+          if block_given? && key?(current_key)
+            block.call(current_key, this_value, other_value)
+          else
+            other_value
+          end
         end
       end
-    end
 
-    self
+      self
+    end
   end
+end
 
-  # Returns a hash, removing all values that cause the block to evaluate to true
-  # Iterates recursively over nested hashes
-  def deep_reject &block
-    dup.deep_reject! &block
-  end
+unless Hash.instance_methods.include? :deep_symbolize_keys
+  # If hash doesn't respond to :deep_symbolize_keys, we can assume
+  # it needs all the key transformation methods
 
-  # Same as +deep_reject+, but modifies +self+.
-  def deep_reject! &block
-    each_pair do |current_key, value|
-      this_value = self[current_key]
+  class Hash
+    # Returns a new hash with all keys converted using the +block+ operation.
+    #
+    #  hash = { name: 'Rob', age: '28' }
+    #
+    #  hash.transform_keys { |key| key.to_s.upcase } # => {"NAME"=>"Rob", "AGE"=>"28"}
+    #
+    # If you do not provide a +block+, it will return an Enumerator
+    # for chaining with other methods:
+    #
+    #  hash.transform_keys.with_index { |k, i| [k, i].join } # => {"name0"=>"Rob", "age1"=>"28"}
+    def transform_keys
+      return enum_for(:transform_keys) { size } unless block_given?
+      result = {}
+      each_key do |key|
+        result[yield(key)] = self[key]
+      end
+      result
+    end
 
-      if this_value.is_a?(Hash)
-        self[current_key] = this_value.deep_reject &block
-      else
-        if block_given? && key?(current_key)
-          self.delete current_key if block.call current_key, this_value
+    # Destructively converts all keys using the +block+ operations.
+    # Same as +transform_keys+ but modifies +self+.
+    def transform_keys!
+      return enum_for(:transform_keys!) { size } unless block_given?
+      keys.each do |key|
+        self[yield(key)] = delete(key)
+      end
+      self
+    end
+
+    # Returns a new hash with all keys converted to strings.
+    #
+    #   hash = { name: 'Rob', age: '28' }
+    #
+    #   hash.stringify_keys
+    #   # => {"name"=>"Rob", "age"=>"28"}
+    def stringify_keys
+      transform_keys(&:to_s)
+    end
+
+    # Destructively converts all keys to strings. Same as
+    # +stringify_keys+, but modifies +self+.
+    def stringify_keys!
+      transform_keys!(&:to_s)
+    end
+
+    # Returns a new hash with all keys converted to symbols, as long as
+    # they respond to +to_sym+.
+    #
+    #   hash = { 'name' => 'Rob', 'age' => '28' }
+    #
+    #   hash.symbolize_keys
+    #   # => {:name=>"Rob", :age=>"28"}
+    def symbolize_keys
+      transform_keys{ |key| key.to_sym rescue key }
+    end
+    alias_method :to_options,  :symbolize_keys
+
+    # Destructively converts all keys to symbols, as long as they respond
+    # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+    def symbolize_keys!
+      transform_keys!{ |key| key.to_sym rescue key }
+    end
+    alias_method :to_options!, :symbolize_keys!
+
+    # Validates all keys in a hash match <tt>*valid_keys</tt>, raising
+    # +ArgumentError+ on a mismatch.
+    #
+    # Note that keys are treated differently than HashWithIndifferentAccess,
+    # meaning that string and symbol keys will not match.
+    #
+    #   { name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age"
+    #   { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'"
+    #   { name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing
+    def assert_valid_keys(*valid_keys)
+      valid_keys.flatten!
+      each_key do |k|
+        unless valid_keys.include?(k)
+          raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
         end
       end
     end
+
+    # Returns a new hash with all keys converted by the block operation.
+    # This includes the keys from the root hash and from all
+    # nested hashes and arrays.
+    #
+    #  hash = { person: { name: 'Rob', age: '28' } }
+    #
+    #  hash.deep_transform_keys{ |key| key.to_s.upcase }
+    #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+    def deep_transform_keys(&block)
+      _deep_transform_keys_in_object(self, &block)
+    end
+
+    # Destructively converts all keys by using the block operation.
+    # This includes the keys from the root hash and from all
+    # nested hashes and arrays.
+    def deep_transform_keys!(&block)
+      _deep_transform_keys_in_object!(self, &block)
+    end
+
+    # Returns a new hash with all keys converted to strings.
+    # This includes the keys from the root hash and from all
+    # nested hashes and arrays.
+    #
+    #   hash = { person: { name: 'Rob', age: '28' } }
+    #
+    #   hash.deep_stringify_keys
+    #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
+    def deep_stringify_keys
+      deep_transform_keys(&:to_s)
+    end
+
+    # Destructively converts all keys to strings.
+    # This includes the keys from the root hash and from all
+    # nested hashes and arrays.
+    def deep_stringify_keys!
+      deep_transform_keys!(&:to_s)
+    end
+
+    # Returns a new hash with all keys converted to symbols, as long as
+    # they respond to +to_sym+. This includes the keys from the root hash
+    # and from all nested hashes and arrays.
+    #
+    #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+    #
+    #   hash.deep_symbolize_keys
+    #   # => {:person=>{:name=>"Rob", :age=>"28"}}
+    def deep_symbolize_keys
+      deep_transform_keys{ |key| key.to_sym rescue key }
+    end
+
+    # Destructively converts all keys to symbols, as long as they respond
+    # to +to_sym+. This includes the keys from the root hash and from all
+    # nested hashes and arrays.
+    def deep_symbolize_keys!
+      deep_transform_keys!{ |key| key.to_sym rescue key }
+    end
+
+    private
+      # support methods for deep transforming nested hashes and arrays
+      def _deep_transform_keys_in_object(object, &block)
+        case object
+        when Hash
+          object.each_with_object({}) do |(key, value), result|
+            result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+          end
+        when Array
+          object.map {|e| _deep_transform_keys_in_object(e, &block) }
+        else
+          object
+        end
+      end
+
+      def _deep_transform_keys_in_object!(object, &block)
+        case object
+        when Hash
+          object.keys.each do |key|
+            value = object.delete(key)
+            object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
+          end
+          object
+        when Array
+          object.map! {|e| _deep_transform_keys_in_object!(e, &block)}
+        else
+          object
+        end
+      end
   end
+end
 
+# Useful hash method necessary for determining if a dataset
+# is valid; we remove all empty elements until just key/vals
+# with non-empty error message arrays are left
+class Hash
   # Returns a hash, removing all elements that
   # respond to and return true from :empty?
   # Iterates recursively over nested hashes

data/lib/rulix/errors.rb

@@ -0,0 +1 @@
+class AllowableNil < StandardError; end

data/lib/rulix/validator.rb

@@ -3,19 +3,21 @@ module Rulix
     include Rulix::Registry
 
     def self.run dataset, ruleset
-      result = super dataset, ruleset do |value, operations|
-        success, errors = operations.reduce([true, []]) do |result, op|
-          success, errors = 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)
+            new_success, *new_errors = op.call(value)
 
-          [success && new_success, errors.concat(new_errors)]
+            [success && new_success, errors.concat(new_errors)]
+          end
+        rescue AllowableNil
+          errors = []
         end
 
         errors
       end
-
-      result
     end
 
     def self.valid? dataset, ruleset

data/lib/rulix/validators/allow_nil_validator.rb

@@ -0,0 +1,21 @@
+require 'date'
+
+module Rulix
+  module Validators
+    class AllowNilValidator
+      def self.to_proc
+        new.method(:call)
+      end
+
+      def call val
+        if val.nil?
+          raise AllowableNil
+        else
+          true
+        end
+      end
+    end
+  end
+end
+
+Rulix::Validator.register :allow_nil, Rulix::Validators::AllowNilValidator

data/lib/rulix/validators/number_validator.rb

@@ -12,13 +12,13 @@ module Rulix
         when Integer, Float, Bignum, Fixnum
           true
         when String
-          /^\d+$/ === value || [false, error_message(value)]
+          /\A[+-]?\d+\.?\d+?\Z/ === value || [false, error_message]
         else
-          [false, error_message(value)]
+          [false, error_message]
         end
       end
 
-      def error_message value = nil
+      def error_message
         "is not a number"
       end
     end

data/lib/rulix/validators/string_validator.rb

@@ -0,0 +1,21 @@
+module Rulix
+  module Validators
+    class StringValidator
+      def self.to_proc
+        new.method(:call)
+      end
+
+      def call value
+        return [false, error_message] unless value
+
+        String === value || [false, error_message]
+      end
+
+      def error_message
+        "is not a string"
+      end
+    end
+  end
+end
+
+Rulix::Validator.register :string, Rulix::Validators::StringValidator

data/lib/rulix/version.rb

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

data/lib/rulix.rb

@@ -1,4 +1,5 @@
 require_relative './rulix/version'
+require_relative './rulix/errors'
 require_relative './rulix/registry'
 require_relative './rulix/base'
 require_relative './rulix/mutator'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rulix
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Mitch Monsen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-29 00:00:00.000000000 Z
+date: 2016-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -71,6 +71,7 @@ files:
 - lib/rulix/active_record_validator.rb
 - lib/rulix/base.rb
 - lib/rulix/core_ext/hash.rb
+- lib/rulix/errors.rb
 - lib/rulix/mutator.rb
 - lib/rulix/mutators/default.rb
 - lib/rulix/mutators/replace.rb
@@ -79,6 +80,7 @@ files:
 - lib/rulix/mutators/truncate.rb
 - lib/rulix/registry.rb
 - lib/rulix/validator.rb
+- lib/rulix/validators/allow_nil_validator.rb
 - lib/rulix/validators/alpha_numeric_validator.rb
 - lib/rulix/validators/alpha_validator.rb
 - lib/rulix/validators/date_validator.rb
@@ -89,6 +91,7 @@ files:
 - lib/rulix/validators/number_validator.rb
 - lib/rulix/validators/one_of_validator.rb
 - lib/rulix/validators/required_validator.rb
+- lib/rulix/validators/string_validator.rb
 - lib/rulix/version.rb
 - rulix.gemspec
 homepage: https://github.com/blarshk/rulix