blacklight 7.41.0 → 8.0.0.beta1

data/spec/i18n_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'i18n/tasks'
 
 RSpec.describe 'I18n', type: :i18n do

data/spec/integration/generators/blacklight/solr_generator_spec.rb

@@ -20,7 +20,7 @@ RSpec.describe Blacklight::SolrGenerator do
     end
 
     after do
-      files_to_test.each { |file| File.delete(file) if File.exist?(file) }
+      files_to_test.each { |file| FileUtils.rm_rf(file) }
     end
 
     it "creates config files" do

data/spec/lib/blacklight/component_spec.rb

@@ -1,48 +1,43 @@
 # frozen_string_literal: true
 
-RSpec.describe Blacklight::Component, type: :component do
-  let(:component_class) { Blacklight::System::ModalComponent }
+RSpec.describe Blacklight::Component do
+  let(:component_class) { Blacklight::DocumentTitleComponent }
 
-  before do
-    component_class.reset_compiler!
-    ViewComponent::CompileCache.invalidate!
-
-    component_class.class_eval do
-      undef :call if method_defined?(:call)
+  context "subclassed" do
+    it "returns our Compiler implementation" do
+      expect(component_class.ancestors).to include described_class
+      expect(component_class.compiler).to be_a Blacklight::Component::EngineCompiler
     end
   end
 
-  after do
-    component_class.reset_compiler!
-    ViewComponent::CompileCache.invalidate!
+  describe Blacklight::Component::EngineCompiler do
+    subject(:compiler) { described_class.new(component_class) }
 
-    component_class.class_eval do
-      undef :call if method_defined?(:call)
-    end
-  end
+    let(:original_compiler) { ViewComponent::Compiler.new(component_class) }
+    let(:original_path) { original_compiler.send(:templates).first[:path] }
+    let(:resolved_path) { compiler.templates.first[:path] }
 
-  context "without overrides" do
-    it "renders the engine template" do
-      render_inline(component_class.new)
-      expect(page).to have_css('.modal-header')
+    context "without overrides" do
+      it "links to engine template" do
+        expect(resolved_path).not_to include(".internal_test_app")
+        expect(resolved_path).to eql(original_path)
+      end
     end
-  end
 
-  context "with overrides" do
-    around do |ex|
-      FileUtils.mkdir_p(Rails.root.join('app/components/blacklight/system'))
-      Rails.root.join("app/components/blacklight/system/modal_component.html.erb").open("w") do |f|
-        f.puts '<div class="custom-modal">Overridden</div>'
+    context "with overrides" do
+      let(:path_match) do
+        Regexp.new(Regexp.escape(File.join(".internal_test_app", component_class.view_component_path)))
       end
 
-      ex.run
-    ensure
-      Rails.root.join('app/components/blacklight/system/modal_component.html.erb').unlink
-    end
+      before do
+        allow(File).to receive(:exist?).and_call_original
+        allow(File).to receive(:exist?).with(path_match).and_return(true)
+      end
 
-    it "renders to application template" do
-      render_inline(component_class.new)
-      expect(page).to have_css('.custom-modal')
+      it "links to application template" do
+        expect(resolved_path).to include(".internal_test_app")
+        expect(resolved_path).not_to eql(original_path)
+      end
     end
   end
 end

data/spec/lib/blacklight/configuration/facet_field_spec.rb

@@ -1,30 +1,41 @@
 # frozen_string_literal: true
 
 RSpec.describe Blacklight::Configuration::FacetField do
-  describe 'link_to_search' do
-    subject { described_class.new(link_to_search: true) }
-
-    it 'is deprecated' do
-      expect(Deprecation).to receive(:warn)
-      expect(subject.normalize!)
-      expect(subject.link_to_facet).to eq true
-    end
-  end
-
   describe '#normalize!' do
-    it 'preserves existing properties' do
-      expected = double
-      subject.presenter = expected
+    context 'with existing properties' do
+      let(:expected_presenter) { double }
+      let(:expected_component) { double }
 
-      subject.normalize!
+      before do
+        subject.presenter = expected_presenter
+        subject.component = expected_component
+      end
 
-      expect(subject.presenter).to eq expected
+      it 'preserves existing properties' do
+        subject.normalize!
+
+        expect(subject.presenter).to eq expected_presenter
+        expect(subject.component).to eq expected_component
+      end
     end
 
