brainstem 1.1.1 → 1.3.0

data/lib/brainstem/concerns/presenter_dsl.rb

@@ -1,6 +1,8 @@
 require 'brainstem/concerns/inheritable_configuration'
 require 'brainstem/dsl/association'
 require 'brainstem/dsl/field'
+require 'brainstem/dsl/array_block_field'
+require 'brainstem/dsl/hash_block_field'
 require 'brainstem/dsl/conditional'
 
 require 'brainstem/dsl/base_block'
@@ -50,6 +52,13 @@ module Brainstem
           configuration[:nodoc] = true
         end
 
+        #
+        # Temporary implementation to track controllers that have been documented.
+        #
+        def documented!
+          configuration[:documented] = true
+        end
+
         # Declare a helper module or block whose methods will be available in dynamic fields and associations.
         def helper(mod = nil, &block)
           if mod
@@ -114,15 +123,17 @@ module Brainstem
 
 
         #
-        # @overload filter(name, options = {})
+        # @overload filter(name, type, options = {})
         #   @param [Symbol] name The name of the scope that may be applied as a
         #     filter.
+        #   @param [Symbol] type The type of the value that filter holds.
         #   @option options [Object] :default If set, causes this filter to be
         #     applied to every request. If the filter accepts parameters, the
         #     value given here will be passed to the filter when it is applied.
         #   @option options [String] :info Docstring for the filter.
+        #   @option options [Array] :items List of assignable values for the filter.
         #
-        # @overload filter(name, options = {}, &block)
+        # @overload filter(name, type, options = {}, &block)
         #   @param [Symbol] name The filter can be requested using this name.
         #   @yieldparam scope [ActiveRecord::Relation] The scope that the
         #     filter should use as a base.
@@ -131,16 +142,25 @@ module Brainstem
         #   @yieldreturn [ActiveRecord::Relation] A new scope that filters the
         #     scope that was yielded.
         #
-        def filter(name, options = {}, &block)
-          valid_options = %w(default info include_params nodoc)
+        def filter(name, type = DEFAULT_FILTER_DATA_TYPE, options = {}, &block)
+          if type.is_a?(Hash)
+            options = type if options.blank?
+            type = DEFAULT_FILTER_DATA_TYPE
+
+            deprecated_type_warning
+          elsif type.to_s == 'array'
+            options[:item_type] = options[:item_type].to_s.presence || DEFAULT_FILTER_DATA_TYPE
+          end
+
+          valid_options = %w(default info include_params nodoc items item_type)
           options.select! { |k, v| valid_options.include?(k.to_s) }
 
           configuration[:filters][name] = options.merge({
-            value: (block_given? ? block : nil)
+            value: (block_given? ? block : nil),
+            type: type.to_s,
           })
         end
 
-
         def search(&block)
           configuration[:search] = block
         end
@@ -166,6 +186,19 @@ module Brainstem
           configuration.nonheritable!(:description)
           configuration.nonheritable!(:nodoc)
         end
+
+        DEFAULT_FILTER_DATA_TYPE = 'string'
+        private_constant :DEFAULT_FILTER_DATA_TYPE
+
+        def deprecated_type_warning
+          ActiveSupport::Deprecation.warn(
+            'Please specify the `type` of the filter as the second argument. If not specified, '\
+              'it will default to `:string`. This default behavior will be deprecated in the next major '\
+              'version and will need to be explicitly specified. '\
+              'e.g. `filter :status, :string, items: ["Started", "Completed"]`',
+            caller
+          )
+        end
       end
     end
   end

data/lib/brainstem/dsl/array_block_field.rb

@@ -0,0 +1,25 @@
+require 'brainstem/dsl/configuration'
+require 'brainstem/dsl/block_field'
+
+module Brainstem
+  module DSL
+    class ArrayBlockField < BlockField
+      def run_on(model, context, helper_instance = Object.new)
+        evaluated_models = evaluate_value_on(model, context, helper_instance)
+
+        evaluated_models.map do |evaluated_model|
+          result = {}
+
+          configuration.each do |field_name, field|
+            next unless field.presentable?(model, context)
+
+            model_for_field = use_parent_value?(field) ? evaluated_model : model
+            result[field_name] = field.run_on(model_for_field, context, context[:helper_instance])
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/brainstem/dsl/block_field.rb

