brainstem 1.0.0.pre.1 → 1.0.0

data/spec/brainstem/concerns/controller_param_management_spec.rb

@@ -2,41 +2,61 @@ require 'spec_helper'
 require 'brainstem/concerns/controller_param_management'
 
 describe Brainstem::Concerns::ControllerParamManagement do
-  class TasksController
-    include Brainstem::Concerns::ControllerParamManagement
+  subject do
+    Class.new do
+      include Brainstem::Concerns::ControllerParamManagement
 
-    def controller_name
-      'tasks'
+      def controller_name
+        self.class.controller_name
+      end
+
+      def self.controller_name
+        'tasks'
+      end
     end
   end
 
   before do
-    TasksController.brainstem_model_name = nil
-    TasksController.brainstem_plural_model_name = nil
+    subject.brainstem_model_name = nil
+    subject.brainstem_plural_model_name = nil
   end
 
   describe '.brainstem_model_name' do
     it 'is settable on the controller' do
-      TasksController.brainstem_model_name = 'thingy'
-      expect(TasksController.new.brainstem_model_name).to eq 'thingy'
+      subject.brainstem_model_name = 'thingy'
+      expect(subject.new.brainstem_model_name).to eq 'thingy'
     end
 
     it 'has good defaults' do
-      expect(TasksController.new.brainstem_model_name).to eq 'task'
-      expect(TasksController.new.brainstem_plural_model_name).to eq 'tasks'
+      expect(subject.new.brainstem_model_name).to eq 'task'
+      expect(subject.new.brainstem_plural_model_name).to eq 'tasks'
+    end
+
+    it "has good defaults on the class level" do
+      expect(subject.brainstem_model_name).to eq 'task'
+      expect(subject.brainstem_plural_model_name).to eq 'tasks'
     end
   end
 
   describe '.brainstem_plural_model_name' do
     it 'is infered from the singular model name' do
-      TasksController.brainstem_model_name = 'thingy'
-      expect(TasksController.new.brainstem_plural_model_name).to eq 'thingies'
+      subject.brainstem_model_name = 'thingy'
+      expect(subject.brainstem_plural_model_name).to eq 'thingies'
+      expect(subject.new.brainstem_plural_model_name).to eq 'thingies'
     end
 
     it 'can be overridden' do
-      TasksController.brainstem_model_name = 'thingy'
-      TasksController.brainstem_plural_model_name = 'thingzees'
-      expect(TasksController.new.brainstem_plural_model_name).to eq 'thingzees'
+      subject.brainstem_model_name = 'thingy'
+      subject.brainstem_plural_model_name = 'thingzees'
+      expect(subject.brainstem_plural_model_name).to eq 'thingzees'
+      expect(subject.new.brainstem_plural_model_name).to eq 'thingzees'
+    end
+  end
+
+  describe '.brainstem_model_class' do
+    it "classifies and constantizes the brainstem_model_name" do
+      subject.brainstem_model_name = "object"
+      expect(subject.brainstem_model_class).to eq Object
     end
   end
-end
+end

data/spec/brainstem/concerns/formattable_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'brainstem/concerns/formattable'
+
+module Brainstem
+  module Concerns
+    describe Formattable do
+      let(:formattable_class) do
+        Class.new do
+          include Brainstem::Concerns::Formattable
+        end
+      end
+
+      let(:subject) { formattable_class.new }
+
+      describe "#formatter_type" do
+        it "returns the class name underscored and symbolized" do
+          stub(formattable_class).to_s { "MyClass" }
+          expect(subject.formatter_type).to eq :my_class
+        end
+
+        it "returns only the last segment of a class name" do
+          stub(formattable_class).to_s { "Namespaced::MyClass" }
+          expect(subject.formatter_type).to eq :my_class
+
+        end
+      end
+
+    end
+  end
+end

data/spec/brainstem/concerns/inheritable_configuration_spec.rb

@@ -33,22 +33,51 @@ describe Brainstem::Concerns::InheritableConfiguration do
       expect(parent_class.configuration['ten']).to be_nil
     end
 