-    it 'adds a default presenter' do
+    it 'adds a default presenter and component' do
       subject.normalize!
 
       expect(subject.presenter).to eq Blacklight::FacetFieldPresenter
+      expect(subject.component).to eq Blacklight::FacetFieldListComponent
+    end
+
+    context 'when component is set to true' do
+      before do
+        subject.component = true
+      end
+
+      it 'casts to the default component' do
+        subject.normalize!
+
+        expect(subject.component).to eq Blacklight::FacetFieldListComponent
+      end
     end
   end
 end

data/spec/lib/blacklight/configuration/field_spec.rb

@@ -8,7 +8,7 @@ RSpec.describe Blacklight::Configuration::Field do
 
   describe '#display_label' do
     it "looks up the label to display for the given document and field" do
-      allow(I18n).to receive(:t).with(:"blacklight.search.fields.my_context.some_key", default: [:"blacklight.search.fields.some_key", label, subject.default_label]).and_return('x')
+      allow(I18n).to receive(:t).with(:'blacklight.search.fields.my_context.some_key', default: [:'blacklight.search.fields.some_key', label, subject.default_label]).and_return('x')
       expect(subject.display_label('my_context')).to eq 'x'
     end
   end

data/spec/lib/blacklight/configuration/view_config_spec.rb

@@ -8,7 +8,7 @@ RSpec.describe Blacklight::Configuration::ViewConfig do
 
   describe '#display_label' do
     it "looks up the label to display for the given document and field" do
-      allow(I18n).to receive(:t).with(:"blacklight.search.view_title.my_view", default: [:"blacklight.search.view.my_view", label, nil, "My view"]).and_return('x')
+      allow(I18n).to receive(:t).with(:'blacklight.search.view_title.my_view', default: [:'blacklight.search.view.my_view', label, nil, "My view"]).and_return('x')
       expect(subject.display_label).to eq 'x'
     end
   end

data/spec/lib/blacklight/open_struct_with_hash_access_spec.rb

@@ -54,11 +54,11 @@ RSpec.describe Blacklight::OpenStructWithHashAccess do
     end
 
     it "is true if the key exists" do
-      expect(subject.key?(:a)).to eq true
+      expect(subject.key?(:a)).to be true
     end
 
     it "is false if the key does not exist" do
-      expect(subject.key?(:c)).to eq false
+      expect(subject.key?(:c)).to be false
     end
   end
 

data/spec/lib/blacklight/parameters_spec.rb

@@ -72,11 +72,8 @@ RSpec.describe Blacklight::Parameters do
     context 'with filter_search_state_fields set to false' do
       let(:blacklight_config) { Blacklight::Configuration.new(filter_search_state_fields: false) }
 
-      it 'allows all params, but warns about the behavior' do
-        allow(Deprecation).to receive(:warn)
+      it 'allows all params' do
         expect(params.permit_search_params.to_h.with_indifferent_access).to include(a: 1, b: 2, c: [])
-
-        expect(Deprecation).to have_received(:warn).with(described_class, /including: a, b, and c/).at_least(:once)
       end
     end
 

data/spec/lib/blacklight/search_state/filter_field_spec.rb

@@ -160,7 +160,7 @@ RSpec.describe Blacklight::SearchState::FilterField do
 
     context "With facet.missing field" do
       let(:params) do
-        { f: { "-some_field": ["[* TO *]"] } }
+        { f: { '-some_field': ["[* TO *]"] } }
       end
 
       it "removes facet.missing facet params" do
@@ -190,12 +190,12 @@ RSpec.describe Blacklight::SearchState::FilterField do
 
   describe '#include?' do
     it 'checks whether the value is currently selected' do
-      expect(search_state.filter('some_field').include?('1')).to eq true
-      expect(search_state.filter('some_field').include?('3')).to eq false
+      expect(search_state.filter('some_field').include?('1')).to be true
+      expect(search_state.filter('some_field').include?('3')).to be false
     end
 
     it 'handles value indirection' do
-      expect(search_state.filter('some_field').include?(OpenStruct.new(value: '1'))).to eq true
+      expect(search_state.filter('some_field').include?(OpenStruct.new(value: '1'))).to be true
     end
   end
 end