@@ -0,0 +1,69 @@
+require 'brainstem/dsl/configuration'
+require 'brainstem/dsl/field'
+
+module Brainstem
+  module DSL
+    class BlockField < Field
+      attr_reader :configuration
+
+      delegate :to_h, :keys, :has_key?, :each, to: :configuration
+
+      def initialize(name, type, options, parent_field = nil)
+        super(name, type, options)
+        @parent_field = parent_field
+      end
+
+      def configuration
+        @configuration ||= begin
+          if @parent_field && @parent_field.respond_to?(:configuration)
+            DSL::Configuration.new(@parent_field.configuration)
+          else
+            DSL::Configuration.new
+          end
+        end
+      end
+
+      def [](key)
+        configuration[key]
+      end
+
+      def run_on(model, context, helper_instance = Object.new)
+        raise NotImplementedError.new("Override this method in a sub class")
+      end
+
+      def self.for(name, type, options, parent_field = nil)
+        case type.to_s
+          when 'array'
+            DSL::ArrayBlockField.new(name, type, options, parent_field)
+          when 'hash'
+            DSL::HashBlockField.new(name, type, options, parent_field)
+          else
+            raise "Unknown Brainstem Block Field type encountered: #{type}"
+        end
+      end
+
+      def evaluate_value_on(model, context, helper_instance = Object.new)
+        if options[:lookup]
+          run_on_with_lookup(model, context, helper_instance)
+        elsif options[:dynamic]
+          proc = options[:dynamic]
+          if proc.arity == 1
+            helper_instance.instance_exec(model, &proc)
+          else
+            helper_instance.instance_exec(&proc)
+          end
+        elsif options[:via]
+          model.send(options[:via])
+        else
+          raise "Block field #{name} can only be evaluated if :dynamic, :lookup, :via options are specified."
+        end
+      end
+
+      def use_parent_value?(field)
+        return true unless field.options.has_key?(:use_parent_value)
+
+        field.options[:use_parent_value]
+      end
+    end
+  end
+end

data/lib/brainstem/dsl/configuration.rb

@@ -78,8 +78,8 @@ module Brainstem
       #   keys
       #
       def nonheritable!(key)
-        key = key.to_s
-        self.nonheritable_keys << key unless self.nonheritable_keys.include?(key)
+        formatted_key = format_key(key)
+        self.nonheritable_keys << formatted_key unless self.nonheritable_keys.include?(formatted_key)
       end
 
 
@@ -104,7 +104,7 @@ module Brainstem
       # @return [Hash] the hash, less nonheritable pairs.
       #
       def pairs_visible_to_children
-        to_h.select {|k, v| keys_visible_to_children.include?(k.to_s) }
+        to_h.select {|k, v| keys_visible_to_children.include?(format_key(k)) }
       end
 
 
@@ -150,7 +150,7 @@ module Brainstem
       # @param [Symbol,String] key the key to check for nonheritability.
       #
       def key_nonheritable_in_parent?(*key)
-        parent_nonheritable_keys.include?(key.first.to_s)
+        parent_nonheritable_keys.include?(format_key(key.first))
       end
 
 
@@ -164,7 +164,7 @@ module Brainstem
       # @param [Symbol,String] key the key to check for heritability.
       #
       def key_inheritable_in_parent?(*key)
-        !key_nonheritable_in_parent?(key.first.to_s)
+        !key_nonheritable_in_parent?(format_key(key.first))
       end
 
 
@@ -258,6 +258,14 @@ module Brainstem
         end
       end
 
+      # @api private
+      #
+      # Stringifies key if key is not a Proc.
+      #
+      def format_key(key)
+        key.respond_to?(:call) ? key : key.to_s
+      end
+
       # An Array-like object that provides `push`, `concat`, `each`, `empty?`, and `to_a` methods that act the combination
       # of its own entries and those of a parent InheritableAppendSet, if present.
       class InheritableAppendSet

data/lib/brainstem/dsl/field.rb

@@ -9,7 +9,7 @@ module Brainstem
 
       def initialize(name, type, options)
         @name = name.to_s
-        @type = type
+        @type = type.to_s
         @conditionals = [options[:if]].flatten.compact
         @options = options
       end
@@ -38,7 +38,12 @@ module Brainstem
         options[:optional]
       end
 
+      # Please override in sub classes to compute value of field with the given arguments.
       def run_on(model, context, helper_instance = Object.new)
