Add support for JSON

README.md

@@ -55,6 +55,7 @@ By declaring parameter types, incoming parameters will automatically be transfor
 - `:boolean/TrueClass/FalseClass` _("1/0", "true/false", "t/f", "yes/no", "y/n")_
 - `Array` _("1,2,3,4,5")_
 - `Hash` _("key1:value1,key2:value2")_
+- `JSON` _("{ "key1": "foo", "key2": "bar"}")_
 - `Date`, `Time`, & `DateTime`
 - `BigDecimal` _("$1,000,000")_
 
@@ -101,6 +102,19 @@ param! :book, Hash do |b|
 end
 ```
 
+And JSON also:
+
+```ruby
+param! :book, JSON do |b|
+  b.param! :title, String, blank: false
+  b.param! :price, BigDecimal, precision: 4, required: true
+  b.param! :author, JSON, required: true do |a|
+    a.param! :first_name, String
+    a.param! :last_name, String, blank: false
+  end
+end
+```
+
 ### Arrays
 
 Validate every element of your array, including nested hashes and arrays:

lib/rails_param/param.rb

@@ -1,6 +1,5 @@
 module RailsParam
   module Param
-
     DEFAULT_PRECISION = 14
 
     class InvalidParameterError < StandardError
@@ -84,13 +83,14 @@ def coerce(param, type, options = {})
         return DateTime.parse(param) if type == DateTime
         return Array(param.split(options[:delimiter] || ",")) if type == Array
         return Hash[param.split(options[:delimiter] || ",").map { |c| c.split(options[:separator] || ":") }] if type == Hash
+        return JSON(param) if type == JSON
         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))
         end
         return nil
-      rescue ArgumentError
+      rescue ArgumentError, JSON::ParserError
         raise InvalidParameterError, "'#{param}' is not a valid #{type}"
       end
     end

spec/rails_param/param_spec.rb

@@ -83,6 +83,12 @@ def params;
         expect(controller.params["foo"]).to eql({"key1" => "foo", "key2" => "bar"})
       end
 
+      it "converts to JSON" do
+        allow(controller).to receive(:params).and_return({"foo" => '{ "key1": "foo", "key2": "bar"}'.gsub("\"", '"') })
+        controller.param! 'foo', JSON
+        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"})
         controller.param! :foo, Date
@@ -221,6 +227,47 @@ def params;
       end
     end
 
+    describe 'validating nested json' do
+      it 'typecasts nested attributes' do
+        allow(controller).to receive(:params).and_return('foo' => '{ "bar" : 1, "baz" : 2}'.gsub("\"", '"'))
+        controller.param! :foo, JSON 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
+
+      it 'does not raise exception if hash is not required but nested attributes are, and no hash is provided' do
+        allow(controller).to receive(:params).and_return(foo: nil)
+        controller.param! :foo, JSON do |p|
+          p.param! :bar, BigDecimal, required: true
+          p.param! :baz, Float, required: true
+        end
+        expect(controller.params['foo']).to be_nil
+      end
+
+      it 'raises exception if hash is required, nested attributes are not required, and no hash is provided' do
+        allow(controller).to receive(:params).and_return(foo: nil)
+        expect {
+          controller.param! :foo, JSON, required: true do |p|
+            p.param! :bar, BigDecimal
+            p.param! :baz, Float
+          end
+        }.to raise_exception
+      end
+
+      it 'raises exception if hash is not required but nested attributes are, and hash has missing attributes' do
+        allow(controller).to receive(:params).and_return("{'foo' : {'bar' : 1, 'baz' : nil}}")
+        expect {
+          controller.param! :foo, JSON do |p|
+            p.param! :bar, BigDecimal, required: true
+            p.param! :baz, Float, required: true
+          end
+        }.to raise_exception
+      end
+    end
+
     describe 'validating arrays' do
       it 'typecasts array of primitive elements' do
         allow(controller).to receive(:params).and_return({'array' => ['1', '2']})