brainstem 1.1.1 → 1.3.0

data/spec/brainstem/dsl/field_spec.rb

@@ -52,14 +52,35 @@ describe Brainstem::DSL::Field do
   describe '#run_on' do
     let(:context) { { } }
 
+    it 'calls `evaluate_value_on`' do
+      mock(field).evaluate_value_on.with(model, context, anything)
+
+      field.run_on(model, context)
+    end
+
+    context 'when helper instance is specified' do
+      let(:helper_instance) { Object.new }
+
+      it 'calls `evaluate_value_on` with the given helper instance' do
+        mock(field).evaluate_value_on.with(model, context, helper_instance)
+
+        field.run_on(model, context, helper_instance)
+      end
+    end
+  end
+
+  describe '#evaluate_value_on' do
+    let(:context) { { } }
+    let(:helper_instance) { Object.new }
+
     context 'on :dynamic fields' do
       let(:options) { { dynamic: lambda { some_instance_method } } }
 
       it 'calls the :dynamic lambda in the context of the given instance' do
         do_not_allow(model).title
-        instance = Object.new
-        mock(instance).some_instance_method
-        field.run_on(model, context, instance)
+        mock(helper_instance).some_instance_method
+
+        field.evaluate_value_on(model, context, helper_instance)
       end
     end
 
@@ -79,22 +100,22 @@ describe Brainstem::DSL::Field do
       context 'The first model is ran' do
         it 'builds lookup cache and returns the value for the first model' do
           expect(context[:lookup][:fields][name.to_s]).to eq(nil)
-          instance = Object.new
-          mock(instance).some_instance_method
-          expect(field.run_on(first_model, context, instance)).to eq("Ben's Project")
+          mock(helper_instance).some_instance_method
+
+          expect(field.evaluate_value_on(first_model, context, helper_instance)).to eq("Ben's Project")
           expect(context[:lookup][:fields][name.to_s]).to eq({ first_model.id => "Ben's Project", second_model.id => "Nate's Project" })
         end
       end
 
       context 'The second model is ran after the first' do
         it 'returns the value from the lookup cache and does not run the lookup' do
-          instance = Object.new
-          mock(instance).some_instance_method
-          field.run_on(first_model, context, instance)
+          mock(helper_instance).some_instance_method
+
+          field.evaluate_value_on(first_model, context, helper_instance)
           expect(context[:lookup][:fields][name.to_s]).to eq({ first_model.id => "Ben's Project", second_model.id => "Nate's Project" })
 
-          mock(instance).some_instance_method.never
-          expect(field.run_on(second_model, context, instance)).to eq("Nate's Project")
+          mock(helper_instance).some_instance_method.never
+          expect(field.evaluate_value_on(second_model, context, helper_instance)).to eq("Nate's Project")
         end
       end
 
@@ -104,7 +125,7 @@ describe Brainstem::DSL::Field do
 
           it 'should raise error explaining the default lookup fetch relies on [] to access the model\'s value from the lookup' do
             expect {
-              field.run_on(first_model, context)
+              field.evaluate_value_on(first_model, context)
             }.to raise_error(StandardError, 'Brainstem expects the return result of the `lookup` to be a Hash since it must respond to [] in order to access the model\'s assocation(s). Default: lookup_fetch: lambda { |lookup, model| lookup[model.id] }`')
           end
         end
@@ -119,10 +140,10 @@ describe Brainstem::DSL::Field do
         }
 
         it 'does not use the dynamic lambda' do
-          instance = Object.new
-          mock(instance).dynamic_instance_method.never
-          mock(instance).lookup_instance_method
-          expect(field.run_on(first_model, context, instance)).to eq "Ben's Project"
+          mock(helper_instance).dynamic_instance_method.never
+          mock(helper_instance).lookup_instance_method
+
+          expect(field.evaluate_value_on(first_model, context, helper_instance)).to eq "Ben's Project"
         end
       end
 
@@ -137,9 +158,9 @@ describe Brainstem::DSL::Field do
         it 'returns the value from the lookup using the lookup_fetch lambda' do
           context[:lookup][:fields][name.to_s] = {}
           context[:lookup][:fields][name.to_s][first_model.id] = "Ben's stubbed out Project"
-          instance = Object.new
-          mock(instance).some_instance_method
-          expect(field.run_on(first_model, context, instance)).to eq("Ben's stubbed out Project")
+          mock(helper_instance).some_instance_method
+
+          expect(field.evaluate_value_on(first_model, context, helper_instance)).to eq("Ben's stubbed out Project")
         end
       end
     end