+        evaluate_value_on(model, context, helper_instance)
+      end
+
+      def evaluate_value_on(model, context, helper_instance = Object.new)
         if options[:lookup]
           run_on_with_lookup(model, context, helper_instance)
         elsif options[:dynamic]
@@ -53,6 +58,15 @@ module Brainstem
         end
       end
 
+      def presentable?(model, context)
+        optioned?(context[:optional_fields]) && conditionals_match?(
+          model,
+          context[:conditionals],
+          context[:helper_instance],
+          context[:conditional_cache]
+        )
+      end
+
       def conditionals_match?(model, presenter_conditionals, helper_instance = Object.new, conditional_cache = { model: {}, request: {} })
         return true unless conditional?
 

data/lib/brainstem/dsl/fields_block.rb

@@ -6,18 +6,36 @@ module Brainstem
           configuration[name] = DSL::Field.new(name, type, smart_merge(block_options, format_options(options)))
         end
 
-        def fields(name, &block)
-          descend FieldsBlock, configuration.nest!(name), &block
+        def fields(name, type = :hash, options = {}, &block)
+          nested_field = DSL::BlockField.for(name, type, smart_merge(block_options, format_options(options)), configuration[name])
+          configuration[name] = nested_field
+
+          descend self.class, nested_field.configuration, merge_parent_options(block_options, options), &block
         end
 
         private
 
+        NON_INHERITABLE_FIELD_OPTIONS = [:dynamic, :via, :lookup, :lookup_fetch, :info, :type, :item_type]
+        private_constant :NON_INHERITABLE_FIELD_OPTIONS
+
+        def merge_parent_options(block_options, parent_options)
+          inheritable_options = parent_options.except(*NON_INHERITABLE_FIELD_OPTIONS)
+          inheritable_options[:use_parent_value] = true unless inheritable_options.has_key?(:use_parent_value)
+
+          block_options.deep_dup.merge(inheritable_options)
+        end
+
         def smart_merge(block_options, options)
           if_clause = ([block_options[:if]] + [options[:if]]).flatten(2).compact.uniq
           block_options.merge(options).tap do |opts|
             opts.merge!(if: if_clause) if if_clause.present?
           end
         end
+
+        def format_options(options)
+          options[:item_type] = options[:item_type].to_s if options.has_key?(:item_type)
+          super
+        end
       end
     end
   end

data/lib/brainstem/dsl/hash_block_field.rb

@@ -0,0 +1,30 @@
+require 'brainstem/dsl/configuration'
+require 'brainstem/dsl/block_field'
+
+module Brainstem
+  module DSL
+    class HashBlockField < BlockField
+      def run_on(model, context, helper_instance = Object.new)
+        evaluated_model = nil
+        evaluated_model = evaluate_value_on(model, context, helper_instance) if executable?
+
+        result = {}
+        configuration.each do |field_name, field|
+          next unless field.presentable?(model, context)
+
+          model_for_field = (executable? && use_parent_value?(field)) ? evaluated_model : model
+          result[field_name] = field.run_on(model_for_field, context, context[:helper_instance]) if model_for_field
+        end
+
+        result
+      end
+
+      def executable?
+        (options.keys & EXECUTABLE_OPTIONS).present?
+      end
+
+      EXECUTABLE_OPTIONS = [:dynamic, :via, :lookup]
+      private_constant :EXECUTABLE_OPTIONS
+    end
+  end
+end

data/lib/brainstem/presenter.rb

@@ -308,15 +308,19 @@ module Brainstem
     def present_fields(model, context, fields, result = {})
       fields.each do |name, field|
         case field
-          when DSL::Field
-            if field.conditionals_match?(model, context[:conditionals], context[:helper_instance], context[:conditional_cache]) && field.optioned?(context[:optional_fields])
+          when DSL::HashBlockField
+            next if field.executable? && !field.presentable?(model, context)
+
+            # This preserves backwards compatibility
+            # In the case of a hash field, the individual attributes will call presentable
+            # If none of the individual attributes are presentable we will receive an empty hash
+            result[name] = field.run_on(model, context, context[:helper_instance])
+          when DSL::ArrayBlockField, DSL::Field
+            if field.presentable?(model, context)
               result[name] = field.run_on(model, context, context[:helper_instance])
             end
-          when DSL::Configuration
-            result[name] ||= {}
-            present_fields(model, context, field, result[name])
           else
-            raise "Unknown Brianstem Field type encountered: #{field}"
+            raise "Unknown Brainstem Field type encountered: #{field}"
         end
       end
       result

