brainstem 1.1.1 → 1.3.0

data/spec/brainstem/concerns/inheritable_configuration_spec.rb

@@ -49,12 +49,14 @@ describe Brainstem::Concerns::InheritableConfiguration do
     end
 
     describe '#keys and #to_h' do
-      let(:subclass) { Class.new(parent_class) }
+      let(:subclass)    { Class.new(parent_class) }
       let(:subsubclass) { Class.new(subclass) }
+      let!(:proc_key)   { Proc.new {} }
 
       before do
         parent_class.configuration['1'] = :a
         parent_class.configuration['2'] = :b
+        parent_class.configuration[proc_key] = :foo
 
         subclass.configuration['2'] = :c
         subclass.configuration['3'] = :d
@@ -64,12 +66,9 @@ describe Brainstem::Concerns::InheritableConfiguration do
       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 })
+        expect(parent_class.configuration.to_h).to eq({ '1' => :a, '2' => :b, proc_key => :foo })
+        expect(subclass.configuration.to_h).to eq({ '1' => :a, '2' => :c, '3' => :d, proc_key => :foo })
+        expect(subsubclass.configuration.to_h).to eq({ '1' => :a, '2' => :c, '3' => :e, '4' => :f, proc_key => :foo })
 
         # it doesn't mutate storage
         subclass.configuration.to_h['1'] = :new
@@ -82,14 +81,19 @@ describe Brainstem::Concerns::InheritableConfiguration do
         expect(parent_class.configuration['1']).to eq :a
         expect(parent_class.configuration['2']).to eq :b
         expect(parent_class.configuration['3']).to be_nil
+        expect(parent_class.configuration[proc_key]).to eq :foo
+
         expect(subclass.configuration['1']).to eq :a
         expect(subclass.configuration['2']).to eq :c
         expect(subclass.configuration['3']).to eq :d
         expect(subclass.configuration['4']).to be_nil
+        expect(subclass.configuration[proc_key]).to eq :foo
+
         expect(subsubclass.configuration['1']).to eq :a
         expect(subsubclass.configuration['2']).to eq :c
         expect(subsubclass.configuration['3']).to eq :e
         expect(subsubclass.configuration['4']).to eq :f
+        expect(subsubclass.configuration[proc_key]).to eq :foo
       end
 
       it "does not return nonheritable keys in the parent" do
@@ -97,8 +101,12 @@ describe Brainstem::Concerns::InheritableConfiguration do
         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
+        parent_class.configuration.nonheritable! proc_key
+        parent_class.configuration[proc_key] = "Not Inheritable!"
+        expect(subclass.configuration.keys).not_to include proc_key
+
+        expect(subclass.configuration.to_h.keys).not_to include proc_key
+        expect(subclass.configuration.has_key?(proc_key)).to eq false
       end
     end
 
@@ -298,6 +306,21 @@ describe Brainstem::Concerns::InheritableConfiguration do
         parent_class.configuration.nonheritable! :nonheritable
         expect(parent_class.configuration.nonheritable_keys.to_a).to eq ["nonheritable"]
       end
+
+      context "when key is a proc" do
+        let!(:proc_key) { Proc.new {} }
+
+        it "adds the key to the nonheritable attributes list" do
+          parent_class.configuration.nonheritable! proc_key
+          expect(parent_class.configuration.nonheritable_keys.to_a).to eq [proc_key]
+        end
+
+        it "dedupes" do
+          parent_class.configuration.nonheritable! proc_key
+          parent_class.configuration.nonheritable! proc_key
+          expect(parent_class.configuration.nonheritable_keys.to_a).to eq [proc_key]
+        end
+      end
     end
   end
 

data/spec/brainstem/concerns/presenter_dsl_spec.rb

@@ -21,16 +21,32 @@ require 'brainstem/concerns/presenter_dsl'
 #   field :description, :string
 #   field :updated_at, :datetime
 #   field :dynamic_title, :string, dynamic: lambda { |model| model.title }
-#   field :secret, :string, 'a secret, via secret_info',
+#   field :secret, :string,
+#         info: 'a secret, via secret_info',
 #         via: :secret_info,
 #         if: [:user_is_bob, :title_is_hello]
 #
