ratatouille 1.3.4 → 1.3.6

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 1.3.6
+
+### Updates
+
+* New Array Method: **ratify\_each** iterates over each item in an array to perform validation logic.
+* Tweaks to Ratatouille::Ratifier.errors\_array to provide additional functionality required for **ratify\_each**.
+  * Refactored logic in Ratatouille::Ratifier into new method (**namespace\_errors\_array**).
+
 ## 1.3.4
 
 ### Updates

data/lib/ratatouille/array.rb

@@ -2,6 +2,28 @@ module Ratatouille
 
   # Module used to provide Array-specific validation methods
   module ArrayMethods
+    
+    # Iterator method to encapsulate validation
+    #
+    # @note Method will NOT work without a block
+    # @param [Hash] options
+    # @option options [Hash] :each 
+    #   options to pass to ratifier for each item in array
+    # @option options [Integer] :min_length
+    # @option options [Integer] :max_length
+    # @return [void]
+    def ratify_each(options={}, &block)
+      if block_given?
+        item_name = options[:name] || "array_item"
+        @ratifiable_object.each_with_index do |obj, i|
+          options[:name] = "#{item_name}"
+          child_object = Ratatouille::Ratifier.new(obj, options, &block)
+          @errors["/"] << child_object.errors unless child_object.valid?
+        end
+      end
+    end#ratify_each
+
+
     # Define Minimum Length of Array
     # 
     # @param [Integer] min_size

data/lib/ratatouille/ratifier.rb

@@ -92,38 +92,35 @@ module Ratatouille
 
     # @param [Hash] hsh Hash to act upon.
     # @return [Array]
-    def errors_array(hsh = @errors)
-      return [] unless Hash === hsh
+    def errors_array(item = @errors)
       all_errs = []
 
-      hsh.each_pair do |k,v|
-        pair_errs = case v
-        when Hash then errors_array(v)
-        when Array then v
-        else []
-        end
-
-        nsed_errs = pair_errs.collect do |e|
-          split_err = e.split("|")
-
-          ctxt, err = "", e
-          ctxt, err = split_err if split_err.size == 2
-
-          case k
-          when String  
-            ctxt = "#{k}#{ctxt}" unless k == '/'
-          when Symbol 
-            ctxt = ":#{k}#{ctxt}"
+      case item
+      when Array
+        item.each_with_index do |e,i|
+          item_errs = case e
+          when Hash, Array then errors_array(e)
+          when String then e
+          else []
           end
 
-          "/#{ctxt}|#{err}"
+          all_errs << namespace_error_array(item_errs, "[#{i}]")
+          all_errs.flatten!
         end
+      when Hash
+        item.each_pair do |k,v|
+          pair_errs = case v
+          when Hash, Array then errors_array(v)
+          when String then v
+          else []
+          end
 
-        all_errs << nsed_errs
-        all_errs.flatten!
+          all_errs << namespace_error_array(pair_errs, k)
+          all_errs.flatten!
+        end
       end
 
-      return all_errs
+      return Array(all_errs)
     end#errors_array
 
 
@@ -131,6 +128,7 @@ module Ratatouille
     # Will not validate without class.
     #
     # @param [Class] klass
+    # @return [void]
     def is_a?(klass=nil, &block)
       if klass.nil?
         validation_error("must provide a Class for is_a?")
@@ -152,12 +150,14 @@ module Ratatouille
     # validation methods defined in various places.
     #
     # @param [Hash] options
+    # @option options [Class] :is_a (nil)
+    # @option options [Boolean] :required (false)
     # @option options [Boolean] :unwrap_block (false)
     #   Perform block validation only -- skip method validation logic.
     def parse_options(options={})
-      @unwrap_block = options.fetch(:unwrap_block, false)
       @is_a = options.fetch(:is_a, nil)
       @required = options.fetch(:required, false)
+      @unwrap_block = options.fetch(:unwrap_block, false)
     end#parse_options
 
 
@@ -203,6 +203,36 @@ module Ratatouille
       instance_eval(&block) if block_given?
       return
     end#method_missing
+
+
+    # Properly prepend namespace definition to array of errors
+    #
+    # @param [Array] arr
+    # @param [String,Symbol] namespace
+    # @return [Array]
+    def namespace_error_array(arr=[], namespace="")
+      errs_out = arr.collect do |e|
+        split_err = e.split("|")
+
+        ctxt, err = "", e
+        ctxt, err = split_err if split_err.size == 2
+
+        case namespace
+        when String  
+          ctxt = "#{namespace}#{ctxt}" unless namespace =~ /^\/.?/
+        when Symbol 
+          ctxt = ":#{namespace}#{ctxt}"
+        end
+
+        if ctxt =~ /^\/.?/
+          "#{ctxt}|#{err}" 
+        else
+          "/#{ctxt}|#{err}"
+        end
+      end
+
+      return Array(errs_out)
+    end#namespace_error_array
   end#Ratifier
 
 end

data/lib/ratatouille/version.rb

@@ -1,4 +1,4 @@
 module Ratatouille
   # Gem Version
-  VERSION = "1.3.4"
+  VERSION = "1.3.6"
 end

data/spec/lib/ratatouille/array_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 
 describe "Ratatouille::ArrayMethods" do
-  [ :min_length, 
+  [ :ratify_each, 
+    :min_length, 
     :max_length, 
     :length_between
   ].each do |m|
@@ -12,6 +13,39 @@ describe "Ratatouille::ArrayMethods" do
     end
   end
 
+  describe "ratify_each" do
+    it "should set block name to name in options" do
+      n = ""
+      RatifierTest.new(['foo', 'bar']) do
+        ratify_each { n = name }
+      end
+      n.should match /^(array_item)/i
+
+      RatifierTest.new(['foo', 'bar']) do
+        ratify_each(:name => "foo") { n = name }
+      end
+      n.should match /^foo/i
+    end
+
+    it "should be invalid for given array" do
+      r = RatifierTest.new(['bar', 'biz']) do
+        ratify_each(:is_a => String) do
+          validation_error("#{ro} is not 'bang'") unless ro == 'bang'
+        end
+      end
+      r.errors_array.length.should == 2
+    end
+
+    it "should be valid for given array" do
+      r = RatifierTest.new(['bar', 'biz']) do
+        ratify_each(:is_a => String) do
+          validation_error("too short") unless ro.size > 2
+        end
+      end
+      r.should be_valid
+    end
+  end
+
   describe "is_empty" do
     it "should not be valid for non-empty array" do
       RatifierTest.new(['bar']){ is_empty }.should_not be_valid

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ratatouille
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 23
   prerelease: 
   segments: 
   - 1
   - 3
-  - 4
-  version: 1.3.4
+  - 6
+  version: 1.3.6
 platform: ruby
 authors: 
 - Ryan Johnson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-25 00:00:00 Z
+date: 2012-04-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec