brainstem 1.1.1 → 1.3.0

data/spec/brainstem/api_docs/presenter_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 require 'set'
 require 'ostruct'
+require 'brainstem/presenter'
 require 'brainstem/api_docs/presenter'
 
 module Brainstem
@@ -111,14 +112,25 @@ module Brainstem
 
 
         describe "#valid_fields" do
-          let(:field) { Object.new }
-          before      { stub(field).options { { nodoc: nodoc } } }
+          let(:presenter_class) do
+            Class.new(Brainstem::Presenter) do
+              presents Workspace
+            end
+          end
 
-          describe "leafs" do
-            let(:config) { { fields: { a_field: field } } }
+          subject { described_class.new(atlas, target_class: 'Workspace', const: presenter_class) }
+
+          before do
+            stub(atlas).find_by_class(anything) { nil }
+          end
 
+          describe "leafs" do
             context "when nodoc" do
-              let(:nodoc)  { true }
+              before do
+                presenter_class.fields do
+                  field :new_field, :string, dynamic: lambda { "new_field value" }, nodoc: true
+                end
+              end
 
               it "rejects the field" do
                 expect(subject.valid_fields.count).to eq 0
@@ -126,18 +138,43 @@ module Brainstem
             end
 
             context "when not nodoc" do
+              before do
+                presenter_class.fields do
+                  field :new_field, :string, dynamic: lambda { "new_field value" }, nodoc: false
+                  field :new_field2, :string, dynamic: lambda { "new_field2 value" }
+                end
+              end
+
               it "keeps the field" do
-                expect(subject.valid_fields.count).to eq 1
+                expect(subject.valid_fields.keys).to match_array(%w(new_field new_field2))
               end
             end
           end
 
           describe "branches" do
             describe "single nesting" do
-              let(:config) { { fields: { nesting_one: { a_field: field } } } }
+              context "when nested field is nodoc" do
+                before do
+                  presenter_class.fields do
+                    fields :nested_field, :hash, dynamic: lambda { {} }, nodoc: true do
+                      field :sub_field, :string, dynamic: lambda { "sub_field value" }
+                    end
+                  end
+                end
 
-              context "when all nodoc" do
-                let(:nodoc)  { true }
+                it "rejects the nested field and its sub fields" do
+                  expect(subject.valid_fields.count).to eq 0
+                end
+              end
+
+              context "when all sub fields in a nested field are nodoc" do
+                before do
+                  presenter_class.fields do
+                    fields :nested_field, :hash, dynamic: lambda { {} }, nodoc: false do
+                      field :sub_field, :string, dynamic: lambda { "new_field2 value" }, nodoc: true
+                    end
+                  end
+                end
 
                 it "rejects the nested field" do
                   expect(subject.valid_fields.count).to eq 0
@@ -145,30 +182,60 @@ module Brainstem
               end
 
               context "when not all nodoc" do
+                before do
+                  presenter_class.fields do
+                    fields :nested_field, :hash, dynamic: lambda { {} } do
+                      field :sub_field, :string, dynamic: lambda { "new_field2 value" }
+                    end
+                  end
+                end
+
                 it "keeps the nested field" do
-                  expect(subject.valid_fields.count).to eq 1
+                  valid_fields = subject.valid_fields.to_h.with_indifferent_access
+
+                  expect(valid_fields.keys).to eq(%w(nested_field))
+                  expect(valid_fields[:nested_field].keys).to eq(%w(sub_field))
                 end
               end
-
             end
 
             describe "double nesting" do
-              let(:config) { { fields: { nesting_one: { nesting_two: { a_field: field } } } } }
-
-              context "when all nodoc" do
-                let(:nodoc)  { true }
+              context "when the only double nested field is nodoc" do
+                before do
+                  presenter_class.fields do
+                    fields :nested_field, :hash, dynamic: lambda { {} } do
+                      fields :double_nested_field, :hash, dynamic: lambda { {} }, nodoc: true do
+                        field :leaf_field, :string, dynamic: lambda { "leaf value" }
+                      end
+                    end
+                  end
+                end
 