+#   field :member_ids, :array,
+#         item_type: :integer,
+#         dynamic: lambda { |model| model.members.pluck(:id) }
+#
 #   with_options if: :user_is_bob do
 #     field :bob_title, :string,
 #           info: 'another name for the title, only for Bob',
 #           via: :title
 #   end
-#   fields :nested_permissions do
+#
+#   fields :members, :array,
+#          if: :user_is_bob,
+#          dynamic: lambda { |project| project.members } do
+#     field :name, :string,
+#           dynamic: lambda { |user| user.username }
+#     field :project_klass, :number,
+#           use_parent_value: false,
+#           dynamic: lambda { |project| project.class }
+#   end
+#
+#   fields :nested_permissions, if: :user_is_bob do
 #     field :something_title, :string, via: :title
 #     field :random, :number, dynamic: lambda { rand }
 #   end
@@ -118,7 +134,6 @@ describe Brainstem::Concerns::PresenterDSL do
     end
   end
 
-
   # sort_order :created_at, ".created_at"
   describe 'the sort_order block' do
     let(:value)   { "widgets.created_at" }
@@ -159,7 +174,6 @@ describe Brainstem::Concerns::PresenterDSL do
     end
   end
 
-
   describe 'the conditional block' do
     before do
       presenter_class.conditionals do
@@ -218,11 +232,16 @@ describe Brainstem::Concerns::PresenterDSL do
               via: :secret_info,
               if: [:user_is_bob, :title_is_hello]
 
+        field :member_ids, :array,
+              item_type: :integer,
+              dynamic: lambda { |model| model.members.pluck(:id) }
+
         with_options if: :user_is_bob do
           field :bob_title, :string,
                 info: 'another name for the title, only for Bob',
                 via: :title
         end
+
         fields :nested_permissions do
           field :something_title, :string, via: :title
           field :random, :number, dynamic: lambda { rand }
@@ -231,16 +250,25 @@ describe Brainstem::Concerns::PresenterDSL do
     end
 
     it 'is stored in the configuration' do
-      expect(presenter_class.configuration[:fields].keys).to match_array %w[updated_at dynamic_title secret bob_title nested_permissions]
-      expect(presenter_class.configuration[:fields][:updated_at].type).to eq :datetime
+      expect(presenter_class.configuration[:fields].keys)
+        .to match_array %w[updated_at dynamic_title secret member_ids bob_title nested_permissions]
+
+      expect(presenter_class.configuration[:fields][:updated_at].type).to eq 'datetime'
       expect(presenter_class.configuration[:fields][:updated_at].description).to be_nil
-      expect(presenter_class.configuration[:fields][:dynamic_title].type).to eq :string
+
+      expect(presenter_class.configuration[:fields][:dynamic_title].type).to eq 'string'
       expect(presenter_class.configuration[:fields][:dynamic_title].description).to be_nil
       expect(presenter_class.configuration[:fields][:dynamic_title].options[:dynamic]).to be_a(Proc)
-      expect(presenter_class.configuration[:fields][:secret].type).to eq :string
+
+      expect(presenter_class.configuration[:fields][:secret].type).to eq 'string'
       expect(presenter_class.configuration[:fields][:secret].description).to be_nil
       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][:member_ids].type).to eq 'array'
+      expect(presenter_class.configuration[:fields][:member_ids].options[:item_type]).to eq 'integer'
+      expect(presenter_class.configuration[:fields][:member_ids].options[:dynamic]).to be_a(Proc)
+
+      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,
@@ -250,7 +278,7 @@ describe Brainstem::Concerns::PresenterDSL do
     end
 
     it 'handles nesting' do
-      expect(presenter_class.configuration[:fields][:nested_permissions][:something_title].type).to eq :string
+      expect(presenter_class.configuration[:fields][:nested_permissions][:something_title].type).to eq 'string'
       expect(presenter_class.configuration[:fields][:nested_permissions][:something_title].options[:via]).to eq :title
       expect(presenter_class.configuration[:fields][:nested_permissions][:random].options[:dynamic]).to be_a(Proc)
     end
@@ -263,11 +291,17 @@ describe Brainstem::Concerns::PresenterDSL do
           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]
-      expect(subclass.configuration[:fields].keys).to match_array %w[updated_at dynamic_title secret bob_title title nested_permissions]
+
+      expect(presenter_class.configuration[:fields].keys).
+        to match_array %w[updated_at dynamic_title secret member_ids bob_title nested_permissions]
+      expect(subclass.configuration[:fields].keys).
+        to match_array %w[updated_at dynamic_title secret member_ids bob_title title nested_permissions]
+
       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].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],
         info: 'this time I have a description and condition'
