brainstem 1.1.1 → 1.3.0

data/spec/brainstem/presenter_spec.rb

@@ -69,7 +69,6 @@ describe Brainstem::Presenter do
       end
     end
 
-
     describe ".possible_brainstem_keys" do
       let(:presented_class)       { Class.new }
       let(:other_presented_class) { Class.new }
@@ -301,6 +300,231 @@ describe Brainstem::Presenter do
           end
         end
       end
+
+      describe 'handling nested hash block fields' do
+        let(:presenter_class) do
+          Class.new(Brainstem::Presenter) do
+            presents Workspace
+
+            helper do
+              def current_user
+                'jane'
+              end
+            end
+
+            conditionals do
+              request :user_is_bob, lambda { current_user == 'bob' }, info: 'visible only to bob'
+            end
+
+            fields do
+              fields :participant, :hash, via: :lead_user, if: :user_is_bob  do
+                field :username, :string
+              end
+
+              fields :lead_user do
+                field :username, :string, dynamic: lambda { |workspace| workspace.lead_user.username }
+              end
+            end
+          end
+        end
+        let(:presenter) { presenter_class.new }
+
+        before do
+          stub.any_instance_of(Brainstem::DSL::Field).presentable?(model, anything) { presentable }
+        end
+
+        context 'when field is presentable' do
+          let(:presentable) { true }
+
+          it 'includes the executable hash block field' do
+            presented_workspace = presenter.group_present([model], []).first
+
+            expect(presented_workspace.keys).to include('participant')
+          end
+
+          it 'includes the non executable hash block field' do
+            presented_workspace = presenter.group_present([model], []).first
+
+            expect(presented_workspace.keys).to include('lead_user')
+          end
+        end
+
+        context 'when field is not presentable' do
+          let(:presentable) { false }
+
+          it 'does not include executable hash block fields' do
+            presented_workspace = presenter.group_present([model], []).first
+
+            expect(presented_workspace.keys).to_not include('participant')
+          end
+
+          it 'always includes non-executable hash block fields' do
+            presented_workspace = presenter.group_present([model], []).first
+
+            expect(presented_workspace.keys).to include('lead_user')
+          end
+        end
+      end
+
+      describe 'handling of nested array fields' do
+        let(:array_values) { [OpenStruct.new(name: 1), OpenStruct.new(name: 2)] }
+        let(:presenter_class) do
+          Class.new(Brainstem::Presenter) do
+            presents Workspace
+
+            fields do
+              fields :participants, :array, via: :members do
+                field :username, :string
+              end
+
+              fields :accessible_by, :array, dynamic: -> { [OpenStruct.new(name: 1), OpenStruct.new(name: 2)] } do
+                field :name, :string
+                field :full_name, :string, via: :name
+                field :formatted_name, :string, dynamic: -> (model) { model.name * 2 }
+              end
+            end
+          end
+        end
+        let(:presenter) { presenter_class.new }
+
+        context 'when dynamic option is specified' do
+          def extract_values(fields, field_name, nested_field_name)
+            fields[field_name].map { |data| data[nested_field_name] }
+          end
+
+          it 'calls named methods' do
+            fields = presenter.group_present([model]).first
+
+            expect(fields).to have_key('accessible_by')
+            expect(extract_values(fields, 'accessible_by', 'name')).to eq([1, 2])
+          end
+
+          it 'can call methods with :via' do
+            fields = presenter.group_present([model]).first
+
+            expect(fields).to have_key('accessible_by')
+            expect(extract_values(fields, 'accessible_by', 'full_name')).to eq([1, 2])
+          end
+
+          it 'can call a dynamic lambda' do
+            fields = presenter.group_present([model]).first
+
+            expect(fields).to have_key('accessible_by')
+            expect(extract_values(fields, 'accessible_by', 'formatted_name')).to eq([2, 4])
+          end
+        end
+
+        context 'when via option is specified' do
+          let(:participants) { [model.user] }
+          let(:presented_field_data) { participants.map { |user| { 'username' => user.username } } }
+
+          it 'returns an array of hashes with the specified field' do
+            fields = presenter.group_present([model]).first
+
+            expect(fields).to have_key('participants')
+            expect(fields['participants']).to eq(presented_field_data)
+          end
+        end
+
+        describe 'when nested fields specify not using the parent value' do
+          let(:presenter_class) do
+            Class.new(Brainstem::Presenter) do
+              presents Workspace
+
+              fields do
+                fields :tasks, :array, via: :tasks do
+                  field :name, :string
+                  field :secret, :string,
+                        info: 'a secret, via secret_info',
+                        via: :secret_info,
+                        use_parent_value: false
+                end
+              end
+            end
+          end
+          let(:tasks) { Task.where(workspace_id: model.id).order(:id).to_a }
+          let(:presented_field_data) { tasks.map { |task| { 'name' => task.name, 'secret' => model.secret_info } } }
+
+          it 'returns an array of hashes while using the correct model to evaluate the properties' do
+            fields = presenter.group_present([model]).first
+
+            expect(fields).to have_key('tasks')
+            expect(fields['tasks']).to eq(presented_field_data)
+          end
+        end
+
+        describe 'handling of conditional fields' do
+          let(:presenter_class) do
+            Class.new(Brainstem::Presenter) do
+              presents Workspace
+
+              helper do
+                def current_user
+                  'jane'
+                end
+              end
+
+              conditionals do
+                model   :title_is_hello, lambda { |model| model.title == 'hello' }, info: 'visible when the title is hello'
+                request :user_is_bob, lambda { current_user == 'bob' }, info: 'visible only to bob'
+              end
+
+              fields do
+                with_options if: :user_is_bob do
+                  fields :tasks, :array, dynamic: lambda { |workspace| workspace.tasks.to_a } do
+                    field :name, :string
+                  end
+                end
+
+                fields :members, :array, via: :members, if: :title_is_hello do
+                  field :hello_title, :string,
+                        info: 'the title, when hello',
+                        dynamic: lambda { 'title is hello' }
+
+                  field :foo, :string,
+                        info: 'a secret, via secret_info',
+                        dynamic: lambda { 'foo' },
+                        if: [:user_is_bob]
+                end
+              end
+            end
+          end
+
+          it 'does not return conditional fields when their :if conditionals do not match' do
+            fields = presenter.group_present([model]).first
+
+            expect(fields).to_not have_key('tasks')
+            expect(fields).to_not have_key('members')
+          end
+
+          it 'returns conditional fields when their :if matches' do
+            model.title = 'hello'
+
+            fields = presenter.group_present([model]).first
+
+            expect(fields).to_not have_key('tasks')
+            expect(fields).to have_key('members')
+            expect(fields['members'][0]).to_not have_key('foo')
+            expect(fields['members'][0]['hello_title']).to eq 'title is hello'
+          end
+
+          it 'returns fields with the :if option only when all of the conditionals in that :if are true' do
+            model.title = 'hello'
+            presenter.class.helper do
+              def current_user
+                'bob'
+              end
+            end
+
+            fields = presenter.group_present([model]).first
+
+            expect(fields).to have_key('tasks')
+            expect(fields).to have_key('members')
+            expect(fields['members'][0]['foo']).to eq('foo')
+            expect(fields['members'][0]['hello_title']).to eq('title is hello')
+          end
+        end
+      end
     end
 
     describe "adding object ids as strings" do