-    describe '#keys' do
-      it "returns the union of this class's keys with any parent keys" do
+    it "does not inherit nonheritable keys" do
+      expect(parent_class.configuration['nonheritable']).to be_nil
+      parent_class.configuration.nonheritable! :nonheritable
+      parent_class.configuration['nonheritable'] = "parent"
+      expect(parent_class.configuration['nonheritable']).to eq "parent"
+
+      subclass = Class.new(parent_class)
+      expect(subclass.configuration['nonheritable']).to be_nil
+
+      subclass.configuration['nonheritable'] = "child"
+
+      subsubclass = Class.new(subclass)
+      expect(subsubclass.configuration['nonheritable']).to be_nil
+    end
+
+    describe '#keys and #to_h' do
+      let(:subclass) { Class.new(parent_class) }
+      let(:subsubclass) { Class.new(subclass) }
+
+      before do
         parent_class.configuration['1'] = :a
         parent_class.configuration['2'] = :b
 
-        subclass = Class.new(parent_class)
         subclass.configuration['2'] = :c
         subclass.configuration['3'] = :d
 
-        subsubclass = Class.new(subclass)
         subsubclass.configuration['3'] = :e
         subsubclass.configuration['4'] = :f
+      end
 
+      it "returns the union of this class's keys with any parent keys" do
         expect(parent_class.configuration.keys).to eq ['1', '2']
+        expect(parent_class.configuration.to_h).to eq({ '1' => :a, '2' => :b })
         expect(subclass.configuration.keys).to eq ['1', '2', '3']
+        expect(subclass.configuration.to_h).to eq({ '1' => :a, '2' => :c, '3' => :d })
         expect(subsubclass.configuration.keys).to eq ['1', '2', '3', '4']
+        expect(subsubclass.configuration.to_h).to eq({ '1' => :a, '2' => :c, '3' => :e, '4' => :f })
+
+        # it doesn't mutate storage
+        subclass.configuration.to_h['1'] = :new
+        subclass.configuration.to_h['2'] = :new
+        expect(subclass.configuration['1']).to eq :a
+        expect(subclass.configuration['2']).to eq :c
+        expect(parent_class.configuration['1']).to eq :a
+        expect(parent_class.configuration['2']).to eq :b
 
         expect(parent_class.configuration['1']).to eq :a
         expect(parent_class.configuration['2']).to eq :b
@@ -62,6 +91,64 @@ describe Brainstem::Concerns::InheritableConfiguration do
         expect(subsubclass.configuration['3']).to eq :e
         expect(subsubclass.configuration['4']).to eq :f
       end
+
+      it "does not return nonheritable keys in the parent" do
+        parent_class.configuration.nonheritable! :nonheritable
+        parent_class.configuration['nonheritable'] = "why yes, I am nonheritable"
+        expect(subclass.configuration.keys).not_to include 'nonheritable'
+
+        expect(subclass.configuration.to_h.keys).not_to include 'nonheritable'
+        expect(subclass.configuration.has_key?('nonheritable')).to eq false
+      end
+    end
+
+    describe "#fetch" do
+      let(:config)    { parent_class.configuration }
+      let(:my_block)  { Proc.new { nil } }
+
+      before do
+        parent_class.configuration["my_key"] = "yep"
+      end
+
+      context "when key is found" do
+        it "returns the key" do
+          expect(config.fetch("my_key")).to eq "yep"
+        end
+      end
+
+      context "when key is not found" do
+        context "when default or block not given" do
+          it "raises a KeyError exception" do
+            expect { config.fetch("fake_key") }.to raise_exception KeyError
+          end
+        end
+
+        context "when block given" do
+          before do
+            mock(my_block).call { "hey" }
+          end
+
+          it "evals and returns the block" do
+            expect(config.fetch("fake_key", &my_block)).to eq "hey"
+          end
+        end
+
+        context "when default given" do
+          it "returns the default" do
+            expect(config.fetch("fake_key", "hey")).to eq "hey"
+          end
+        end
+
+        context "when default and block given" do
+          before do
+            mock(my_block).call("hey") { "sup" }
+          end
+
+          it "evals and returns the block, passing it the default" do
+            expect(config.fetch("fake_key", "hey", &my_block)).to eq "sup"
+          end
+        end
+      end
     end
 
     describe '#nest!' do