data/lib/brainstem/presenter_validator.rb

@@ -33,15 +33,17 @@ module Brainstem
     end
 
     def fields_exist(fields = presenter_class.configuration[:fields])
-      fields.each do |name, field_or_fields|
-        case field_or_fields
+      fields.each do |name, field|
+        case field
+          when DSL::HashBlockField
+            fields_exist(field) if presenter_class.presents.any? { !field.executable? }
           when DSL::Field
-            method_name = field_or_fields.method_name
+            method_name = field.method_name
             if method_name && presenter_class.presents.any? { |klass| !klass.new.respond_to?(method_name) }
               errors.add(:fields, "'#{name}' is not valid because not all presented classes respond to '#{method_name}'")
             end
-          when DSL::Configuration
-            fields_exist(field_or_fields)
+          else
+            errors.add(:fields, "'#{name}' is an unknown Brainstem field type")
         end
       end
     end
@@ -61,16 +63,23 @@ module Brainstem
     end
 
     def conditionals_exist(fields = presenter_class.configuration[:fields])
-      fields.each do |name, field_or_fields|
-        case field_or_fields
+      fields.each do |name, field|
+        case field
+          when DSL::HashBlockField
+            if field.options[:if].present?
+              if Array.wrap(field.options[:if]).any? { |conditional| presenter_class.configuration[:conditionals][conditional].nil? }
+                errors.add(:fields, "'#{name}' is not valid because one or more of the specified conditionals does not exist")
+              end
+            end
+            conditionals_exist(field) if presenter_class.presents.any? { |klass| !field.executable? }
           when DSL::Field
-            if field_or_fields.options[:if].present?
-              if Array.wrap(field_or_fields.options[:if]).any? { |conditional| presenter_class.configuration[:conditionals][conditional].nil? }
+            if field.options[:if].present?
+              if Array.wrap(field.options[:if]).any? { |conditional| presenter_class.configuration[:conditionals][conditional].nil? }
                 errors.add(:fields, "'#{name}' is not valid because one or more of the specified conditionals does not exist")
               end
             end
-          when DSL::Configuration
-            conditionals_exist(field_or_fields)
+          else
+            errors.add(:fields, "'#{name}' is an unknown Brainstem field type")
         end
       end
     end

data/lib/brainstem/version.rb

@@ -1,3 +1,3 @@
 module Brainstem
-  VERSION = "1.1.1"
+  VERSION = "1.3.0"
 end

data/spec/brainstem/api_docs/endpoint_spec.rb

@@ -143,65 +143,398 @@ module Brainstem
         end
 
 
-        describe "#root_param_keys" do
-          let(:nested_param)      { { title: { nodoc: nodoc, root: :sprocket } } }
-          let(:proc_nested_param) { { title: { nodoc: nodoc, root: Proc.new { |klass| klass.brainstem_model_name } } } }
-          let(:root_param)        { { title: { nodoc: nodoc } } }
-          let(:default_config)    { { valid_params: which_param } }
+        describe "#params_configuration_tree" do
+          let(:default_config) { { valid_params: which_param } }
 
           context "non-nested params" do
+            let(:root_param)  { { Proc.new { 'title' } => { nodoc: nodoc, type: 'string' } } }
             let(:which_param) { root_param }
 
             context "when nodoc" do
               let(:nodoc) { true }
 
               it "rejects the key" do
-                expect(subject.root_param_keys).to be_empty
+                expect(subject.params_configuration_tree).to be_empty
               end
             end
 
             context "when not nodoc" do
+              let(:nodoc) { false }
+
               it "lists it as a root param" do
-                expect(subject.root_param_keys).to have_key(:title)
+                expect(subject.params_configuration_tree).to eq(
+                  {
+                    title: {
+                      _config: { nodoc: nodoc, type: 'string' }
+                    }
+                  }.with_indifferent_access
+                )
+              end
+
+              context "when param has an item" do
+                let(:which_param) { { only: { nodoc: nodoc, type: 'array', item: 'integer' } } }
+
+                it "lists it as a root param" do
+                  expect(subject.params_configuration_tree).to eq(
+                    {
+                      only: {
+                        _config: { nodoc: nodoc, type: 'array', item: 'integer' }
+                      }
+                    }.with_indifferent_access
+                  )
+                end
               end
             end
           end
 
-
           context "nested params" do