@@ -650,8 +874,8 @@ describe Brainstem::Presenter do
     let(:presenter) { presenter_class.new }
 
     it 'returns only known filters' do
-      presenter_class.filter :owned_by
-      presenter_class.filter(:bar) { |scope| scope }
+      presenter_class.filter :owned_by, :integer
+      presenter_class.filter(:bar, :string) { |scope| scope }
       expect(presenter.extract_filters({ 'foo' => 'hi' })).to eq({})
       expect(presenter.extract_filters({ 'owned_by' => '2' })).to eq({ 'owned_by' => '2' })
       expect(presenter.extract_filters({ 'owned_by' => [2] })).to eq({ 'owned_by' => [2] })
@@ -659,7 +883,7 @@ describe Brainstem::Presenter do
     end
 
     it "converts 'true' and 'false' into true and false" do
-      presenter_class.filter :owned_by
+      presenter_class.filter :owned_by, :boolean
       expect(presenter.extract_filters({ 'owned_by' => 'true' })).to eq({ 'owned_by' => true })
       expect(presenter.extract_filters({ 'owned_by' => 'TRUE' })).to eq({ 'owned_by' => true })
       expect(presenter.extract_filters({ 'owned_by' => 'false' })).to eq({ 'owned_by' => false })
@@ -668,19 +892,19 @@ describe Brainstem::Presenter do
     end
 
     it 'defaults to applying default filters' do
-      presenter_class.filter :owned_by, default: '2'
+      presenter_class.filter :owned_by, :integer, default: '2'
       expect(presenter.extract_filters({ 'owned_by' => '3' })).to eq({ 'owned_by' => '3' })
       expect(presenter.extract_filters({})).to eq({ 'owned_by' => '2' })
     end
 
     it 'will skip default filters when asked' do
-      presenter_class.filter :owned_by, default: '2'
+      presenter_class.filter :owned_by, :integer, default: '2'
       expect(presenter.extract_filters({ 'owned_by' => '3' }, apply_default_filters: false)).to eq({ 'owned_by' => '3' })
       expect(presenter.extract_filters({}, apply_default_filters: false)).to eq({})
     end
 
     it 'ignores nil and blank values' do
-      presenter_class.filter :owned_by
+      presenter_class.filter :owned_by, :integer
       expect(presenter.extract_filters({ 'owned_by' => nil })).to eq({})
       expect(presenter.extract_filters({ 'owned_by' => '' })).to eq({})
     end
@@ -694,8 +918,8 @@ describe Brainstem::Presenter do
     let(:options) { { apply_default_filters: true } }
 
     before do
