add recursion feature for validating nested attributes

add tests for nested attributes

lib/rails_param/param.rb

@@ -7,6 +7,13 @@ module RailsParam
             attr_accessor :param, :options
         end
 
+        class MockController
+            include RailsParam::Param
+            attr_accessor :params
+            # def params
+            # end
+        end
+
         def param!(name, type, options = {})
             name = name.to_s
 
@@ -17,8 +24,19 @@ module RailsParam
                 params[name] = (options[:default].call if options[:default].respond_to?(:call)) || options[:default] if params[name].nil? and options[:default]
                 params[name] = options[:transform].to_proc.call(params[name]) if params[name] and options[:transform]
                 validate!(params[name], options)
+                if block_given?
+                    controller = RailsParam::Param::MockController.new
+                    controller.params = params[name]
+                    # begin
+                        yield(controller)
+
+                        # exception.param, exception.options = name, options
+                        # raise InvalidParameterError exception
+                    # end
+                end
             rescue InvalidParameterError => exception
-        exception.param, exception.options = name, options
+                exception.param ||= name
+                exception.options ||= options
                 raise exception
             end
         end
@@ -58,7 +76,7 @@ module RailsParam
                 return (/(false|f|no|n|0)$/i === param.to_s ? false : (/(true|t|yes|y|1)$/i === param.to_s ? true : nil)) if type == TrueClass || type == FalseClass || type == :boolean
                 if type == BigDecimal
                     param = param.delete('$,').strip.to_f if param.is_a?(String)
-          return BigDecimal.new(param, (options[:precision] || DEFAULT_PRECISION)) if type == BigDecimal
+                    return BigDecimal.new(param, (options[:precision] || DEFAULT_PRECISION))
                 end
                 return nil
             rescue ArgumentError

spec/fixtures/controllers.rb

@@ -17,4 +17,18 @@ class FakeController < ActionController::Base
   def new
     render text: "new"
   end
+
+    def edit
+        param! :book, Hash, required: true do |b|
+            b.param! :title, String, required: true
+            b.param! :author, Hash do |a|
+                a.param! :first_name, String, required: true
+                a.param! :last_name, String, required: true
+                a.param! :age, Integer, required: true
+            end
+            b.param! :price, BigDecimal, required: true
+        end
+        render text: :book
+    end
+
 end

spec/fixtures/fake_rails_application.rb

@@ -15,6 +15,7 @@ module Rails
         get '/fake/new' => "fake#new"
         get '/fakes' => "fake#index"
         get '/fake/(:id)' => "fake#show"
+          get '/fake/edit' => "fake#edit"
       end
       @routes
     end

spec/rails_integration_spec.rb

@@ -10,6 +10,54 @@ describe FakeController, type: :controller do
     end
   end
 