-                it "rejects the nested field" do
+                it "rejects the nested field and its sub fields" do
                   expect(subject.valid_fields.count).to eq 0
                 end
               end
 
               context "when not all nodoc" do
+                before do
+                  presenter_class.fields do
+                    fields :nested_field, :hash, dynamic: lambda { {} } do
+                      fields :double_nested_field, :hash, dynamic: lambda { {} } do
+                        field :leaf_field_1, :string, dynamic: lambda { "leaf_field_1 value" }
+                        field :leaf_field_2, :string, dynamic: lambda { "leaf_field_2 value" }, nodoc: false
+                      end
+                    end
+                  end
+                end
+
                 it "keeps the nested field" do
-                  expect(subject.valid_fields.count).to eq 1
+                  valid_fields = subject.valid_fields.to_h.with_indifferent_access
+
+                  expect(valid_fields.keys).to match_array(%w(nested_field))
+                  expect(valid_fields[:nested_field].keys).to match_array(%w(double_nested_field))
+                  expect(valid_fields[:nested_field][:double_nested_field].keys).to match_array(%w(leaf_field_1 leaf_field_2))
                 end
               end
-
             end
           end
         end

data/spec/brainstem/concerns/controller_dsl_spec.rb

@@ -102,23 +102,31 @@ module Brainstem
       end
 
       describe ".model_params" do
+        let(:root_proc) { Proc.new {} }
+
         before do
           stub(subject).brainstem_model_name { "widgets" }
+          stub(subject).format_root_name(:widgets) { root_proc }
         end
 
         it "evaluates the block given to it" do
-          mock(subject).valid(:thing, root: "widgets")
+          mock(subject).valid(:thing, :string, 'root' => root_proc, 'ancestors' => [root_proc])
 
           subject.model_params :widgets do |param|
-            param.valid :thing
+            param.valid :thing, :string
           end
         end
 
         it "merges options" do
-          mock(subject).valid(:thing, root: "widgets", nodoc: true)
+          mock(subject).valid(:thing, :integer,
+            'root'      => root_proc,
+            'ancestors' => [root_proc],
+            'nodoc'     => true,
+            'required'  => true
+          )
 
           subject.model_params :widgets do |param|
-            param.valid :thing, nodoc: true
+            param.valid :thing, :integer, nodoc: true, required: true
           end
         end
       end
@@ -127,29 +135,405 @@ module Brainstem
         context "when given a name and an options hash" do
           it "appends to the valid params hash" do
             subject.brainstem_params do
-              valid :sprocket_name,
-                info: "sprockets[sprocket_name] is required"
+              valid :sprocket_ids, :array,
+                info: "sprockets[sprocket_ids] is required",
+                required: true,
+                item_type: :integer
             end
 
-            expect(subject.configuration[:_default][:valid_params][:sprocket_name][:info]).to \
-              eq "sprockets[sprocket_name] is required"
+            valid_params = subject.configuration[:_default][:valid_params]
+            expect(valid_params.keys.length).to eq(1)
+            expect(valid_params.keys[0]).to be_a(Proc)
+            expect(valid_params.keys[0].call).to eq("sprocket_ids")
+
+            sprocket_ids_config = valid_params[valid_params.keys[0]]
+            expect(sprocket_ids_config[:info]).to eq "sprockets[sprocket_ids] is required"
+            expect(sprocket_ids_config[:required]).to be_truthy
+            expect(sprocket_ids_config[:type]).to eq("array")
+            expect(sprocket_ids_config[:item_type]).to eq("integer")
           end
         end
 
-        context "when given a name and an options hash" do
+        context "when given a name and an HWIA options hash" do
           it "appends to the valid params hash" do
-            # This is HWIA, so all keys are stringified
+            # This is Hash With Indifferent Access, so all keys are stringified
             data = {
               "recursive" => true,
-              "info" => "sprockets[sub_sprockets] is recursive and an array"
+              "info"      => "sprockets[sub_sprockets] is recursive and an array",
+              "required"  => true
             }
 
             subject.brainstem_params do