@@ -148,7 +169,52 @@ describe Brainstem::DSL::Field do
       it 'calls method_name on the model' do
         mock(model).foo
         mock(field).method_name { 'foo' }
-        field.run_on(model, context)
+
+        field.evaluate_value_on(model, context)
+      end
+    end
+  end
+
+  describe '#presentable?' do
+    let(:given_context) {
+      {
+        optional_fields: 'optional field',
+        conditionals: 'conditionals',
+        helper_instance: 'helper instance',
+        conditional_cache: 'conditional cache'
+      }
+    }
+    let(:optioned) { false }
+    let(:conditionals_match) { false }
+
+    before do
+      mock(field).optioned?.with(given_context[:optional_fields]) { optioned }
+      stub(field).conditionals_match?.with(
+        model,
+        given_context[:conditionals],
+        given_context[:helper_instance],
+        given_context[:conditional_cache]
+      ) { conditionals_match }
+    end
+
+    it 'calls `optioned?` by passing in the optional fields from the context' do
+      expect(field.presentable?(model, given_context)).to be_falsey
+    end
+
+    context 'when field is not optional' do
+      let(:optioned) { true }
+
+      it 'calls `conditionals_match?` with conditionals, helper instance and conditional cache from the context' do
+        expect(field.presentable?(model, given_context)).to be_falsey
+      end
+    end
+
+    context 'when field is not optional and conditionals match' do
+      let(:optioned) { true }
+      let(:conditionals_match) { true }
+
+      it 'returns true' do
+        expect(field.presentable?(model, given_context)).to be_truthy
       end
     end
   end

data/spec/brainstem/dsl/hash_block_field_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+require 'brainstem/dsl/hash_block_field'
+
+describe Brainstem::DSL::HashBlockField do
+  let(:name)         { :tasks }
+  let(:type)         { :hash }
+  let(:description)  { 'the title of this model' }
+  let(:options)      { { info: description } }
+  let(:nested_field) { Brainstem::DSL::HashBlockField.new(name, type, options) }
+  let(:model)        { Workspace.find(1) }
+  let(:lead_user)    { model.lead_user }
+
+  before do
+    expect(lead_user).to be_present
+    expect(nested_field.configuration.keys).to be_empty
+
+    # Add sub fields to the hash block field.
+    nested_field.configuration[:type] = Brainstem::DSL::Field.new(:type, type, {})
+    nested_field.configuration[:formatted_type] = Brainstem::DSL::Field.new(:formatted_type, type,
+      dynamic: -> (model) { "Formatted #{model.type}" },
+      use_parent_value: true
+    )
+
+    expect(nested_field.configuration.keys).to eq(%w(type formatted_type))
+  end
+
+  describe '#run_on' do
+    let(:context)              { { } }
+    let(:helper_instance)      { Object.new }
+
+    describe 'when none of the sub-fields are presentable' do
+      before do
+        stub.any_instance_of(Brainstem::DSL::Field).presentable? { false }
+      end
+
+      it 'presents an empty hash' do
+        presented_data = nested_field.run_on(model, context)
+
+        expect(presented_data).to eq({})
+      end
+    end
+
+    describe 'when the field is executable' do
+      let(:name) { :lead_user }
+      let(:options) { { info: description, via: :lead_user } }
+
+      before do
+        expect(nested_field.executable?).to be_truthy
+
+        expect(nested_field.configuration[:type].options[:use_parent_value]).to be_nil
+        expect(nested_field.configuration[:formatted_type].options[:use_parent_value]).to be_truthy
+      end
+
+      it 'returns a hash with the value from the evaluated parent' do
+        presented_data = nested_field.run_on(model, context)
+
+        expect(presented_data['type']).to eq(lead_user.type)
+        expect(presented_data['formatted_type']).to eq("Formatted #{lead_user.type}")
+      end
+
+      context 'when the evaluated parent value is blank' do
+        before do
+          stub(model).lead_user { nil }
+        end
+
+        it 'returns a hash with the value from the evaluated parent' do
+          expect(nested_field.run_on(model, context)).to eq({})
+        end
+      end
+
+      context 'when the sub field doesn\'t use a parent value' do
+        before do
+          nested_field.configuration[:secret] = Brainstem::DSL::Field.new(:secret, type,
+            via: :secret_info,
+            use_parent_value: false
+          )
+
+          expect(nested_field.configuration.keys).to eq(%w(type formatted_type secret))
+          expect(nested_field.configuration[:secret].options[:use_parent_value]).to be_falsey
+        end
+
+        it 'returns a hash with the value from itself' do
+          presented_data = nested_field.run_on(model, context)
+
+          expect(presented_data['secret']).to eq(model.secret_info)
+        end
+
+        context 'when the evaluated parent value is blank' do
+          before do
+            stub(model).lead_user { nil }
+          end
+
+          it 'returns a hash with the value from itself' do
+            presented_data = nested_field.run_on(model, context)
+
+            expect(presented_data['secret']).to eq(model.secret_info)
+          end
+        end
+      end
+    end
+
+    describe 'when the field delegates to its parent' do
+      let(:name) { :klass }
+
+      before do
+        expect(nested_field.executable?).to be_falsey
+
+        expect(nested_field.configuration[:type].options[:use_parent_value]).to be_nil
+        expect(nested_field.configuration[:formatted_type].options[:use_parent_value]).to be_truthy
+      end
+
+      it 'returns a hash with the value from its parent' do
+        presented_data = nested_field.run_on(model, context)
+
+        expect(presented_data['type']).to eq(model.type)
+        expect(presented_data['formatted_type']).to eq("Formatted #{model.type}")
+      end
+
+      context 'when the sub field doesn\'t use a parent value' do
+        before do
+          nested_field.configuration[:secret] = Brainstem::DSL::Field.new(:secret, type,
+            via: :secret_info,
+            use_parent_value: false
+          )
+
+          expect(nested_field.configuration.keys).to eq(%w(type formatted_type secret))
+          expect(nested_field.configuration[:secret].options[:use_parent_value]).to be_falsey
+        end
+
+        it 'returns a hash with the value from itself' do
+          presented_data = nested_field.run_on(model, context)
+
+          expect(presented_data['secret']).to eq(model.secret_info)
+        end
+      end
+    end
+  end
+
+  describe '#executable' do
+    subject { nested_field.executable? }
+
+    context 'when dynamic option is specified' do
+      let(:options) { { dynamic: -> { [] } } }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when lookup option is specified' do
+      let(:options) { { lookup: -> { [] } } }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when via option is specified' do
+      let(:options) { { via: :foo } }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when dynamic option is specified' do
+      let(:options) { {} }
+
+      it { is_expected.to be_falsey }
+    end
+  end
+end