-      presenter_class.filter :owned_by, default: '2'
-      presenter_class.filter(:bar) { |scope| scope.where(id: 6) }
+      presenter_class.filter :owned_by, :integer, default: '2'
+      presenter_class.filter(:bar, :string) { |scope| scope.where(id: 6) }
       mock(presenter).extract_filters(params, options) { { 'bar' => 'foo', 'owned_by' => '2' } }
     end
 

data/spec/brainstem/query_strategies/filter_and_search_spec.rb

@@ -35,7 +35,7 @@ describe Brainstem::QueryStrategies::FilterAndSearch do
         [search_results, search_results.count]
       end
 
-      CheesePresenter.filter(:owned_by) { |scope, user_id| scope.owned_by(user_id.to_i) }
+      CheesePresenter.filter(:owned_by, :integer) { |scope, user_id| scope.owned_by(user_id.to_i) }
       CheesePresenter.sort_order(:id)   { |scope, direction| scope.order("cheeses.id #{direction}") }
     end
 

data/spec/spec_helpers/presenters.rb

@@ -32,6 +32,14 @@
       field :access_level, :integer, dynamic: lambda { 2 }
     end
 
+    fields :members, :array, via: :members do
+      field :username, :string
+      field :secret, :string,
+            info: 'a secret, via secret_info',
+            via: :secret_info,
+            use_parent_value: false
+    end
+
     field :hello_title, :string,
           info: 'the title, when hello',
           dynamic: lambda { 'title is hello' },

data/spec/spec_helpers/schema.rb

@@ -51,10 +51,15 @@ end
 
 class User < ActiveRecord::Base
   has_many :workspaces
+
+  def type
+    self.class.name
+  end
 end
 
 class Task < ActiveRecord::Base
   belongs_to :workspace
+  belongs_to :parent, :class_name => "Task"
   has_many :sub_tasks, :foreign_key => :parent_id, :class_name => "Task"
   has_many :posts
 
@@ -75,6 +80,10 @@ class Workspace < ActiveRecord::Base
     "this is secret!"
   end
 
+  def members
+    [user]
+  end
+
   def lead_user
     user
   end
@@ -82,6 +91,10 @@ class Workspace < ActiveRecord::Base
   def missing_user
     nil
   end
+
+  def type
+    self.class.name
+  end
 end
 
 class Group < Workspace

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brainstem
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Mavenlink
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-15 00:00:00.000000000 Z
+date: 2018-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -112,16 +112,16 @@ dependencies:
   name: mysql2
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.4.10
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.4.10
 - !ruby/object:Gem::Dependency
   name: database_cleaner
   requirement: !ruby/object:Gem::Requirement
@@ -252,14 +252,17 @@ files:
 - lib/brainstem/concerns/optional.rb
 - lib/brainstem/concerns/presenter_dsl.rb
 - lib/brainstem/controller_methods.rb
+- lib/brainstem/dsl/array_block_field.rb
 - lib/brainstem/dsl/association.rb
 - lib/brainstem/dsl/associations_block.rb
 - lib/brainstem/dsl/base_block.rb
+- lib/brainstem/dsl/block_field.rb
 - lib/brainstem/dsl/conditional.rb
 - lib/brainstem/dsl/conditionals_block.rb
 - lib/brainstem/dsl/configuration.rb
 - lib/brainstem/dsl/field.rb
 - lib/brainstem/dsl/fields_block.rb
+- lib/brainstem/dsl/hash_block_field.rb
 - lib/brainstem/help_text.txt
 - lib/brainstem/preloader.rb
 - lib/brainstem/presenter.rb
@@ -306,10 +309,13 @@ files:
 - spec/brainstem/concerns/optional_spec.rb
 - spec/brainstem/concerns/presenter_dsl_spec.rb
 - spec/brainstem/controller_methods_spec.rb
+- spec/brainstem/dsl/array_block_field_spec.rb
 - spec/brainstem/dsl/association_spec.rb
+- spec/brainstem/dsl/block_field_spec.rb
 - spec/brainstem/dsl/conditional_spec.rb
 - spec/brainstem/dsl/configuration_spec.rb
 - spec/brainstem/dsl/field_spec.rb
+- spec/brainstem/dsl/hash_block_field_spec.rb
 - spec/brainstem/preloader_spec.rb
 - spec/brainstem/presenter_collection_spec.rb
 - spec/brainstem/presenter_spec.rb
@@ -384,10 +390,13 @@ test_files:
 - spec/brainstem/concerns/optional_spec.rb
 - spec/brainstem/concerns/presenter_dsl_spec.rb
 - spec/brainstem/controller_methods_spec.rb
+- spec/brainstem/dsl/array_block_field_spec.rb
 - spec/brainstem/dsl/association_spec.rb
+- spec/brainstem/dsl/block_field_spec.rb
 - spec/brainstem/dsl/conditional_spec.rb
 - spec/brainstem/dsl/configuration_spec.rb
 - spec/brainstem/dsl/field_spec.rb
+- spec/brainstem/dsl/hash_block_field_spec.rb
 - spec/brainstem/preloader_spec.rb
 - spec/brainstem/presenter_collection_spec.rb
 - spec/brainstem/presenter_spec.rb