data/spec/lib/blacklight/search_state/pivot_filter_field_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::SearchState::PivotFilterField do
+  let(:value_class) { described_class::PivotValue }
+  let(:search_state) { Blacklight::SearchState.new(params.with_indifferent_access, blacklight_config, controller) }
+
+  let(:params) { { f: { some_field: %w[1 2], some_other_field: ['3'] } } }
+  let(:blacklight_config) do
+    Blacklight::Configuration.new.configure do |config|
+      config.add_facet_field 'pivot_field', pivot: %w[some_field some_other_field], filter_class: described_class
+    end
+  end
+  let(:controller) { double }
+
+  describe '#add' do
+    context 'with a string value' do
+      it 'adds the parameter to the first pivot\'s filter list' do
+        filter = search_state.filter('pivot_field')
+        new_state = filter.add('4')
+
+        expect(new_state.filter('some_field').values).to eq %w[1 2 4]
+        expect(new_state.filter('pivot_field').values&.map(&:value)).to eq %w[1 2 4]
+      end
+
+      context 'without any parameters in the url' do
+        let(:params) { {} }
+
+        it 'adds the necessary structure' do
+          filter = search_state.filter('some_field')
+          new_state = filter.add('1')
+
+          expect(new_state.filter('pivot_field').values&.map(&:value)).to eq %w[1]
+          expect(new_state.params).to include(:f)
+        end
+      end
+    end
+
+    context 'with a pivot facet-type item' do
+      it 'includes the pivot facet fqs' do
+        filter = search_state.filter('pivot_field')
+        new_state = filter.add(value_class.new(fq: { some_other_field: '5' }, value: '4'))
+
+        expect(new_state.filter('some_field').values).to eq %w[1 2 4]
+        expect(new_state.filter('some_other_field').values).to eq %w[3 5]
+      end
+    end
+
+    context 'with an array' do
+      pending 'decide how inclusive facets should work with pivots'
+    end
+  end
+
+  describe '#remove' do
+    it 'returns a search state without the given filter applied' do
+      filter = search_state.filter('some_field')
+      new_state = filter.remove('1')
+
+      expect(new_state.filter('pivot_field').values&.map(&:value)).to eq ['2']
+    end
+
+    context 'with a pivot facet-type item' do
+      it 'includes the pivot facet fqs' do
+        filter = search_state.filter('pivot_field')
+        new_state = filter.remove(value_class.new(fq: { some_other_field: '3' }, value: '1'))
+
+        expect(new_state.filter('some_field').values).to eq %w[2]
+        expect(new_state.filter('some_other_field').values).to eq []
+      end
+    end
+
+    it 'removes the whole field if there are no filter left for the field' do
+      filter = search_state.filter('pivot_field')
+      new_state = filter.remove(value_class.new(fq: { some_other_field: '3' }, value: '1'))
+
+      expect(new_state.params[:f]).not_to include :some_other_field
+      expect(new_state.filter('pivot_field').values&.map(&:fq)).to eql([some_other_field: nil])
+    end
+
+    it 'removes the filter parameter entirely if there are no filters left' do
+      filter = search_state.filter('pivot_field')
+      new_state = filter.remove(value_class.new(fq: { some_other_field: '3' }, value: '1'))
+      new_state = new_state.filter('pivot_field').remove(value_class.new(fq: { some_other_field: '3' }, value: '2'))
+
+      expect(new_state.filter('pivot_field').values).to eq []
+      expect(new_state.params).not_to include :f
+    end
+
+    context 'with an array' do
+      pending 'decide how inclusive facets should work with pivots'
+    end
+
+    context "With facet.missing field" do
+      pending 'decide how facet.missing should work with pivots'
+    end
+  end
+
+  describe '#values' do
+    it 'returns the currently selected values of the filter' do
+      expect(search_state.filter('pivot_field').values.map(&:value)).to eq %w[1 2]
+    end
+
+    context 'with an array' do
+      pending 'decide how inclusive facets should work with pivots'
+    end
+  end
+
+  describe '#include?' do
+    it 'checks whether the value is currently selected' do
+      expect(search_state.filter('some_field').include?('1')).to be true
+      expect(search_state.filter('some_field').include?('3')).to be false
+    end
+
+    it 'handles value indirection' do
+      expect(search_state.filter('some_field').include?(value_class.new(value: '1'))).to be true
+    end
+  end
+end