-              valid :sub_sprockets, data
+              valid :sub_sprockets, :hash, data
+            end
+
+            valid_params = subject.configuration[:_default][:valid_params]
+            expect(valid_params.keys.length).to eq(1)
+            expect(valid_params.keys[0].call).to eq("sub_sprockets")
+            expect(valid_params[valid_params.keys[0]]).to eq({
+              "recursive" => true,
+              "info"      => "sprockets[sub_sprockets] is recursive and an array",
+              "required"  => true,
+              "type"      => "hash",
+              "nodoc"     => false
+            })
+          end
+        end
+
+        context "when no options are provided" do
+          it "sets default options for the param" do
+            subject.brainstem_params do
+              valid :sprocket_name, :text
+            end
+
+            valid_params = subject.configuration[:_default][:valid_params]
+            expect(valid_params.keys.length).to eq(1)
+            expect(valid_params.keys[0].call).to eq("sprocket_name")
+
+            configuration = valid_params[valid_params.keys[0]]
+            expect(configuration[:nodoc]).to be_falsey
+            expect(configuration[:required]).to be_falsey
+            expect(configuration[:type]).to eq("text")
+          end
+
+          context "when block is specified" do
+            it "defaults type to string and sets default options for the param" do
+              subject.brainstem_params do
+                valid :sprocket, :hash do
+                  valid :title, :string
+                end
+              end
+
+              valid_params = subject.configuration[:_default][:valid_params]
+              expect(valid_params.keys.length).to eq(2)
+
+              param_keys = valid_params.keys
+              expect(param_keys[0].call).to eq('sprocket')
+              expect(param_keys[1].call).to eq('title')
+
+              sprocket_key = param_keys[0]
+              sprocket_configuration = valid_params[sprocket_key]
+              expect(sprocket_configuration[:nodoc]).to be_falsey
+              expect(sprocket_configuration[:required]).to be_falsey
+              expect(sprocket_configuration[:type]).to eq('hash')
+              expect(sprocket_configuration[:ancestors]).to be_nil
+              expect(sprocket_configuration[:root]).to be_nil
+
+              title_configuration = valid_params[param_keys[1]]
+              expect(title_configuration[:nodoc]).to be_falsey
+              expect(title_configuration[:required]).to be_falsey
+              expect(title_configuration[:type]).to eq('string')
+              expect(title_configuration[:root]).to be_nil
+              expect(title_configuration[:ancestors]).to eq([sprocket_key])
+            end
+          end
+        end
+
+        context "when type is hash" do
+          it "adds the nested fields to valid params" do
+            subject.brainstem_params do
+              valid :id, :integer
+
+              valid :info, :hash, required: true do |param|
+                param.valid :title, :string, required: true
+              end
+
+              model_params :sprocket do |param|
+                param.valid :data, :text
+              end
+            end
+
+            valid_params = subject.configuration[:_default][:valid_params]
+            expect(valid_params.keys.length).to eq(4)
+
+            param_keys = valid_params.keys
+            expect(param_keys[0].call).to eq('id')
+            expect(param_keys[1].call).to eq('info')
+            expect(param_keys[2].call).to eq('title')
+            expect(param_keys[3].call).to eq('data')
+
+            id_config = valid_params[param_keys[0]]
+            expect(id_config[:root]).to be_nil
+            expect(id_config[:ancestors]).to be_nil
+
+            info_key = param_keys[1]
+            info_config = valid_params[info_key]
+            expect(info_config[:root]).to be_nil
+            expect(info_config[:ancestors]).to be_nil
+
+            info_title_config = valid_params[param_keys[2]]
+            expect(info_title_config[:root]).to be_nil
+            expect(info_title_config[:ancestors]).to eq([info_key])
+
+            sprocket_data_config = valid_params[param_keys[3]]
+            sprocket_data_root_key = sprocket_data_config[:root]
+            expect(sprocket_data_root_key).to be_present
+            expect(sprocket_data_config[:ancestors]).to eq([sprocket_data_root_key])
+          end
+
+          context "when multi nested attributes are specified" do
+            it "adds the nested fields to valid params" do
+              subject.brainstem_params do
+                model_params :sprocket do |param|
+                  param.valid :title, :string
+
+                  param.valid :details, :hash do |nested_param|
+                    nested_param.valid :category, :string
+
+                    nested_param.valid :data, :hash do |double_nested_param|
+                      double_nested_param.valid :raw_text, :string
+                    end
+                  end
+                end
+              end
+
+              valid_params = subject.configuration[:_default][:valid_params]
+              param_keys = valid_params.keys
+              expect(param_keys.length).to eq(5)
+
+              expect(param_keys[0].call).to eq('title')
+              title_config = valid_params[param_keys[0]]
+              root_param_key = title_config[:root]
+              expect(root_param_key).to be_present
+              expect(title_config[:ancestors]).to eq([root_param_key])
+
+              expect(param_keys[1].call).to eq('details')
+              details_key = param_keys[1]
+              details_config = valid_params[details_key]
+              expect(details_config[:root]).to eq(root_param_key)
+              expect(details_config[:ancestors]).to eq([root_param_key])
+
+              expect(param_keys[2].call).to eq('category')
+              details_category_config = valid_params[param_keys[2]]
+              expect(details_category_config[:root]).to be_nil
+              expect(details_category_config[:ancestors]).to eq([root_param_key, details_key])
+
+              expect(param_keys[3].call).to eq('data')
+              details_data_key = param_keys[3]
+              details_data_config = valid_params[details_data_key]
+              expect(details_data_config[:root]).to be_nil
+              expect(details_data_config[:ancestors]).to eq([root_param_key, details_key])
+
+              expect(param_keys[4].call).to eq('raw_text')
+              details_data_raw_text_config = valid_params[param_keys[4]]
+              expect(details_data_raw_text_config[:root]).to be_nil
+              expect(details_data_raw_text_config[:ancestors]).to eq([root_param_key, details_key, details_data_key])
+            end
+          end
+
+          context "when root has no required attribute" do
+            it "sets the required attribute for the parent configuration to false" do
+              subject.brainstem_params do
+                valid :template, :hash do |param|
+                  param.valid :id, :integer
+                  param.valid :title, :string
+                end
+              end
+
+              valid_params = subject.configuration[:_default][:valid_params]
+
+              template_key = valid_params.keys[0]
+              expect(template_key.call).to eq('template')
+              expect(valid_params[template_key][:required]).to be_falsey
+            end
+
+            context "when one of the nested fields is required" do
+              it "sets the required attribute for the parent configuration to true" do
+                subject.brainstem_params do
+                  valid :template, :hash do |param|
+                    param.valid :id, :integer, required: true
+                    param.valid :title, :string
+                  end
+
+                  model_params :sprocket do |param|
+                    param.valid :details, :hash do |nested_param|
+                      nested_param.valid :data, :hash do |double_nested_param|
+                        double_nested_param.valid :raw_text, :string, required: true
+                      end
+                    end
+                  end
+                end
+
+                valid_params = subject.configuration[:_default][:valid_params]
+
+                template_key = valid_params.keys[0]
+                expect(template_key.call).to eq('template')
+                expect(valid_params[template_key][:required]).to be_truthy
+
+                sprocket_details_key = valid_params.keys[3]
+                expect(sprocket_details_key.call).to eq('details')
+                expect(valid_params[sprocket_details_key][:required]).to be_truthy
+
+                sprocket_details_data_key = valid_params.keys[4]
+                expect(sprocket_details_data_key.call).to eq('data')
+                expect(valid_params[sprocket_details_data_key][:required]).to be_truthy
+
+                sprocket_details_data_raw_text_key = valid_params.keys[5]
+                expect(sprocket_details_data_raw_text_key.call).to eq('raw_text')
+                expect(valid_params[sprocket_details_data_raw_text_key][:required]).to be_truthy
+              end
+            end
+          end
+
+          context "when root is nodoc" do
+            it "updates the nodoc property on its nested fields to true" do
+              subject.brainstem_params do
+                model_params :sprocket do |param|
+                  param.valid :title, :string
+                  param.valid :details, :hash, nodoc: true do |param|
+                    param.valid :category, :string
+                    param.valid :data, :hash do |nested_param|
+                      param.valid :raw_text, :string
+                    end
+                  end
+                end
+              end
+
+              valid_params = subject.configuration[:_default][:valid_params]
+
+              title_key = valid_params.keys[0]
+              expect(title_key.call).to eq('title')
+              expect(valid_params[title_key][:nodoc]).to be_falsey
+
+              details_key = valid_params.keys[1]
+              expect(details_key.call).to eq('details')
+              expect(valid_params[details_key][:nodoc]).to be_truthy
+
+              details_category_key = valid_params.keys[2]
+              expect(details_category_key.call).to eq('category')
+              expect(valid_params[details_category_key][:nodoc]).to be_truthy
+
+              details_data_key = valid_params.keys[3]
+              expect(details_data_key.call).to eq('data')
+              expect(valid_params[details_data_key][:nodoc]).to be_truthy
+
+              details_data_raw_text_key = valid_params.keys[4]
+              expect(details_data_raw_text_key.call).to eq('raw_text')
+              expect(valid_params[details_data_raw_text_key][:nodoc]).to be_truthy
+            end
+          end
+        end
+
+        context "when type is array" do
+          it "sets the type and sub type appropriately" do
+            subject.brainstem_params do
+              valid :sprocket_ids, :array,
+                    required: true,
+                    item_type: :string
+            end
+
+            valid_params = subject.configuration[:_default][:valid_params]
+
+            sprocket_ids_key = valid_params.keys[0]
+            expect(sprocket_ids_key.call).to eq('sprocket_ids')
+
+            sprocket_ids_config = valid_params[sprocket_ids_key]
+            expect(sprocket_ids_config[:required]).to be_truthy
+            expect(sprocket_ids_config[:type]).to eq('array')
+            expect(sprocket_ids_config[:item_type]).to eq('string')
+          end
+
+          context "when a block is given" do
+            it "sets the type and sub type appropriately" do
+              subject.brainstem_params do
+                valid :sprocket_tasks, :array, required: true, item_type: 'hash' do |param|
+                  param.valid :task_id, :integer, required: true
+                  param.valid :task_title, :string
+                end
+              end
+
+              valid_params = subject.configuration[:_default][:valid_params]
+
+              sprocket_tasks_key = valid_params.keys[0]
+              expect(sprocket_tasks_key.call).to eq('sprocket_tasks')
+
+              sprocket_tasks_config = valid_params[sprocket_tasks_key]
+              expect(sprocket_tasks_config[:required]).to be_truthy
+              expect(sprocket_tasks_config[:type]).to eq('array')
+              expect(sprocket_tasks_config[:item_type]).to eq('hash')
+
+              task_id_key = valid_params.keys[1]
+              expect(task_id_key.call).to eq('task_id')
+
+              task_id_config = valid_params[task_id_key]
+              expect(task_id_config[:required]).to be_truthy
+              expect(task_id_config[:type]).to eq('integer')
+              expect(task_id_config[:root]).to be_nil
+              expect(task_id_config[:ancestors]).to eq([sprocket_tasks_key])
+
+              task_title_key = valid_params.keys[2]
+              expect(task_title_key.call).to eq('task_title')
+
+              task_title_config = valid_params[task_title_key]
+              expect(task_title_config[:required]).to be_falsey
+              expect(task_title_config[:type]).to eq('string')
+              expect(task_title_config[:root]).to be_nil
+              expect(task_title_config[:ancestors]).to eq([sprocket_tasks_key])
+            end
+          end
+        end
+
+        context "deprecated type behavior" do
+          context "when no type is provided" do
+            before do
+              mock(subject).deprecated_type_warning
+            end
+
+            it "defaults to type string" do
+              subject.brainstem_params do
+                valid :sprocket_name, required: true
+              end
+
+              valid_params = subject.configuration[:_default][:valid_params]
+              expect(valid_params.keys.length).to eq(1)
+              expect(valid_params.keys[0].call).to eq("sprocket_name")
+
+              configuration = valid_params[valid_params.keys[0]]
+              expect(configuration[:type]).to eq("string")
+              expect(configuration[:required]).to be_truthy
+            end
+          end
+
+          context "when no type and options are provided" do
+            before do
+              mock(subject).deprecated_type_warning
+            end
+
+            it "defaults type to string and sets default options for the param" do
+              subject.brainstem_params do
+                valid :sprocket_name
+              end
+
+              valid_params = subject.configuration[:_default][:valid_params]
+              expect(valid_params.keys.length).to eq(1)
+              expect(valid_params.keys[0].call).to eq("sprocket_name")
+
+              configuration = valid_params[valid_params.keys[0]]
+              expect(configuration[:nodoc]).to be_falsey
+              expect(configuration[:required]).to be_falsey
+              expect(configuration[:type]).to eq("string")
+            end
+          end
+
+          context "when type and options are hashes" do
+          before do
+            mock(subject).deprecated_type_warning
+          end
+
+          it "ignores the type and defaults to string" do
+            subject.brainstem_params do
+              valid :sprocket_name, { troll: true }, { required: true }
             end
 