@@ -199,6 +286,19 @@ describe Brainstem::Concerns::InheritableConfiguration do
         expect(lambda { subclass.configuration['list'] = 2 }).to raise_error('You cannot override an inheritable array once set')
       end
     end
+
+    describe "#nonheritable!" do
+      it "adds the key to the nonheritable attributes list" do
+        parent_class.configuration.nonheritable! :nonheritable
+        expect(parent_class.configuration.nonheritable_keys.to_a).to eq ["nonheritable"]
+      end
+
+      it "dedupes" do
+        parent_class.configuration.nonheritable! :nonheritable
+        parent_class.configuration.nonheritable! :nonheritable
+        expect(parent_class.configuration.nonheritable_keys.to_a).to eq ["nonheritable"]
+      end
+    end
   end
 
   describe '#configuration' do

data/spec/brainstem/concerns/optional_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'brainstem/concerns/optional'
+
+describe Brainstem::Concerns::Optional do
+  let(:optional_class) do
+    Class.new do
+      include Brainstem::Concerns::Optional
+    end
+  end
+
+  context "when options are not passed" do
+    it "raises no error" do
+      expect { optional_class.new }.not_to raise_error
+    end
+  end
+
+  context "when options are passed" do
+    context "when option is whitelisted" do
+      before do
+        stub.any_instance_of(optional_class).valid_options { [:thing] }
+      end
+
+      context "when an accessor exists" do
+        before do
+          mock.any_instance_of(optional_class).thing=("blah")
+        end
+
+        it "passes the option to the accessor" do
+          optional_class.new(thing: "blah")
+        end
+      end
+
+      context "when no accessor exists" do
+        it "raises an error" do
+          expect { optional_class.new(thing: "blah") }.to \
+            raise_error NoMethodError
+        end
+      end
+    end
+
+    context "when option is not whitelisted" do
+      it "does not send the symbol" do
+        dont_allow.any_instance_of(optional_class).other_thing
+        expect { optional_class.new(other_thing: "nope") }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/brainstem/concerns/presenter_dsl_spec.rb

@@ -5,11 +5,17 @@ require 'brainstem/concerns/presenter_dsl'
 #
 # brainstem_key :projects
 #
+# title "Project"
+# description "It does stuff"
+#
+#
 # conditionals do
-#   model   :title_is_hello, lambda { workspace.title == 'hello' }, 'visible when the title is hello'
-#   request :user_is_bob, lambda { current_user.username == 'bob' }, 'visible only to bob'
+#   model   :title_is_hello, lambda { workspace.title == 'hello' }, info: 'visible when the title is hello'
+#   request :user_is_bob, lambda { current_user.username == 'bob' }, info: 'visible only to bob'
 # end
 #
+# sort_order :created_at, ".created_at"
+#
 # fields do
 #   field :title, :string
 #   field :description, :string
@@ -20,7 +26,8 @@ require 'brainstem/concerns/presenter_dsl'
 #         if: [:user_is_bob, :title_is_hello]
 #
 #   with_options if: :user_is_bob do
-#     field :bob_title, :string, 'another name for the title, only for Bob',
+#     field :bob_title, :string,
+#           info: 'another name for the title, only for Bob',
 #           via: :title
 #   end
 #   fields :nested_permissions do
@@ -30,10 +37,13 @@ require 'brainstem/concerns/presenter_dsl'
 # end
 #
 # associations do
-#   association :tasks, Task, 'The Tasks in this Workspace',
+#   association :tasks, Task,
+#               info: 'The Tasks in this Workspace',
 #               restrict_to_only: true