data/spec/lib/blacklight/search_state_spec.rb

@@ -3,8 +3,6 @@
 RSpec.describe Blacklight::SearchState do
   subject(:search_state) { described_class.new(params, blacklight_config, controller) }
 
-  around { |test| Deprecation.silence(described_class) { test.call } }
-
   let(:blacklight_config) do
     Blacklight::Configuration.new.configure do |config|
       config.index.title_field = 'title_tsim'
@@ -81,19 +79,6 @@ RSpec.describe Blacklight::SearchState do
     end
   end
 
-  describe 'interface compatibility with params' do
-    let(:simple_facet_fields) { [:ff] }
-    let(:params) { parameter_class.new f: { ff: ['xyz'] } }
-
-    it 'implements param methods' do
-      Deprecation.silence(described_class) do
-        expect(search_state.to_unsafe_h).to eq('f' => { 'ff' => ['xyz'] })
-        expect(search_state.fetch(:f)).to eq('ff' => ['xyz'])
-        expect(search_state.select { |k, _v,| k == 'f' }).to eq('f' => { 'ff' => ['xyz'] })
-      end
-    end
-  end
-
   describe '#query_param' do
     let(:params) { parameter_class.new q: 'xyz' }
 
@@ -102,25 +87,16 @@ RSpec.describe Blacklight::SearchState do
     end
   end
 
-  describe '#filter_params' do
-    let(:simple_facet_fields) { [:ff] }
-    let(:params) { parameter_class.new f: { ff: ['xyz'] } }
-
-    it 'returns the query param' do
-      expect(search_state.filter_params.deep_symbolize_keys).to eq(ff: ['xyz'])
-    end
-  end
-
   describe '#has_constraints?' do
     it 'is false' do
-      expect(search_state.has_constraints?).to eq false
+      expect(search_state.has_constraints?).to be false
     end
 
     context 'with a query param' do
       let(:params) { parameter_class.new q: 'xyz' }
 
       it 'is true' do
-        expect(search_state.has_constraints?).to eq true
+        expect(search_state.has_constraints?).to be true
       end
     end
 
@@ -129,7 +105,7 @@ RSpec.describe Blacklight::SearchState do
       let(:params) { parameter_class.new f: { ff: ['xyz'] } }
 
       it 'is true' do
-        expect(search_state.has_constraints?).to eq true
+        expect(search_state.has_constraints?).to be true
       end
     end
   end
@@ -213,112 +189,6 @@ RSpec.describe Blacklight::SearchState do
     end
   end
 