-            expect(subject.configuration[:_default][:valid_params][:sub_sprockets]).to \
-              eq data
+            valid_params = subject.configuration[:_default][:valid_params]
+            expect(valid_params.keys.length).to eq(1)
+            expect(valid_params.keys[0].call).to eq("sprocket_name")
+
+            configuration = valid_params[valid_params.keys[0]]
+            expect(configuration[:nodoc]).to be_falsey
+            expect(configuration[:required]).to be_truthy
+            expect(configuration[:type]).to eq("string")
+          end
           end
         end
       end
@@ -276,15 +660,15 @@ module Brainstem
           it "uses the existing context" do
             subject.brainstem_params do
               action_context :show do
-                valid :param_1, info: "something"
+                valid :param_1, :integer, info: "something"
               end
 
               action_context :show do
-                valid :param_2, info: "something else"
+                valid :param_2, :string, info: "something else"
               end
             end
 
-            expect(subject.configuration[:show][:valid_params].keys).to \
+            expect(subject.configuration[:show][:valid_params].keys.map(&:call)).to \
               eq ["param_1", "param_2"]
 
           end
@@ -297,7 +681,7 @@ module Brainstem
 
           subject.brainstem_params do
             actions [:show, :index] do
-              valid :param_1, info: "something"
+              valid :param_1, :integer, info: "something"
             end
           end
         end