+  describe "nested_hash" do
+      it "validates nested properties" do
+          params = {
+              'book' => {
+                  'title' => 'One Hundred Years of Solitude',
+                  'author' => {
+                      'first_name' => 'Garbriel Garcia',
+                      'last_name' => 'Marquez',
+                      'age' => '70'
+                  },
+                  'price' => '$1,000.00'
+              }}
+          get :edit, params
+          expect(controller.params[:book][:author][:age]).to eql 70
+          expect(controller.params[:book][:author][:age]).to be_kind_of Integer
+          expect(controller.params[:book][:price]).to eql 1000.0
+          expect(controller.params[:book][:price]).to be_instance_of BigDecimal
+      end
+
+      it "raises error when required nested attribute missing" do
+          params = {
+              'book' => {
+                  'title' => 'One Hundred Years of Solitude',
+                  'author' => {
+                      'last_name' => 'Marquez',
+                      'age' => '70'
+                  },
+                  'price' => '$1,000.00'
+              }}
+          expect { get :edit, params }.to raise_error { |error|
+              expect(error).to be_a(RailsParam::Param::InvalidParameterError)
+              expect(error.param).to eql("first_name")
+              expect(error.options).to eql({ :required => true })
+          }
+      end
+
+      it "passes when hash that's not required but has required attributes is missing" do
+          params = {
+              'book' => {
+                  'title' => 'One Hundred Years of Solitude',
+                  'price' => '$1,000.00'
+              }}
+          get :edit, params
+          expect(controller.params[:book][:price]).to eql 1000.0
+          expect(controller.params[:book][:price]).to be_instance_of BigDecimal
+      end
+  end
+
   describe "InvalidParameterError" do
     it "raises an exception with params attributes" do
       expect { get :index, sort: "foo" }.to raise_error { |error|

spec/rails_param/param_spec.rb

@@ -4,7 +4,8 @@ require 'action_controller'
 class MyController < ActionController::Base
     include RailsParam::Param
 
-  def params; end
+    def params;
+    end
 end
 
 describe RailsParam::Param do
@@ -18,7 +19,7 @@ describe RailsParam::Param do
         describe "transform" do
             context "with a method" do
                 it "transforms the value" do
-          allow(controller).to receive(:params).and_return({ "word" => "foo" })
+                    allow(controller).to receive(:params).and_return({"word" => "foo"})
                     controller.param! :word, String, transform: :upcase
                     expect(controller.params["word"]).to eql("FOO")
                 end
@@ -26,7 +27,7 @@ describe RailsParam::Param do
 
             context "with a block" do
                 it "transforms the value" do
-          allow(controller).to receive(:params).and_return({ "word" => "FOO" })
+                    allow(controller).to receive(:params).and_return({"word" => "FOO"})
                     controller.param! :word, String, transform: lambda { |n| n.downcase }
                     expect(controller.params["word"]).to eql("foo")
                 end
@@ -36,7 +37,7 @@ describe RailsParam::Param do
         describe "default" do
             context "with a value" do
                 it "defaults to the value" do
-          allow(controller).to receive(:params).and_return({ })
+                    allow(controller).to receive(:params).and_return({})
                     controller.param! :word, String, default: "foo"
                     expect(controller.params["word"]).to eql("foo")
                 end
@@ -44,7 +45,7 @@ describe RailsParam::Param do
 
             context "with a block" do
                 it "defaults to the block value" do
-          allow(controller).to receive(:params).and_return({ })
+                    allow(controller).to receive(:params).and_return({})
                     controller.param! :word, String, default: lambda { "foo" }
                     expect(controller.params["word"]).to eql("foo")
                 end
@@ -53,68 +54,68 @@ describe RailsParam::Param do
 
         describe "coerce" do
             it "converts to String" do
-        allow(controller).to receive(:params).and_return({ "foo" => :bar })
+                allow(controller).to receive(:params).and_return({"foo" => :bar})
                 controller.param! :foo, String
                 expect(controller.params["foo"]).to eql("bar")
             end
 
             it "converts to Integer" do
-        allow(controller).to receive(:params).and_return({ "foo" => "42" })
+                allow(controller).to receive(:params).and_return({"foo" => "42"})
                 controller.param! :foo, Integer
                 expect(controller.params["foo"]).to eql(42)
             end
 
             it "converts to Float" do
-        allow(controller).to receive(:params).and_return({ "foo" => "42.22" })
+                allow(controller).to receive(:params).and_return({"foo" => "42.22"})
                 controller.param! :foo, Float
                 expect(controller.params["foo"]).to eql(42.22)
             end
 
             it "converts to Array" do
-        allow(controller).to receive(:params).and_return({ "foo" => "2,3,4,5" })
+                allow(controller).to receive(:params).and_return({"foo" => "2,3,4,5"})
                 controller.param! :foo, Array
                 expect(controller.params["foo"]).to eql(["2", "3", "4", "5"])
             end
 
             it "converts to Hash" do
-        allow(controller).to receive(:params).and_return({ "foo" => "key1:foo,key2:bar" })
+                allow(controller).to receive(:params).and_return({"foo" => "key1:foo,key2:bar"})
                 controller.param! :foo, Hash
-        expect(controller.params["foo"]).to eql({ "key1" => "foo", "key2" => "bar" })
+                expect(controller.params["foo"]).to eql({"key1" => "foo", "key2" => "bar"})
             end
 
             it "converts to Date" do
-        allow(controller).to receive(:params).and_return({ "foo" => "1984-01-10" })
+                allow(controller).to receive(:params).and_return({"foo" => "1984-01-10"})
                 controller.param! :foo, Date
                 expect(controller.params["foo"]).to eql(Date.parse("1984-01-10"))
             end
 
             it "converts to Time" do
-        allow(controller).to receive(:params).and_return({ "foo" => "2014-08-07T12:25:00.000+02:00" })
+                allow(controller).to receive(:params).and_return({"foo" => "2014-08-07T12:25:00.000+02:00"})
                 controller.param! :foo, Time
                 expect(controller.params["foo"]).to eql(Time.parse("2014-08-07T12:25:00.000+02:00"))
             end
 
             it "converts to DateTime" do
-        allow(controller).to receive(:params).and_return({ "foo" => "2014-08-07T12:25:00.000+02:00" })
+                allow(controller).to receive(:params).and_return({"foo" => "2014-08-07T12:25:00.000+02:00"})
                 controller.param! :foo, DateTime
                 expect(controller.params["foo"]).to eql(DateTime.parse("2014-08-07T12:25:00.000+02:00"))
             end
 
             describe "BigDecimals" do
                 it "converts to BigDecimal using default precision" do
-          allow(controller).to receive(:params).and_return({ "foo" => 12345.67890123456})
+                    allow(controller).to receive(:params).and_return({"foo" => 12345.67890123456})
                     controller.param! :foo, BigDecimal
                     expect(controller.params["foo"]).to eql 12345.678901235
                 end
 
                 it "converts to BigDecimal using precision option" do
-          allow(controller).to receive(:params).and_return({ "foo" => 12345.6789 })
+                    allow(controller).to receive(:params).and_return({"foo" => 12345.6789})
                     controller.param! :foo, BigDecimal, precision: 6
                     expect(controller.params["foo"]).to eql 12345.7
                 end
 
                 it "converts formatted currency string to big decimal" do
-          allow(controller).to receive(:params).and_return({ "foo" => "$100,000"})
+                    allow(controller).to receive(:params).and_return({"foo" => "$100,000"})
                     controller.param! :foo, BigDecimal
                     expect(controller.params["foo"]).to eql 100000.0
                 end
@@ -123,161 +124,173 @@ describe RailsParam::Param do
 
             describe "booleans" do
                 it "converts 1/0" do
-          allow(controller).to receive(:params).and_return({ "foo" => "1" })
+                    allow(controller).to receive(:params).and_return({"foo" => "1"})
                     controller.param! :foo, TrueClass
                     expect(controller.params["foo"]).to eql(true)
 
-          allow(controller).to receive(:params).and_return({ "foo" => "0" })
+                    allow(controller).to receive(:params).and_return({"foo" => "0"})
                     controller.param! :foo, TrueClass
                     expect(controller.params["foo"]).to eql(false)
                 end
 
                 it "converts true/false" do
-          allow(controller).to receive(:params).and_return({ "foo" => "true" })
+                    allow(controller).to receive(:params).and_return({"foo" => "true"})
                     controller.param! :foo, TrueClass
                     expect(controller.params["foo"]).to eql(true)
 
-          allow(controller).to receive(:params).and_return({ "foo" => "false" })
+                    allow(controller).to receive(:params).and_return({"foo" => "false"})
                     controller.param! :foo, TrueClass
                     expect(controller.params["foo"]).to eql(false)
                 end
 
                 it "converts t/f" do
-          allow(controller).to receive(:params).and_return({ "foo" => "t" })
+                    allow(controller).to receive(:params).and_return({"foo" => "t"})
                     controller.param! :foo, TrueClass
                     expect(controller.params["foo"]).to eql(true)
 
-          allow(controller).to receive(:params).and_return({ "foo" => "f" })
+                    allow(controller).to receive(:params).and_return({"foo" => "f"})
                     controller.param! :foo, TrueClass
                     expect(controller.params["foo"]).to eql(false)
                 end
 
                 it "converts yes/no" do
-          allow(controller).to receive(:params).and_return({ "foo" => "yes" })
+                    allow(controller).to receive(:params).and_return({"foo" => "yes"})
                     controller.param! :foo, TrueClass
                     expect(controller.params["foo"]).to eql(true)
 
-          allow(controller).to receive(:params).and_return({ "foo" => "no" })
+                    allow(controller).to receive(:params).and_return({"foo" => "no"})
                     controller.param! :foo, TrueClass
                     expect(controller.params["foo"]).to eql(false)
                 end
 
                 it "converts y/n" do
-          allow(controller).to receive(:params).and_return({ "foo" => "y" })
+                    allow(controller).to receive(:params).and_return({"foo" => "y"})
                     controller.param! :foo, TrueClass
                     expect(controller.params["foo"]).to eql(true)
 
-          allow(controller).to receive(:params).and_return({ "foo" => "n" })
+                    allow(controller).to receive(:params).and_return({"foo" => "n"})
                     controller.param! :foo, TrueClass
                     expect(controller.params["foo"]).to eql(false)
                 end
             end
 
             it "raises InvalidParameterError if the value is invalid" do
-        allow(controller).to receive(:params).and_return({ "foo" => "1984-01-32" })
+                allow(controller).to receive(:params).and_return({"foo" => "1984-01-32"})
                 expect { controller.param! :foo, Date }.to raise_error(RailsParam::Param::InvalidParameterError)
             end
         end
 
+        describe 'validating nested hash' do
+            it 'typecasts nested attribtues' do
+                allow(controller).to receive(:params).and_return({'foo' => {'bar' => 1, 'baz' => 2}})
+                controller.param! :foo, Hash do |p|
+                    p.param! :bar, BigDecimal
+                    p.param! :baz, Float
+                end
+                expect(controller.params['foo']['bar']).to be_instance_of BigDecimal
+                expect(controller.params['foo']['baz']).to be_instance_of Float
+            end
+        end
+
         describe "validation" do
             describe "required parameter" do
                 it "succeeds" do
-          allow(controller).to receive(:params).and_return({ "price" => "50" })
+                    allow(controller).to receive(:params).and_return({"price" => "50"})
                     expect { controller.param! :price, Integer, required: true }.to_not raise_error
                 end
 
                 it "raises" do
-          allow(controller).to receive(:params).and_return({ })
+                    allow(controller).to receive(:params).and_return({})
                     expect { controller.param! :price, Integer, required: true }.to raise_error(RailsParam::Param::InvalidParameterError)
                 end
             end
 
             describe "blank parameter" do
                 it "succeeds" do
-          allow(controller).to receive(:params).and_return({ "price" => "50" })
+                    allow(controller).to receive(:params).and_return({"price" => "50"})
                     expect { controller.param! :price, String, blank: false }.to_not raise_error
                 end
 
                 it "raises" do
-          allow(controller).to receive(:params).and_return({ "price" => "" })
+                    allow(controller).to receive(:params).and_return({"price" => ""})
                     expect { controller.param! :price, String, blank: false }.to raise_error(RailsParam::Param::InvalidParameterError)
                 end
             end
 
             describe "format parameter" do
                 it "succeeds" do
-          allow(controller).to receive(:params).and_return({ "price" => "50$" })
+                    allow(controller).to receive(:params).and_return({"price" => "50$"})
                     expect { controller.param! :price, String, format: /[0-9]+\$/ }.to_not raise_error
                 end
 
                 it "raises" do
-          allow(controller).to receive(:params).and_return({ "price" => "50" })
+                    allow(controller).to receive(:params).and_return({"price" => "50"})
                     expect { controller.param! :price, String, format: /[0-9]+\$/ }.to raise_error(RailsParam::Param::InvalidParameterError)
                 end
             end
 
             describe "is parameter" do
                 it "succeeds" do
-          allow(controller).to receive(:params).and_return({ "price" => "50" })
+                    allow(controller).to receive(:params).and_return({"price" => "50"})
                     expect { controller.param! :price, String, is: "50" }.to_not raise_error
                 end
 
                 it "raises" do
-          allow(controller).to receive(:params).and_return({ "price" => "51" })
+                    allow(controller).to receive(:params).and_return({"price" => "51"})
                     expect { controller.param! :price, String, is: "50" }.to raise_error(RailsParam::Param::InvalidParameterError)
                 end
             end
 
             describe "min parameter" do
                 it "succeeds" do
-          allow(controller).to receive(:params).and_return({ "price" => "50" })
+                    allow(controller).to receive(:params).and_return({"price" => "50"})
                     expect { controller.param! :price, Integer, min: 50 }.to_not raise_error
                 end
 
                 it "raises" do
-          allow(controller).to receive(:params).and_return({ "price" => "50" })
+                    allow(controller).to receive(:params).and_return({"price" => "50"})
                     expect { controller.param! :price, Integer, min: 51 }.to raise_error(RailsParam::Param::InvalidParameterError)
                 end
             end
 
             describe "max parameter" do
                 it "succeeds" do
-          allow(controller).to receive(:params).and_return({ "price" => "50" })
+                    allow(controller).to receive(:params).and_return({"price" => "50"})
                     expect { controller.param! :price, Integer, max: 50 }.to_not raise_error
                 end
 
                 it "raises" do
-          allow(controller).to receive(:params).and_return({ "price" => "50" })
+                    allow(controller).to receive(:params).and_return({"price" => "50"})
                     expect { controller.param! :price, Integer, max: 49 }.to raise_error(RailsParam::Param::InvalidParameterError)
                 end
             end
 
             describe "min_length parameter" do
                 it "succeeds" do
-          allow(controller).to receive(:params).and_return({ "word" => "foo" })
+                    allow(controller).to receive(:params).and_return({"word" => "foo"})
                     expect { controller.param! :word, String, min_length: 3 }.to_not raise_error
                 end
 
                 it "raises" do
-          allow(controller).to receive(:params).and_return({ "word" => "foo" })
+                    allow(controller).to receive(:params).and_return({"word" => "foo"})
                     expect { controller.param! :word, String, min_length: 4 }.to raise_error(RailsParam::Param::InvalidParameterError)
                 end
             end
 
             describe "max_length parameter" do
                 it "succeeds" do
-          allow(controller).to receive(:params).and_return({ "word" => "foo" })
+                    allow(controller).to receive(:params).and_return({"word" => "foo"})
                     expect { controller.param! :word, String, max_length: 3 }.to_not raise_error
                 end
 
                 it "raises" do
-          allow(controller).to receive(:params).and_return({ "word" => "foo" })
+                    allow(controller).to receive(:params).and_return({"word" => "foo"})
                     expect { controller.param! :word, String, max_length: 2 }.to raise_error(RailsParam::Param::InvalidParameterError)
                 end
             end
 
             describe "in, within, range parameters" do
-        before(:each) { allow(controller).to receive(:params).and_return({ "price" => "50" }) }
+                before(:each) { allow(controller).to receive(:params).and_return({"price" => "50"}) }
 
                 it "succeeds in the range" do
                     controller.param! :price, Integer, in: 1..100