+            let(:root_proc) { Proc.new { 'sprocket' } }
+            let(:nested_param) {
+              { Proc.new { 'title' } => { nodoc: nodoc, type: 'string', root: root_proc, ancestors: [root_proc] } }
+            }
             let(:which_param) { nested_param }
 
             context "when nodoc" do
               let(:nodoc) { true }
 
               it "rejects the key" do
-                expect(subject.root_param_keys).to be_empty
+                expect(subject.params_configuration_tree).to be_empty
               end
             end
 
             context "when not nodoc" do
               it "lists it as a nested param" do
-                expect(subject.root_param_keys).to eq({ sprocket: [ :title ] })
+                expect(subject.params_configuration_tree).to eq(
+                  {
+                    sprocket: {
+                      _config: {
+                        type: 'hash',
+                      },
+                      title: {
+                        _config: {
+                          nodoc: nodoc,
+                          type: 'string'
+                        }
+                      }
+                    }
+                  }.with_indifferent_access
+                )
+              end
+
+              context "when nested param has an item" do
+                let(:which_param) {
+                  {
+                    Proc.new { 'ids' } => { nodoc: nodoc, type: 'array', item: 'integer', root: root_proc, ancestors: [root_proc] }
+                  }
+                }
+
+                it "lists it as a nested param" do
+                  expect(subject.params_configuration_tree).to eq(
+                    {
+                      sprocket: {
+                        _config: {
+                          type: 'hash'
+                        },
+                        ids: {
+                          _config: {
+                            nodoc: nodoc,
+                            type: 'array',
+                            item: 'integer'
+                          }
+                        }
+                      }
+                    }.with_indifferent_access
+                  )
+                end
               end
             end
           end
 
-
           context "proc nested params" do
-            let(:which_param) { proc_nested_param }
+            let!(:root_proc)        { Proc.new { |klass| klass.brainstem_model_name } }
+            let(:proc_nested_param) {
+              { Proc.new { 'title' } => { nodoc: nodoc, type: 'string', root: root_proc, ancestors: [root_proc] } }
+            }
+            let(:which_param)       { proc_nested_param }
 
             context "when nodoc" do
               let(:nodoc) { true }
 
               it "rejects the key" do
-                expect(subject.root_param_keys).to be_empty
+                expect(subject.params_configuration_tree).to be_empty
               end
             end
 
             context "when not nodoc" do
               it "evaluates the proc in the controller's context and lists it as a nested param" do
                 mock.proxy(const).brainstem_model_name