data/spec/brainstem/presenter_collection_spec.rb

@@ -482,8 +482,8 @@ describe Brainstem::PresenterCollection do
 
     describe "filters" do
       before do
-        WorkspacePresenter.filter(:owned_by) { |scope, user_id| scope.owned_by(user_id.to_i) }
-        WorkspacePresenter.filter(:title) { |scope, title| scope.where(:title => title) }
+        WorkspacePresenter.filter(:owned_by, :integer) { |scope, user_id| scope.owned_by(user_id.to_i) }
+        WorkspacePresenter.filter(:title, :string) { |scope, title| scope.where(:title => title) }
       end
 
       it "limits records to those matching given filters" do
@@ -510,7 +510,7 @@ describe Brainstem::PresenterCollection do
       it "converts boolean parameters from strings to booleans" do
         jane_id = jane.id
         bob_id = bob.id
-        WorkspacePresenter.filter(:owned_by_bob) { |scope, boolean| boolean ? scope.where(:user_id => bob_id) : scope.where(:user_id => jane_id) }
+        WorkspacePresenter.filter(:owned_by_bob, :boolean) { |scope, boolean| boolean ? scope.where(:user_id => bob_id) : scope.where(:user_id => jane_id) }
         result = @presenter_collection.presenting("workspaces", :params => { :owned_by_bob => "false" }) { Workspace.where(nil) }
         expect(result['workspaces'].values.find { |workspace| workspace['title'].include?("jane") }).to be
         expect(result['workspaces'].values.find { |workspace| workspace['title'].include?("bob") }).not_to be
@@ -518,7 +518,7 @@ describe Brainstem::PresenterCollection do
 
       it "ensures arguments are strings if they are not arrays" do
         string = nil
-        WorkspacePresenter.filter(:owned_by_bob) do |scope, arg|
+        WorkspacePresenter.filter(:owned_by_bob, :boolean) do |scope, arg|
           string = arg
           scope
         end
@@ -528,7 +528,7 @@ describe Brainstem::PresenterCollection do
 
       it "preserves array arguments" do
         array = nil
-        WorkspacePresenter.filter(:owned_by_bob) do |scope, arg|
+        WorkspacePresenter.filter(:owned_by_bob, :boolean) do |scope, arg|
           array = arg
           scope
         end