@@ -320,18 +354,21 @@ describe Brainstem::Concerns::PresenterDSL do
           field :something, :string, via: :title
         end
       end
-      expect(presenter_class.configuration[:fields].keys).to match_array %w[updated_at dynamic_title secret bob_title nested_permissions]
-      expect(subclass.configuration[:fields].keys).to match_array %w[updated_at dynamic_title secret bob_title nested_permissions new_nested_permissions]
 
-      expect(presenter_class.configuration[:fields][:nested_permissions][:something_title].type).to eq :string
-      expect(presenter_class.configuration[:fields][:nested_permissions][:random].type).to eq :number
+      expect(presenter_class.configuration[:fields].keys)
+        .to match_array %w[updated_at dynamic_title secret member_ids bob_title nested_permissions]
+      expect(subclass.configuration[:fields].keys)
+        .to match_array %w[updated_at dynamic_title secret member_ids bob_title nested_permissions new_nested_permissions]
+
+      expect(presenter_class.configuration[:fields][:nested_permissions][:something_title].type).to eq 'string'
+      expect(presenter_class.configuration[:fields][:nested_permissions][:random].type).to eq 'number'
       expect(presenter_class.configuration[:fields][:nested_permissions][:new]).to be_nil
       expect(presenter_class.configuration[:fields][:nested_permissions][:deeper]).to be_nil
       expect(presenter_class.configuration[:fields][:new_nested_permissions]).to be_nil
 
-      expect(subclass.configuration[:fields][:nested_permissions][:something_title].type).to eq :number # changed this
-      expect(subclass.configuration[:fields][:nested_permissions][:random].type).to eq :number
-      expect(subclass.configuration[:fields][:nested_permissions][:new].type).to eq :string
+      expect(subclass.configuration[:fields][:nested_permissions][:something_title].type).to eq 'number' # changed this
+      expect(subclass.configuration[:fields][:nested_permissions][:random].type).to eq 'number'
+      expect(subclass.configuration[:fields][:nested_permissions][:new].type).to eq 'string'
       expect(subclass.configuration[:fields][:nested_permissions][:deeper][:something]).to be_present
       expect(subclass.configuration[:fields][:new_nested_permissions]).to be_present
     end
@@ -345,7 +382,7 @@ describe Brainstem::Concerns::PresenterDSL do
 
       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].type).to eq 'datetime'
         expect(presenter_class.configuration[:fields][:synced_at].description).to eq 'Last time the object was synced'
       end
     end
@@ -539,21 +576,58 @@ describe Brainstem::Concerns::PresenterDSL do
 
     it "creates an entry in the filters configuration" do
       my_proc = Proc.new { 1 }
-      presenter_class.filter(:foo, :default => true, &my_proc)
+      presenter_class.filter(:foo, :string, :default => true, :items => [:a, :b], &my_proc)
 
-      expect(foo).to eq({ "default" => true, "value" => my_proc })
+      expect(foo).to eq({ "default" => true, "value" => my_proc, "type" => "string", "items" => [:a, :b] })
     end
 
     it "accepts names without blocks" do
-      presenter_class.filter(:foo)
+      presenter_class.filter(:foo, :string, :items => [:a, :b])
       expect(foo[:value]).to be_nil
+      expect(foo[:type]).to eq("string")
+      expect(foo[:items]).to eq([:a, :b])
     end
 
     it "records the info option" do
-      presenter_class.filter(:foo, :info => "This is documented.")
+      presenter_class.filter(:foo, :integer, :info => "This is documented.", :items => [:a, :b])
       expect(foo[:info]).to eq "This is documented."
+      expect(foo[:type]).to eq "integer"
+      expect(foo[:items]).to eq([:a, :b])
+    end
+
+    context "when filter is of array type" do
+      it "records the item_type option" do
+        presenter_class.filter(:foo, :array, :item_type => :integer)
+        expect(foo[:type]).to eq "array"
+        expect(foo[:item_type]).to eq("integer")
+      end
+
+      it "defaults item_type to string if not specified" do
+        presenter_class.filter(:foo, :array)
+        expect(foo[:type]).to eq "array"
+        expect(foo[:item_type]).to eq("string")
+      end
     end
 