-#   association :lead_user, User, 'The user who runs this Workspace'
-#   association :subtasks, Task, 'Only Tasks in this Workspace that are subtasks',
+#   association :lead_user, User,
+#               info: 'The user who runs this Workspace'
+#   association :subtasks, Task,
+#               info: 'Only Tasks in this Workspace that are subtasks',
 #               dynamic: lambda { |workspace| workspace.tasks.where('parent_id IS NOT NULL') }
 #   association :something, :polymorphic
 # end
@@ -62,11 +72,99 @@ describe Brainstem::Concerns::PresenterDSL do
     end
   end
 
+  describe 'the title method' do
+    it "is stored in the configuration" do
+      presenter_class.title "Project"
+      expect(presenter_class.configuration[:title][:info]).to eq "Project"
+    end
+
+    it "stores options" do
+      presenter_class.title "Project", nodoc: true
+      expect(presenter_class.configuration[:title][:nodoc]).to be true
+    end
+
+    it "is not inherited" do
+      presenter_class.title "Project"
+      subclass = Class.new(presenter_class)
+      expect(subclass.configuration).not_to have_key :title
+    end
+  end
+
+  describe 'the description method' do
+    it "is stored in the configuration" do
+      presenter_class.description "desc 123"
+      expect(presenter_class.configuration[:description][:info]).to eq "desc 123"
+    end
+
+    it "stores options" do
+      presenter_class.description "Project", nodoc: true
+      expect(presenter_class.configuration[:description][:nodoc]).to be true
+    end
+
+    it "is not inherited" do
+      presenter_class.description "desc 123"
+      subclass = Class.new(presenter_class)
+      expect(subclass.configuration).not_to have_key :description
+    end
+  end
+
+  describe 'the nodoc! method' do
+    before do
+      presenter_class.nodoc!
+    end
+
+    it "is stored in the configuration" do
+      expect(presenter_class.configuration[:nodoc]).to be true
+    end
+  end
+
+
+  # sort_order :created_at, ".created_at"
+  describe 'the sort_order block' do
+    let(:value)   { "widgets.created_at" }
+    let(:orders)  { presenter_class.configuration[:sort_orders] }
+
+    context "when passed value is a column" do
+      before do
+        presenter_class.sort_order :created_at, value, info: "sorts by creation time"
+      end
+
+      it "is stored in the configuration by name" do
+        expect(orders).to have_key "created_at"
+      end
+
+      it "stores the value passed" do
+        expect(orders[:created_at][:value]).to eq "widgets.created_at"
+      end
+
+      it "stores the documentation" do
+        expect(orders[:created_at][:info]).to eq "sorts by creation time"
+      end
+    end
+
+    context "when passed value is a block" do
+      let(:value) { Proc.new { nil } }
+
+      before do
+        presenter_class.sort_order :created_at, info: "sorts by creation time", &value
+      end
+
+      it "stores the value passed" do
+        expect(orders[:created_at][:value]).to eq value
+      end
+
+      it "stores the documentation" do
+        expect(orders[:created_at][:info]).to eq "sorts by creation time"
+      end
+    end
+  end
+
+
   describe 'the conditional block' do
     before do
       presenter_class.conditionals do
-        model      :title_is_hello, lambda { |workspace| workspace.title == 'hello' }, 'visible when the title is hello'
-        request    :user_is_bob, lambda { current_user == 'bob' }, 'visible only to bob'
+        model      :title_is_hello, lambda { |workspace| workspace.title == 'hello' }, info: 'visible when the title is hello', nodoc: true
+        request    :user_is_bob, lambda { current_user == 'bob' }, info: 'visible only to bob'
       end
     end
 
@@ -75,6 +173,7 @@ describe Brainstem::Concerns::PresenterDSL do
       expect(presenter_class.configuration[:conditionals][:title_is_hello].action).to be_present
       expect(presenter_class.configuration[:conditionals][:title_is_hello].type).to eq :model
       expect(presenter_class.configuration[:conditionals][:title_is_hello].description).to eq 'visible when the title is hello'