@@ -305,12 +689,12 @@ module Brainstem
         it "allows passing an array" do
           subject.brainstem_params do
             actions [:show, :index] do
-              valid :param_1, info: "something"
+              valid :param_1, :string, info: "something"
             end
           end
 
           %w(index show).each do |meth|
-            expect(subject.configuration[meth.to_sym][:valid_params].keys).to \
+            expect(subject.configuration[meth.to_sym][:valid_params].keys.map(&:call)).to \
               include "param_1"
           end
         end
@@ -318,17 +702,201 @@ module Brainstem
         it "allows passing multiple symbols" do
           subject.brainstem_params do
             actions :show, :index do
-              valid :param_1, "something"
+              valid :param_1, :integer, info: "something"
             end
           end
 
           %w(index show).each do |meth|
-            expect(subject.configuration[meth.to_sym][:valid_params].keys).to \
+            expect(subject.configuration[meth.to_sym][:valid_params].keys.map(&:call)).to \
               include "param_1"
           end
         end
       end
 
+      describe "#valid_params_tree" do
+        context "when no root is specified" do
+          it "returns the field names as the top level keys" do
+            stub.any_instance_of(subject).action_name { "show" }
+
+            subject.brainstem_params do
+              actions :show do
+                valid :sprocket_ids, :array,
+                      info: "sprockets[sprocket_ids] is required",
+                      required: true,
+                      item_type: :integer
+
+                valid :widget_id, :integer,
+                      info: "sprockets[widget_id] is not required"
+              end
+            end
+
+            result = subject.new.valid_params_tree
+            expect(result.keys).to match_array(%w(sprocket_ids widget_id))
+
+            sprocket_ids_config = result[:sprocket_ids][:_config]
+            expect(sprocket_ids_config).to eq({
+              "info"      => "sprockets[sprocket_ids] is required",
+              "required"  => true,
+              "item_type" => "integer",
+              "nodoc"     => false,
+              "type"      => "array"
+            })
+
+            widget_id_config = result[:widget_id][:_config]
+            expect(widget_id_config).to eq({
+              "info"     => "sprockets[widget_id] is not required",
+              "required" => false,
+              "nodoc"    => false,
+              "type"     => "integer"
+            })
+          end
+        end
+
+        context "when root is specified" do
+          let(:brainstem_model_name) { "widget" }
+
+          it "returns the root as a top level key" do
+            stub(subject).brainstem_model_name { brainstem_model_name }
+            stub.any_instance_of(subject).brainstem_model_name { brainstem_model_name }
+            stub.any_instance_of(subject).action_name { "show" }
+
+            subject.brainstem_params do
+              valid :unrelated_root_key, :string,
+                    info: "it's unrelated.",
+                    required: true
+
+              model_params(brainstem_model_name) do |params|
+                params.valid :sprocket_parent_id, :long,
+                             info: "widget[sprocket_parent_id] is not required"
+              end
+
+              actions :show do
+                model_params(brainstem_model_name) do |params|
+                  params.valid :sprocket_name, :string,
+                               info: "widget[sprocket_name] is required",
+                               required: true
+                end
+              end
+            end
+
+            result = subject.new.valid_params_tree
+            expect(result.keys).to match_array(%w(widget unrelated_root_key))
+            expect(result[:widget].keys).to match_array(%w(sprocket_parent_id sprocket_name))
+
+            sprocket_parent_id_config = result[:widget][:sprocket_parent_id][:_config]
+            expect(sprocket_parent_id_config).to eq({
+              "info"     => "widget[sprocket_parent_id] is not required",
+              "required" => false,
+              "nodoc"    => false,
+              "type"     => "long"
+            })
+
+            sprocket_name_config = result[:widget][:sprocket_name][:_config]
+            expect(sprocket_name_config).to eq({
+              "info"     => "widget[sprocket_name] is required",
+              "required" => true,
+              "nodoc"    => false,
+              "type"     => "string"
+            })
+          end
+        end
+
+        context "when multiple fields share the same name" do
+          let(:brainstem_model_name) { "widget" }
+
+          it "retains config for both fields" do
+            stub(subject).brainstem_model_name { brainstem_model_name }
+            stub.any_instance_of(subject).brainstem_model_name { brainstem_model_name }
+            stub.any_instance_of(subject).action_name { "update" }
+
+            subject.brainstem_params do
+              actions :update do
+                valid :id, :integer,
+                      info: "ID of the widget.",
+                      required: true
+
+                model_params(brainstem_model_name) do |params|
+                  params.valid :id, :integer,
+                               info: "widget[id] is optional"
+                end
+              end
+            end
+
+            result = subject.new.valid_params_tree
+            expect(result.keys).to match_array(%w(widget id))
+            expect(result[:widget].keys).to match_array(%w(id))
+
+            id_param_config = result[:id][:_config]
+            expect(id_param_config).to eq({
+              "info"     => "ID of the widget.",
+              "required" => true,
+              "nodoc"    => false,
+              "type"     => "integer"
+            })
+
+            nested_id_param_config = result[:widget][:id][:_config]
+            expect(nested_id_param_config).to eq({
+              "info"     => "widget[id] is optional",
+              "required" => false,
+              "nodoc"    => false,
+              "type"     => "integer"
+            })
+          end
+        end
+
+        context "when multiple nested params are specified" do
+          let(:brainstem_model_name) { "widget" }
+
+          it "retains config for both fields" do
+            stub(subject).brainstem_model_name { brainstem_model_name }
+            stub.any_instance_of(subject).brainstem_model_name { brainstem_model_name }
+            stub.any_instance_of(subject).action_name { "update" }
+
+            subject.brainstem_params do
+              actions :update do
+                model_params(brainstem_model_name) do |params|
+                  params.valid :title, :string,
+                               info: "widget[title] is required",
+                               required: true
+
+                  params.valid :sprocket, :hash do |nested_params|
+                    nested_params.valid :name, :string,
+                                        info: "sprocket[name] is optional"
+                  end
+                end
+              end
+            end
+
+            result = subject.new.valid_params_tree
+            expect(result.keys).to match_array(%w(widget))
+            expect(result[:widget].keys).to match_array(%w(title sprocket))
+
+            title_param_config = result[:widget][:title][:_config]
+            expect(title_param_config).to eq({
+              "info"     => "widget[title] is required",
+              "required" => true,
+              "nodoc"    => false,
+              "type"     => "string"
+            })
+
+            sprocket_param_config = result[:widget][:sprocket][:_config]
+            expect(sprocket_param_config).to eq({
+              "required" => false,
+              "nodoc"    => false,
+              "type"     => "hash"
+            })
+
+            sprocket_name_param_config = result[:widget][:sprocket][:name][:_config]
+            expect(sprocket_name_param_config).to eq({
+              "info"     => "sprocket[name] is optional",
+              "required" => false,
+              "nodoc"    => false,
+              "type"     => "string"
+            })
+          end
+        end
+      end
+
       describe "#brainstem_valid_params" do
         let(:brainstem_model_name) { "widget" }
 