+
+    context "when type is not specified" do
+      before do
+        mock(presenter_class).deprecated_type_warning
+      end
+
+      it "adds a deprecation warning and creates an entry in the filters configuration" do
+        my_proc = Proc.new { 1 }
+        presenter_class.filter(:foo, :default => true, &my_proc)
+
+        expect(foo).to eq({ "default" => true, "value" => my_proc, "type" => "string" })
+      end
+
+      it "adds a deprecation warning and records the info option" do
+        presenter_class.filter(:foo, :info => "This is documented.")
+        expect(foo[:info]).to eq "This is documented."
+        expect(foo[:type]).to eq "string"
+      end
+    end
   end
 
   describe ".search" do

data/spec/brainstem/dsl/array_block_field_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'brainstem/dsl/array_block_field'
+
+describe Brainstem::DSL::ArrayBlockField do
+  let(:name)         { :tasks }
+  let(:type)         { :array }
+  let(:description)  { 'the title of this model' }
+  let(:options)      { { info: description, via: :tasks } }
+  let(:nested_field) { Brainstem::DSL::ArrayBlockField.new(name, type, options) }
+  let(:model)        { Workspace.find(1) }
+  let(:tasks)        { Task.where(workspace_id: model.id).order(:id).to_a }
+
+  before do
+    expect(tasks).to_not be_empty
+    expect(nested_field.configuration.keys).to be_empty
+
+    # Add sub fields to the array block field.
+    nested_field.configuration[:name] = Brainstem::DSL::Field.new(:name, type, {})
+    nested_field.configuration[:parent_name] = Brainstem::DSL::Field.new(:parent_name, type,
+      dynamic: -> (model) { model.parent.try(:name) }
+    )
+    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(name parent_name secret))
+  end
+
+  describe '#run_on' do
+    let(:context)              { { } }
+    let(:helper_instance)      { Object.new }
+    let(:presented_field_data) {
+      tasks.map do |task|
+        { 'name' => task.name, 'parent_name' => task.parent.try(:name), 'secret' => model.secret_info }
+      end
+    }
+
+    it 'returns an array of hashes with sub nested properties' do
+      expect(nested_field.run_on(model, context)).to eq(presented_field_data)
+    end
+  end
+end