-                expect(subject.root_param_keys).to eq({ widget: [ :title ] })
+
+                result = subject.params_configuration_tree
+                expect(result.keys).to eq(%w(widget))
+
+                children_of_the_root = result[:widget].except(:_config)
+                expect(children_of_the_root.keys).to eq(%w(title))
+
+                title_param = children_of_the_root[:title][:_config]
+                expect(title_param.keys).to eq(%w(nodoc type))
+                expect(title_param[:nodoc]).to eq(nodoc)
+                expect(title_param[:type]).to eq('string')
+              end
+            end
+          end
+
+          context "multi nested params" do
+            let(:project_proc)   { Proc.new { 'project' } }
+            let(:id_proc)        { Proc.new { 'id' } }
+            let(:task_proc)      { Proc.new { 'task' } }
+            let(:title_proc)     { Proc.new { 'title' } }
+            let(:checklist_proc) { Proc.new { 'checklist' } }
+            let(:name_proc)      { Proc.new { 'name' } }
+
+            context "has a root & ancestors" do
+              let(:which_param) {
+                {
+                  id_proc => {
+                    type: 'integer'
+                  },
+                  task_proc => {
+                    type: 'hash',
+                    root: project_proc,
+                    ancestors: [project_proc]
+                  },
+                  title_proc => {
+                    type: 'string',
+                    ancestors: [project_proc, task_proc]
+                  },
+                  checklist_proc => {
+                    type: 'array',
+                    item: 'hash',
+                    ancestors: [project_proc, task_proc]
+                  },
+                  name_proc => {
+                    type: 'string',
+                    ancestors: [project_proc, task_proc, checklist_proc]
+                  }
+                }
+              }
+
+              context "when a leaf param has no doc" do
+                before do
+                  which_param[name_proc][:nodoc] = true
+                end
+
+                it "rejects the key" do
+                  expect(subject.params_configuration_tree).to eq(
+                    {
+                      id: {
+                        _config: {
+                          type: 'integer',
+                        }
+                      },
+                      project: {
+                        _config: {
+                          type: 'hash',
+                        },
+                        task: {
+                          _config: {
+                            type: 'hash',
+                          },
+                          title: {
+                            _config: {
+                              type: 'string'
+                            }
+                          },
+                          checklist: {
+                            _config: {
+                              type: 'array',
+                              item: 'hash',
+                            }
+                          },
+                        },
+                      },
+                    }.with_indifferent_access
+                  )
+                end
+              end
+
+              context "when nodoc on a parent param" do
+                before do
+                  which_param[checklist_proc][:nodoc] = true
+                  which_param[name_proc][:nodoc] = true # This will be inherited from the parent when the param is defined.
+                end
+
+                it "rejects the parent key and its children" do
+                  expect(subject.params_configuration_tree).to eq(
+                    {
+                      id: {
+                        _config: {
+                          type: 'integer'
+                        }
+                      },
+                      project: {
+                        _config: {
+                          type: 'hash'
+                        },
+                        task: {
+                          _config: {
+                            type: 'hash',
+                          },
+                          title: {
+                            _config: {
+                              type: 'string'
+                            }
+                          },
+                        },
+                      },
+                    }.with_indifferent_access
+                  )
+                end
+              end
+
+              context "when not nodoc" do
+                it "evaluates the proc in the controller's context and lists it as a nested param" do
+                  expect(subject.params_configuration_tree).to eq(
+                    {
+                      id: {
+                        _config: {
+                          type: 'integer'
+                        }
+                      },
+                      project: {
+                        _config: {
+                          type: 'hash',
+                        },
+                        task: {
+                          _config: {
+                            type: 'hash',
+                          },
+                          title: {
+                            _config: {
+                              type: 'string'
+                            }
+                          },
+                          checklist: {
+                            _config: {
+                              type: 'array',
+                              item: 'hash'
+                            },
+                            name: {
+                              _config: {
+                                type: 'string'
+                              }
+                            },
+                          },
+                        },
+                      },
+                    }.with_indifferent_access
+                  )
+                end
+              end
+            end
+
+            context "has only ancestors" do
+              let(:which_param) {
+                {
+                  task_proc => {
+                    type: 'hash',
+                  },
+                  title_proc => {
+                    type: 'string',
+                    ancestors: [task_proc]
+                  },
+                  checklist_proc => {
+                    type: 'array',
+                    item: 'hash',
+                    ancestors: [task_proc]
+                  },
+                  name_proc => {
+                    type: 'string',
+                    ancestors: [task_proc, checklist_proc]
+                  }
+                }
+              }
+
+              context "when a leaf param has no doc" do
+                before do
+                  which_param[name_proc][:nodoc] = true
+                end
+
+                it "rejects the key" do
+                  expect(subject.params_configuration_tree).to eq(
+                    {
+                      task: {
+                        _config: {
+                          type: 'hash'
+                        },
+                        title: {
+                          _config: {
+                            type: 'string'
+                          }
+                        },
+                        checklist: {
+                          _config: {
+                            type: 'array',
+                            item: 'hash'
+                          }
+                        },
+                      },
+                    }.with_indifferent_access
+                  )
+                end
+              end
+
+              context "when parent param has nodoc" do
+                before do
+                  which_param[checklist_proc][:nodoc] = true
+                  which_param[name_proc][:nodoc] = true # This will be inherited from the parent when the param is defined.
+                end
+
+                it "rejects the parent key and its children" do
+                  expect(subject.params_configuration_tree).to eq(
+                    {
+                      task: {
+                        _config: {
+                          type: 'hash'
+                        },
+                        title: {
+                          _config: {
+                            type: 'string'
+                          }
+                        }
+                      }
+                    }.with_indifferent_access
+                  )
+                end
+              end
+
+              context "when not nodoc" do
+                it "evaluates the proc in the controller's context and lists it as a nested param" do
+                  expect(subject.params_configuration_tree).to eq(
+                    {
+                      task: {
+                        _config: {
+                          type: 'hash'
+                        },
+                        title: {
+                          _config: {
+                            type: 'string'
+                          }
+                        },
+                        checklist: {
+                          _config: {
+                            type: 'array',
+                            item: 'hash',
+                          },
+                          name: {
+                            _config: {
+                              type: 'string',
+                            }
+                          },
+                        },
+                      },
+                    }.with_indifferent_access
+                  )
+                end
               end
             end
           end