@@ -337,18 +905,20 @@ module Brainstem
           stub.any_instance_of(subject).brainstem_model_name { brainstem_model_name }
 
           subject.brainstem_params do
-            valid :unrelated_root_key,
-              info: "it's unrelated."
+            valid :unrelated_root_key, :string,
+              info: "it's unrelated.",
+              required: true
 
             model_params(brainstem_model_name) do |params|
-              params.valid :sprocket_parent_id,
-                info: "sprockets[sprocket_parent_id] is required"
+              params.valid :sprocket_parent_id, :long,
+                info: "sprockets[sprocket_parent_id] is not required"
             end
 
             actions :show do
               model_params(brainstem_model_name) do |params|
-                params.valid :sprocket_name,
-                  info: "sprockets[sprocket_name] is required"
+                params.valid :sprocket_name, :string,
+                  info: "sprockets[sprocket_name] is required",
+                  required: true
               end
             end
           end
@@ -359,7 +929,7 @@ module Brainstem
 
           subject.brainstem_params do
             model_params Proc.new { |k| k.arbitrary_method } do |params|
-              params.valid :nested_key, info: "it's nested!"
+              params.valid :nested_key, :hash, info: "it's nested!"
             end
           end
 
@@ -371,8 +941,22 @@ module Brainstem
           stub.any_instance_of(subject).action_name { "show" }
 
           expect(subject.new.brainstem_valid_params).to eq({
-            "sprocket_name" => { "info" => "sprockets[sprocket_name] is required", "root" => "widget" },
-            "sprocket_parent_id" => { "info" => "sprockets[sprocket_parent_id] is required", "root" => "widget" }
+            "sprocket_name" => {
+              "_config" => {
+                "info"     => "sprockets[sprocket_name] is required",
+                "required" => true,
+                "type"     => "string",
+                "nodoc"    => false
+              }
+            },
+            "sprocket_parent_id" => {
+              "_config" => {
+                "info"     => "sprockets[sprocket_parent_id] is not required",
+                "type"     => "long",
+                "nodoc"    => false,
+                "required" => false
+              }
+            }
           })
         end