data/spec/brainstem/dsl/block_field_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+require 'brainstem/dsl/block_field'
+
+describe Brainstem::DSL::BlockField do
+  let(:name)         { :tasks }
+  let(:type)         { :hash }
+  let(:description)  { 'the title of this model' }
+  let(:options)      { { info: description } }
+  let(:nested_field) { Brainstem::DSL::BlockField.new(name, type, options) }
+  let(:model)        { Workspace.find(1) }
+
+  describe 'configuration' do
+    context 'when parent field specified' do
+      let(:parent_field) { Brainstem::DSL::BlockField.new(name, type, options) }
+      let(:nested_field) { Brainstem::DSL::BlockField.new(name, type, options, parent_field) }
+      let(:inherited_field) do
+        Brainstem::DSL::Field.new(:parent_name, type, dynamic: -> (model) { model.parent.try(:name) })
+      end
+      let(:overriden_field) do
+        Brainstem::DSL::Field.new(:name, type, dynamic: -> (model) { "Formatted #{model.name}" })
+      end
+
+      before do
+        parent_field.configuration[:name] = Brainstem::DSL::Field.new(:name, type, {})
+        parent_field.configuration[:parent_name] = inherited_field
+
+        nested_field.configuration[:name] = overriden_field
+        nested_field.configuration[:parent_title] = Brainstem::DSL::Field.new(:parent_title, type,
+          dynamic: -> (model) { model.parent.try(:name) }
+        )
+
+        expect(nested_field.configuration.keys).to include('name', 'parent_title')
+      end
+
+      it 'inherits sub fields from the parent field' do
+        expect(nested_field.configuration.keys).to include('parent_name')
+        expect(nested_field.configuration[:parent_name]).to eq(inherited_field)
+      end
+
+      it 'override keys inherits from the parent' do
+        expect(nested_field.configuration.keys).to include('name')
+        expect(nested_field.configuration[:name]).to eq(overriden_field)
+      end
+    end
+
+    context 'when parent field is not specified' do
+      let(:nested_field) { Brainstem::DSL::BlockField.new(name, type, options) }
+
+      before do
+        nested_field.configuration[:name] = Brainstem::DSL::Field.new(:name, type, {})
+        nested_field.configuration[:parent_title] = Brainstem::DSL::Field.new(:parent_title, type,
+          dynamic: -> (model) { model.parent.try(:name) }
+        )
+      end
+
+      it 'only has sub fields defined on itself' do
+        expect(nested_field.configuration.keys).to match_array(['name', 'parent_title'])
+      end
+    end
+  end
+
+  describe 'self.for' do
+    subject { described_class.for(name, type, options) }
+
+    context 'when given an array type' do
+      let(:type) { :array }
+
+      it 'returns a new ArrayBlockField' do
+        expect(subject).to be_instance_of(Brainstem::DSL::ArrayBlockField)
+      end
+    end
+
+    context 'when given a hash type' do
+      let(:type) { :hash }
+
+      it 'returns a new HashBlockField' do
+        expect(subject).to be_instance_of(Brainstem::DSL::HashBlockField)
+      end
+    end
+
+    context 'when given an unknown type' do
+      let(:type) { :unknown }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(StandardError)
+      end
+    end
+  end
+
+  describe 'evaluate_value_on' do
+    let(:context) { {} }
+    let(:helper_instance) { Object.new }
+
+    context 'when lookup option is specifed' do
+      let(:context) {
+        {
+          lookup: Brainstem::Presenter.new.send(:empty_lookup_cache, [name.to_s], []),
+          models: [model]
+        }
+      }
+
+      context 'when lookup_fetch option is not specified' do
+        let(:options) do
+          { lookup: lambda { |models| Hash[models.map { |model| [model.id, model.tasks.to_a] }] } }
+        end
+
+        before do
+          expect(options).to_not have_key(:lookup_fetch)
+        end
+
+        it 'returns the value from the lookup cache' do
+          expect(nested_field.evaluate_value_on(model, context, helper_instance)).to eq(model.tasks.to_a)
+        end
+      end
+
+      context 'when lookup_fetch option is specified' do
+        let(:options) do
+          {
+            lookup: lambda { |models| Hash[models.map { |model| [model.id + 10, model.tasks.to_a] }] },
+            lookup_fetch: lambda { |lookup, model| lookup[model.id + 10]  }
+          }
+        end
+
+        before do
+          expect(options).to have_key(:lookup_fetch)
+        end
+
+        it 'returns the value from the lookup cache using the lookup fetch' do
+          expect(nested_field.evaluate_value_on(model, context, helper_instance)).to eq(model.tasks.to_a)
+        end
+      end
+    end
+
+    context 'when dynamic option is specified' do
+      let(:options) { { dynamic: lambda { |model| model.tasks.to_a } } }
+
+      it 'calls the :dynamic lambda in the context of the given instance' do
+        expect(nested_field.evaluate_value_on(model, context, helper_instance)).to eq(model.tasks.to_a)
+      end
+    end
+
+    context 'when via option is specified' do
+      let(:options) { { via: :tasks } }
+
+      it 'calls the method name in the :via option in the context of the given instance' do
+        expect(nested_field.evaluate_value_on(model, context, helper_instance)).to eq(model.tasks.to_a)
+      end
+    end
+
+    context 'when none of the options are specified' do
+      let(:options) { {} }
+
+      it 'should raise error' do
+        expect {
+          nested_field.evaluate_value_on(model, context, helper_instance)
+        }.to raise_error(StandardError)
+      end
+    end
+  end
+
+  describe 'use_parent_value?' do
+    let(:field) { Brainstem::DSL::Field.new(:type, type, options) }
+
+    subject { nested_field.use_parent_value?(field) }
+
+    context 'when sub field does not specify use_parent_value option' do
+      let(:options) { { info: description } }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when sub field specifies use_parent_value option' do
+      let(:options) { { use_parent_value: use_parent_value } }
+
+      context 'when set to true' do
+        let(:use_parent_value) { true }
+
+        it { is_expected.to be_truthy }
+      end
+
+      context 'when set to false' do
+        let(:use_parent_value) { false }
+
+        it { is_expected.to be_falsey }
+      end
+    end
+  end
+end