@@ -537,7 +537,7 @@ describe Brainstem::PresenterCollection do
       end
 
       it "allows filters to be called with false as an argument" do
-        WorkspacePresenter.filter(:nothing) { |scope, bool| bool ? scope.where(:id => nil) : scope }
+        WorkspacePresenter.filter(:nothing, :boolean) { |scope, bool| bool ? scope.where(:id => nil) : scope }
         result = @presenter_collection.presenting("workspaces", :params => { :nothing => "true" }) { Workspace.where(nil) }
         expect(result['workspaces'].length).to eq(0)
         result = @presenter_collection.presenting("workspaces", :params => { :nothing => "false" }) { Workspace.where(nil) }
@@ -546,7 +546,7 @@ describe Brainstem::PresenterCollection do
 
       it "passes colon separated params through as a string" do
         a, b = nil, nil
-        WorkspacePresenter.filter(:between) { |scope, a_and_b|
+        WorkspacePresenter.filter(:between, :string) { |scope, a_and_b|
           a, b = a_and_b.split(':')
           scope
         }
@@ -564,7 +564,7 @@ describe Brainstem::PresenterCollection do
         end
 
         called = false
-        WorkspacePresenter.filter(:something) { |scope, string|
+        WorkspacePresenter.filter(:something, :string) { |scope, string|
           called = true
           some_method
           scope
@@ -576,7 +576,7 @@ describe Brainstem::PresenterCollection do
 
       context "with defaults" do
         before do
-          WorkspacePresenter.filter(:owner, :default => bob.id) { |scope, id| scope.owned_by(id) }
+          WorkspacePresenter.filter(:owner, :integer, :default => bob.id) { |scope, id| scope.owned_by(id) }
         end
 
         let(:jane) { User.where(:username => "jane").first }
@@ -587,7 +587,7 @@ describe Brainstem::PresenterCollection do
         end
 
         it "allows falsy defaults" do
-          WorkspacePresenter.filter(:include_early_workspaces, :default => false) { |scope, bool| bool ? scope : scope.where("id > 3") }
+          WorkspacePresenter.filter(:include_early_workspaces, :boolean, :default => false) { |scope, bool| bool ? scope : scope.where("id > 3") }
           result = @presenter_collection.presenting("workspaces") { Workspace.unscoped }
           expect(result['workspaces']['2']).not_to be_present
           result = @presenter_collection.presenting("workspaces", :params => { :include_early_workspaces => "true" }) { Workspace.unscoped }
@@ -595,7 +595,7 @@ describe Brainstem::PresenterCollection do
         end
 
         it "allows defaults to be skipped if :apply_default_filters is false" do
-          WorkspacePresenter.filter(:include_early_workspaces, :default => false) { |scope, bool| bool ? scope : scope.where("id > 3") }
+          WorkspacePresenter.filter(:include_early_workspaces, :boolean, :default => false) { |scope, bool| bool ? scope : scope.where("id > 3") }
           result = @presenter_collection.presenting("workspaces", :apply_default_filters => true) { Workspace.unscoped }
           expect(result['workspaces']['2']).not_to be_present
           result = @presenter_collection.presenting("workspaces", :apply_default_filters => false) { Workspace.unscoped }
@@ -603,7 +603,7 @@ describe Brainstem::PresenterCollection do
         end
 
         it "allows defaults set to false to be skipped if params contain :apply_default_filters with a false value" do
-          WorkspacePresenter.filter(:include_early_workspaces, :default => false) { |scope, bool| bool ? scope : scope.where("id > 3") }
+          WorkspacePresenter.filter(:include_early_workspaces, :boolean, :default => false) { |scope, bool| bool ? scope : scope.where("id > 3") }
 
           result = @presenter_collection.presenting("workspaces", :params => { :apply_default_filters => "true" }) { Workspace.unscoped }
           expect(result['workspaces']['2']).not_to be_present
@@ -613,7 +613,7 @@ describe Brainstem::PresenterCollection do
         end
 
         it "allows defaults set to true to be skipped if params contain :apply_default_filters with a false value" do
-          WorkspacePresenter.filter(:include_early_workspaces, :default => true) { |scope, bool| bool ? scope : scope.where("id > 3") }
+          WorkspacePresenter.filter(:include_early_workspaces, :boolean, :default => true) { |scope, bool| bool ? scope : scope.where("id > 3") }
 
           result = @presenter_collection.presenting("workspaces", :params => { :apply_default_filters => "false" }) { Workspace.unscoped }
           expect(result['workspaces']['2']).to be_present
@@ -626,7 +626,7 @@ describe Brainstem::PresenterCollection do
           result = @presenter_collection.presenting("workspaces", :params => { :owner => jane.id.to_s }) { Workspace.unscoped }
           expect(result['workspaces'].keys).to match_array(jane.workspaces.map(&:id).map(&:to_s))
 
-          WorkspacePresenter.filter(:include_early_workspaces, :default => true) { |scope, bool| bool ? scope : scope.where("id > 3") }
+          WorkspacePresenter.filter(:include_early_workspaces, :boolean, :default => true) { |scope, bool| bool ? scope : scope.where("id > 3") }
           result = @presenter_collection.presenting("workspaces", :params => { :include_early_workspaces => "false" }) { Workspace.unscoped }
           expect(result['workspaces']['2']).not_to be_present
         end
@@ -637,7 +637,7 @@ describe Brainstem::PresenterCollection do
         let(:jane) { User.where(:username => "jane").first }
 
         before do
-          WorkspacePresenter.filter(:owned_by, :default => bob.id)
+          WorkspacePresenter.filter(:owned_by, :boolean, :default => bob.id)
         end
 
         it "calls the named scope with default arguments" do
@@ -651,7 +651,7 @@ describe Brainstem::PresenterCollection do
         end
 
         it "can use filters without lambdas in the presenter or model, but behaves strangely when false is given" do
-          WorkspacePresenter.filter(:numeric_description)
+          WorkspacePresenter.filter(:numeric_description, :boolean)
 
           result = @presenter_collection.presenting("workspaces") { Workspace.where(nil) }
           expect(result['workspaces'].keys).to eq(%w[1 2 3 4])
@@ -668,13 +668,13 @@ describe Brainstem::PresenterCollection do
 
       context "with include_params" do
         it "passes the params into the filter block" do
-          WorkspacePresenter.filter(:other_filter) { |scope, opt| scope }
-          WorkspacePresenter.filter(:unused_filter) { |scope, opt| scope }
-          WorkspacePresenter.filter(:other_filter_with_default, default: true) { |scope, opt| scope }
+          WorkspacePresenter.filter(:other_filter, :integer) { |scope, opt| scope }
+          WorkspacePresenter.filter(:unused_filter, :string) { |scope, opt| scope }
+          WorkspacePresenter.filter(:other_filter_with_default, :boolean, default: true) { |scope, opt| scope }
 
           provided_params = nil
 
-          WorkspacePresenter.filter :filter_with_param, :include_params => true do |scope, option, params|
+          WorkspacePresenter.filter :filter_with_param, :string, :include_params => true do |scope, option, params|
             provided_params = params
             scope
           end
@@ -767,7 +767,7 @@ describe Brainstem::PresenterCollection do
 
           describe "passing options to the search block" do
             it "passes the search method, the search string, includes, order, and paging options" do
-              WorkspacePresenter.filter(:owned_by) { |scope| scope }
+              WorkspacePresenter.filter(:owned_by, :integer) { |scope| scope }
               search_args = nil
               WorkspacePresenter.search do |*args|
                 search_args = args
@@ -801,7 +801,7 @@ describe Brainstem::PresenterCollection do
 
             describe "filters" do
               it "passes through the default filters if no filter is requested" do
-                WorkspacePresenter.filter(:owned_by, :default => true) { |scope| scope }
+                WorkspacePresenter.filter(:owned_by, :boolean, :default => true) { |scope| scope }
                 search_options = nil
                 WorkspacePresenter.search do |string, options|
                   search_options = options
@@ -824,7 +824,7 @@ describe Brainstem::PresenterCollection do
               end
 
               it "does not pass through existing non-default filters that are not requested" do
-                WorkspacePresenter.filter(:owned_by) { |scope| scope }
+                WorkspacePresenter.filter(:owned_by, :integer) { |scope| scope }
                 search_options = nil
                 WorkspacePresenter.search do |string, options|
                   search_options = options
@@ -1090,7 +1090,7 @@ describe Brainstem::PresenterCollection do
 
     describe "the count top level key" do
       it "should return the total number of matched records" do
-        WorkspacePresenter.filter(:owned_by) { |scope, user_id| scope.owned_by(user_id.to_i) }
+        WorkspacePresenter.filter(:owned_by, :integer) { |scope, user_id| scope.owned_by(user_id.to_i) }
 
         result = @presenter_collection.presenting("workspaces") { Workspace.where(:id => 1) }
         expect(result['count']).to eq(1)