+      expect(presenter_class.configuration[:conditionals][:title_is_hello].options).to eq({ nodoc: true, info: 'visible when the title is hello' })
       expect(presenter_class.configuration[:conditionals][:user_is_bob].action).to be_present
       expect(presenter_class.configuration[:conditionals][:user_is_bob].type).to eq :request
       expect(presenter_class.configuration[:conditionals][:user_is_bob].description).to eq 'visible only to bob'
@@ -83,13 +182,30 @@ describe Brainstem::Concerns::PresenterDSL do
     it 'is inherited and overridable' do
       subclass = Class.new(presenter_class)
       subclass.conditionals do
-        model :silly_conditional, lambda { rand > 0.5 }, 'visible half the time'
-        model :title_is_hello, lambda { |workspace| workspace.title == 'HELLO' }, 'visible when the title is hello (in all caps)'
+        model :silly_conditional, lambda { rand > 0.5 }, info: 'visible half the time'
+        model :title_is_hello, lambda { |workspace| workspace.title == 'HELLO' }, info: 'visible when the title is hello (in all caps)'
       end
       expect(presenter_class.configuration[:conditionals].keys).to eq %w[title_is_hello user_is_bob]
       expect(subclass.configuration[:conditionals].keys).to eq %w[title_is_hello user_is_bob silly_conditional]
       expect(presenter_class.configuration[:conditionals][:title_is_hello].description).to eq "visible when the title is hello"
+      expect(presenter_class.configuration[:conditionals][:title_is_hello].options).to eq({ nodoc: true, info: "visible when the title is hello" })
       expect(subclass.configuration[:conditionals][:title_is_hello].description).to eq "visible when the title is hello (in all caps)"
+      expect(subclass.configuration[:conditionals][:title_is_hello].options).to eq({ info: "visible when the title is hello (in all caps)" })
+    end
+
+    context 'when options hash is a hash with indifferent access' do
+      before do
+        presenter_class.conditionals do
+          request :user_is_jane, lambda { current_user == 'jane' }, { info: 'visible only to Jane' }.with_indifferent_access
+        end
+      end
+
+      it 'is stored in the configuration correctly' do
+        expect(presenter_class.configuration[:conditionals].keys).to include('user_is_jane')
+        expect(presenter_class.configuration[:conditionals][:user_is_jane].action).to be_present
+        expect(presenter_class.configuration[:conditionals][:user_is_jane].type).to eq :request
+        expect(presenter_class.configuration[:conditionals][:user_is_jane].description).to eq 'visible only to Jane'
+      end
     end
   end
 
@@ -103,7 +219,8 @@ describe Brainstem::Concerns::PresenterDSL do
               if: [:user_is_bob, :title_is_hello]
 
         with_options if: :user_is_bob do
-          field :bob_title, :string, 'another name for the title, only for Bob',
+          field :bob_title, :string,
+                info: 'another name for the title, only for Bob',
                 via: :title
         end
         fields :nested_permissions do
@@ -125,7 +242,11 @@ describe Brainstem::Concerns::PresenterDSL do
       expect(presenter_class.configuration[:fields][:secret].options).to eq({ via: :secret_info, if: [:user_is_bob, :title_is_hello] })
       expect(presenter_class.configuration[:fields][:bob_title].type).to eq :string
       expect(presenter_class.configuration[:fields][:bob_title].description).to eq 'another name for the title, only for Bob'
-      expect(presenter_class.configuration[:fields][:bob_title].options).to eq({ via: :title, if: [:user_is_bob] })
+      expect(presenter_class.configuration[:fields][:bob_title].options).to eq(
+        via: :title,
+        if: [:user_is_bob],
+        info: 'another name for the title, only for Bob'
+      )
     end
 
     it 'handles nesting' do
@@ -139,7 +260,7 @@ describe Brainstem::Concerns::PresenterDSL do
       subclass.fields do
         field :title, :string
         with_options if: [:some_condition, :some_other_condition] do