-  describe "add_facet_params" do
-    let(:params_no_existing_facet) do
-      parameter_class.new q: "query",
-                          search_field: "search_field",
-                          per_page: "50"
-    end
-    let(:params_existing_facets) do
-      parameter_class.new q: "query",
-                          search_field: "search_field",
-                          per_page: "50",
-                          f: { "facet_field_1" => ["value1"],
-                               "facet_field_2" => %w[value2 value2a] }
-    end
-
-    context "when there are no pre-existing facets" do
-      let(:params) { params_no_existing_facet }
-
-      it "adds facet value" do
-        result_params = search_state.add_facet_params("facet_field", "facet_value")
-        expect(result_params[:f]).to be_a Hash
-        expect(result_params[:f]["facet_field"]).to be_a_kind_of(Array)
-        expect(result_params[:f]["facet_field"]).to eq ["facet_value"]
-      end
-
-      it "leaves non-facet params alone" do
-        result_params = search_state.add_facet_params("facet_field_2", "new_facet_value")
-
-        params.each_pair do |key, _value|
-          next if key == :f
-
-          expect(result_params[key]).to eq params[key]
-        end
-      end
-
-      it "uses the facet's key in the url" do
-        blacklight_config.add_facet_field 'some_key', single: true, field: "a_solr_field"
-
-        result_params = search_state.add_facet_params('some_key', 'my_value')
-
-        expect(result_params[:f]['some_key']).to have(1).item
-        expect(result_params[:f]['some_key'].first).to eq 'my_value'
-      end
-    end
-
-    context "when there are pre-existing facets" do
-      let(:params) { params_existing_facets }
-
-      it "adds a facet param to existing facet constraints" do
-        result_params = search_state.add_facet_params("facet_field_2", "new_facet_value")
-
-        expect(result_params[:f]).to be_a Hash
-
-        params_existing_facets[:f].each_pair do |facet_field, _value_list|
-          expect(result_params[:f][facet_field]).to be_a_kind_of(Array)
-          if facet_field == 'facet_field_2'
-            expect(result_params[:f][facet_field]).to eq (params_existing_facets[:f][facet_field] | ["new_facet_value"])
-          else
-            expect(result_params[:f][facet_field]).to eq params_existing_facets[:f][facet_field]
-          end
-        end
-      end
-
-      it "leaves non-facet params alone" do
-        result_params = search_state.add_facet_params("facet_field_2", "new_facet_value")
-
-        params.each_pair do |key, _value|
-          next if key == 'f'
-
-          expect(result_params[key]).to eq params[key]
-        end
-      end
-    end
-
-    context "with a facet selected in the params" do
-      let(:params) { parameter_class.new f: { 'single_value_facet_field' => 'other_value' } }
-
-      it "replaces facets configured as single" do
-        blacklight_config.add_facet_field 'single_value_facet_field', single: true
-        result_params = search_state.add_facet_params('single_value_facet_field', 'my_value')
-
-        expect(result_params[:f]['single_value_facet_field']).to have(1).item
-        expect(result_params[:f]['single_value_facet_field'].first).to eq 'my_value'
-      end
-    end
-
-    it "accepts a FacetItem instead of a plain facet value" do
-      result_params = search_state.add_facet_params('facet_field_1', double(value: 123))
-
-      expect(result_params[:f]['facet_field_1']).to include(123)
-    end
-
-    it "defers to the field set on a FacetItem" do
-      result_params = search_state.add_facet_params('facet_field_1', double(field: 'facet_field_2', value: 123))
-
-      expect(result_params[:f]['facet_field_1']).to be_blank
-      expect(result_params[:f]['facet_field_2']).to include(123)
-    end
-
-    it "adds any extra fq parameters from the FacetItem" do
-      result_params = search_state.add_facet_params('facet_field_1', double(value: 123, fq: { 'facet_field_2' => 'abc' }))
-
-      expect(result_params[:f]['facet_field_1']).to include(123)
-      expect(result_params[:f]['facet_field_2']).to include('abc')
-    end
-  end
-
   describe "add_facet_params_and_redirect" do
     let(:params) do
       parameter_class.new(
@@ -346,71 +216,6 @@ RSpec.describe Blacklight::SearchState do
       params = search_state.add_facet_params_and_redirect("facet_field_2", "facet_value")
       expect(params).not_to have_key(:page)
     end
-
-    it "otherwise does the same thing as add_facet_params" do
-      added_facet_params = search_state.add_facet_params("facet_field_2", "facet_value")
-      added_facet_params_from_facet_action = search_state.add_facet_params_and_redirect("facet_field_2", "facet_value")
-
-      expect(added_facet_params_from_facet_action).to eq added_facet_params.except(Blacklight::Solr::FacetPaginator.request_keys[:page], Blacklight::Solr::FacetPaginator.request_keys[:sort])
-    end
-  end
-
-  describe "#remove_facet_params" do
-    let(:simple_facet_fields) { [:some_field, :another_field] }
-    let(:params) { parameter_class.new 'f' => facet_params }
-    let(:facet_params) { {} }
-
-    context "when the facet has multiple values" do
-      let(:facet_params) { { 'some_field' => %w[some_value another_value] } }
-
-      it "removes the facet / value tuple from the query parameters" do
-        params = search_state.remove_facet_params('some_field', 'some_value')
-        expect(params[:f]['some_field']).not_to include 'some_value'
-        expect(params[:f]['some_field']).to include 'another_value'
-      end
-    end
-
-    context "when the facet_params is a HWIA" do
-      let(:facet_values) { { '0' => 'some_value', '1' => 'another_value' }.with_indifferent_access }
-      let(:facet_params) { { 'some_field' => facet_values } }
-
-      it "removes the facet / value tuple from the query parameters" do
-        params = search_state.remove_facet_params('some_field', 'some_value')
-        expect(params[:f]['some_field']).not_to include 'some_value'
-        expect(params[:f]['some_field']).to include 'another_value'
-      end
-    end
-
-    context "when the facet has configuration" do
-      before do
-        blacklight_config.facet_fields['some_field'].merge!(single: true, field: "a_solr_field", key: 'some_key')
-      end
-
-      let(:facet_params) { { 'some_key' => %w[some_value another_value] } }
-
-      it "uses the facet's key configuration" do
-        params = search_state.remove_facet_params('some_field', 'some_value')
-        expect(params[:f]['some_key']).not_to eq 'some_value'
-        expect(params[:f]['some_key']).to include 'another_value'
-      end
-    end
-
-    it "removes the facet entirely when the last facet value is removed" do
-      facet_params['another_field'] = ['some_value']
-      facet_params['some_field'] = ['some_value']
-
-      params = search_state.remove_facet_params('some_field', 'some_value')
-
-      expect(params[:f]).not_to have_key 'some_field'
-    end
-
-    it "removes the 'f' parameter entirely when no facets remain" do
-      facet_params['some_field'] = ['some_value']
-
-      params = search_state.remove_facet_params('some_field', 'some_value')
-
-      expect(params).not_to have_key :f
-    end
   end
 
   describe '#reset' do
@@ -549,4 +354,81 @@ RSpec.describe Blacklight::SearchState do
       expect(search_state.facet_prefix).to eq 'A'
     end
   end
+
+  describe "#url_for_document" do
+    let(:controller_class) { ::CatalogController.new }
+    let(:doc) { SolrDocument.new }
+
+    before do
+      allow(search_state).to receive_messages(controller: controller_class)
+      allow(search_state).to receive_messages(controller_name: controller_class.controller_name)
+      allow(search_state).to receive_messages(params: parameter_class.new)
+    end
+
+    it "is a polymorphic routing-ready object" do
+      expect(search_state.url_for_document(doc)).to eq doc
+    end
+
+    it "allows for custom show routes" do
+      search_state.blacklight_config.show.route = { controller: 'catalog' }
+      expect(search_state.url_for_document(doc)).to eq(controller: 'catalog', action: :show, id: doc)
+    end
+
+    context "within bookmarks" do
+      let(:controller_class) { ::BookmarksController.new }
+
+      it "uses polymorphic routing" do
+        expect(search_state.url_for_document(doc)).to eq doc
+      end
+    end
+
+    context "within an alternative catalog controller" do
+      let(:controller_class) { ::AlternateController.new }
+
+      before do
+        search_state.blacklight_config.show.route = { controller: :current }
+        allow(search_state).to receive(:params).and_return(parameter_class.new(controller: 'alternate'))
+      end
+
+      it "supports the :current controller configuration" do
+        expect(search_state.url_for_document(doc)).to eq(controller: 'alternate', action: :show, id: doc)
+      end
+    end
+
+    it "is a polymorphic route if the solr document responds to #to_model with a non-SolrDocument" do
+      some_model = double
+      doc = SolrDocument.new
+      allow(doc).to receive_messages(to_model: some_model)
+      expect(search_state.url_for_document(doc)).to eq doc
+    end
+  end
+
+  describe '#filters' do
+    context 'pivot facet config but no facet params' do
+      it 'maps no filters' do
+        blacklight_config.add_facet_field 'some_key', pivot: %w[pivot_field_1 pivot_field_2]
+        expect(search_state.filters).to eq([])
+      end
+    end
+
+    context 'pivot facet config and some pivot facet params' do
+      let(:params) { { 'f' => { 'pivot_field_1' => 'foo' } } }
+
+      it 'maps the pivot matching param pivot_field' do
+        blacklight_config.add_facet_field 'some_key', pivot: %w[pivot_field_1 pivot_field_2]
+        expect(search_state.filters.count).to eq(1)
+        expect(search_state.filters.first.key).to eq('some_key')
+      end
+    end
+
+    context 'regular facet config with params' do
+      let(:params) { { 'f' => { 'some_key' => 'foo' } } }
+
+      it 'maps the field matching param facet_field' do
+        blacklight_config.add_facet_field 'some_key'
+        expect(search_state.filters.count).to eq(1)
+        expect(search_state.filters.first.key).to eq('some_key')
+      end
+    end
+  end
 end