-          field :updated_at, :datetime, 'this time I have a description and condition'
+          field :updated_at, :datetime, info: 'this time I have a description and condition'
         end
       end
       expect(presenter_class.configuration[:fields].keys).to match_array %w[updated_at dynamic_title secret bob_title nested_permissions]
@@ -147,24 +268,32 @@ describe Brainstem::Concerns::PresenterDSL do
       expect(presenter_class.configuration[:fields][:updated_at].description).to be_nil
       expect(presenter_class.configuration[:fields][:updated_at].options).to eq({})
       expect(subclass.configuration[:fields][:updated_at].description).to eq 'this time I have a description and condition'
-      expect(subclass.configuration[:fields][:updated_at].options).to eq({ if: [:some_condition, :some_other_condition] })
+      expect(subclass.configuration[:fields][:updated_at].options).to eq(
+        if: [:some_condition, :some_other_condition],
+        info: 'this time I have a description and condition'
+      )
     end
 
     it 'any :if options are combined and inherited using with_options' do
       presenter_class.fields do
         with_options if: :user_is_bob do
-          field :bob_title, :string, 'another name for the title, only for Bob',
-                via: :title, if: :another_condition
-          field :bob_title2, :string, 'another name for the title, only for Bob',
+          field :bob_title, :string,
+                info: 'another name for the title, only for Bob',
+                via: :title,
+                if: :another_condition
+          field :bob_title2, :string,
+                info: 'another name for the title, only for Bob',
                 via: :title, if: :another_condition
         end
       end
       subclass = Class.new(presenter_class)
       subclass.fields do
         with_options if: [:user_is_bob, :more_specific] do
-          field :bob_title, :string, 'another name for the title, only for Bob',
+          field :bob_title, :string,
+                info: 'another name for the title, only for Bob',
                 via: :title, if: [:another_condition]
-          field :bob_title2, :string, 'another name for the title, only for Bob',
+          field :bob_title2, :string,
+                info: 'another name for the title, only for Bob',
                 via: :title
         end
       end
@@ -206,14 +335,30 @@ describe Brainstem::Concerns::PresenterDSL do
       expect(subclass.configuration[:fields][:nested_permissions][:deeper][:something]).to be_present
       expect(subclass.configuration[:fields][:new_nested_permissions]).to be_present
     end
+
+    context "when options is a hash with indifferent access" do
+      before do
+        presenter_class.fields do
+          field :synced_at, :datetime, { info: "Last time the object was synced" }.with_indifferent_access
+        end
+      end
+
+      it "is stored in the configuration correctly" do
+        expect(presenter_class.configuration[:fields].keys).to include('synced_at')
+        expect(presenter_class.configuration[:fields][:synced_at].type).to eq :datetime
+        expect(presenter_class.configuration[:fields][:synced_at].description).to eq 'Last time the object was synced'
+      end
+    end
   end
 
   describe 'the associations block' do
     before do
       presenter_class.associations do
-        association :tasks, Task, 'The Tasks in this Workspace',
+        association :tasks, Task,
+                    info: 'The Tasks in this Workspace',
                     restrict_to_only: true
-        association :subtasks, Task, 'Only Tasks in this Workspace that are subtasks',
+        association :subtasks, Task,
+                    info: 'Only Tasks in this Workspace that are subtasks',
                     dynamic: lambda { |workspace| workspace.tasks.where('parent_id IS NOT NULL') }
         association :something, :polymorphic
       end
@@ -223,10 +368,10 @@ describe Brainstem::Concerns::PresenterDSL do
       expect(presenter_class.configuration[:associations].keys).to match_array %w[tasks subtasks something]
       expect(presenter_class.configuration[:associations][:tasks].target_class).to eq Task
       expect(presenter_class.configuration[:associations][:tasks].description).to eq 'The Tasks in this Workspace'
-      expect(presenter_class.configuration[:associations][:tasks].options).to eq({ restrict_to_only: true })
+      expect(presenter_class.configuration[:associations][:tasks].options).to eq({ restrict_to_only: true, info: 'The Tasks in this Workspace' })
       expect(presenter_class.configuration[:associations][:subtasks].target_class).to eq Task
       expect(presenter_class.configuration[:associations][:subtasks].description).to eq 'Only Tasks in this Workspace that are subtasks'
-      expect(presenter_class.configuration[:associations][:subtasks].options.keys).to eq [:dynamic]
+      expect(presenter_class.configuration[:associations][:subtasks].options.keys).to match_array [:dynamic, :info]
       expect(presenter_class.configuration[:associations][:something].target_class).to eq :polymorphic
       expect(presenter_class.configuration[:associations][:something].description).to be_nil
     end
@@ -234,20 +379,37 @@ describe Brainstem::Concerns::PresenterDSL do
     it 'is inherited and overridable' do
       subclass = Class.new(presenter_class)
       subclass.associations do
-        association :tasks, Task, 'The Tasks in this Workspace'
-        association :lead_user, User, 'The user who runs this Workspace'
+        association :tasks, Task, info: 'The Tasks in this Workspace'
+        association :lead_user, User, info: 'The user who runs this Workspace'
       end
 
       expect(presenter_class.configuration[:associations].keys).to match_array %w[tasks subtasks something]
       expect(subclass.configuration[:associations].keys).to match_array %w[tasks subtasks lead_user something]
 
-      expect(presenter_class.configuration[:associations][:tasks].options).to eq({ restrict_to_only: true })
+      expect(presenter_class.configuration[:associations][:tasks].options).to eq({ restrict_to_only: true, info: 'The Tasks in this Workspace' })
       expect(presenter_class.configuration[:associations][:lead_user]).to be_nil
 
-      expect(subclass.configuration[:associations][:tasks].options).to eq({})
+      expect(subclass.configuration[:associations][:tasks].options).to eq({ info: 'The Tasks in this Workspace' })
       expect(subclass.configuration[:associations][:lead_user].target_class).to eq User
       expect(subclass.configuration[:associations][:lead_user].description).to eq 'The user who runs this Workspace'
     end
+
+    context "when options is a hash with indifferent access" do
+      before do
+        presenter_class.associations do
+          association :something_else, :polymorphic, { info: 'The other things in this Workspace', restrict_to_only: true }.with_indifferent_access
+        end
+      end
+
+      it "is stored in the configuration correctly" do
+        expect(presenter_class.configuration[:associations].keys).to include('something_else')
+        expect(presenter_class.configuration[:associations][:something_else].description).to eq 'The other things in this Workspace'
+        expect(presenter_class.configuration[:associations][:something_else].options).to eq(
+          info: 'The other things in this Workspace',
+          restrict_to_only: true
+        )
+      end
+    end
   end
 
   describe ".helper" do
@@ -373,16 +535,25 @@ describe Brainstem::Concerns::PresenterDSL do
   end
 
   describe ".filter" do
+    let(:foo) { presenter_class.configuration[:filters][:foo] }
+
     it "creates an entry in the filters configuration" do
-      presenter_class.filter(:foo, :default => true) { 1 }
-      expect(presenter_class.configuration[:filters][:foo][0]).to eq({"default" => true})
-      expect(presenter_class.configuration[:filters][:foo][1]).to be_a(Proc)
+      my_proc = Proc.new { 1 }
+      presenter_class.filter(:foo, :default => true, &my_proc)
+
+      expect(foo).to eq({ "default" => true, "value" => my_proc })
     end
 
     it "accepts names without blocks" do
       presenter_class.filter(:foo)
-      expect(presenter_class.configuration[:filters][:foo][1]).to be_nil
+      expect(foo[:value]).to be_nil
+    end
+
+    it "records the info option" do
+      presenter_class.filter(:foo, :info => "This is documented.")
+      expect(foo[:info]).to eq "This is documented."
     end
+
   end
 
   describe ".search" do