blacklight 7.37.0 → 8.0.0.beta1

data/spec/helpers/blacklight_helper_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 RSpec.describe BlacklightHelper do
   before do
     allow(helper).to receive(:current_or_guest_user).and_return(User.new)
@@ -16,7 +17,7 @@ RSpec.describe BlacklightHelper do
       expect(application_name).to eq "Blacklight"
     end
 
-    context "when the language is not english " do
+    context "when the language is not english" do
       around do |example|
         I18n.locale = :de
         example.run
@@ -72,7 +73,7 @@ RSpec.describe BlacklightHelper do
     end
 
     before do
-      allow(helper).to receive(:presenter).and_return(presenter)
+      allow(helper).to receive(:document_presenter).and_return(presenter)
       allow(helper).to receive(:blacklight_config).and_return(blacklight_config)
     end
 
@@ -131,104 +132,6 @@ RSpec.describe BlacklightHelper do
         expect(helper.render_index_doc_actions(document)).to be_blank
       end
     end
-
-    describe "render_show_doc_actions" do
-      it "renders partials" do
-        response = helper.render_show_doc_actions(document)
-        expect(response).to have_selector(".bookmark-toggle")
-      end
-    end
-  end
-
-  describe "#should_render_index_field?" do
-    before do
-      allow(helper).to receive_messages(should_render_field?: true, document_has_value?: true)
-    end
-
-    it "is true" do
-      expect(Deprecation).to receive(:warn)
-      expect(helper.should_render_index_field?(double, double)).to be true
-    end
-
-    it "is false if the document doesn't have a value for the field" do
-      expect(Deprecation).to receive(:warn)
-      allow(helper).to receive_messages(document_has_value?: false)
-      expect(helper.should_render_index_field?(double, double)).to be false
-    end
-
-    it "is false if the configuration has the field disabled" do
-      expect(Deprecation).to receive(:warn)
-      allow(helper).to receive_messages(should_render_field?: false)
-      expect(helper.should_render_index_field?(double, double)).to be false
-    end
-  end
-
-  describe "#should_render_show_field?" do
-    before do
-      allow(helper).to receive_messages(should_render_field?: true, document_has_value?: true)
-    end
-
-    it "is true" do
-      expect(Deprecation).to receive(:warn)
-      expect(helper.should_render_show_field?(double, double)).to be true
-    end
-
-    it "is false if the document doesn't have a value for the field" do
-      expect(Deprecation).to receive(:warn)
-      allow(helper).to receive_messages(document_has_value?: false)
-      expect(helper.should_render_show_field?(double, double)).to be false
-    end
-
-    it "is false if the configuration has the field disabled" do
-      expect(Deprecation).to receive(:warn)
-      allow(helper).to receive_messages(should_render_field?: false)
-      expect(helper.should_render_show_field?(double, double)).to be false
-    end
-  end
-
-  describe "#document_has_value?" do
-    let(:doc) { double(SolrDocument) }
-
-    before { allow(Deprecation).to receive(:warn) }
-
-    it "ifs the document has the field value" do
-      allow(doc).to receive(:has?).with('asdf').and_return(true)
-      field_config = double(field: 'asdf')
-      expect(helper.document_has_value?(doc, field_config)).to eq true
-    end
-
-    it "ifs the document has a highlight field value" do
-      allow(doc).to receive(:has?).with('asdf').and_return(false)
-      allow(doc).to receive(:has_highlight_field?).with('asdf').and_return(true)
-      field_config = double(field: 'asdf', highlight: true)
-      expect(helper.document_has_value?(doc, field_config)).to eq true
-    end
-
-    it "ifs the field has a model accessor" do
-      allow(doc).to receive(:has?).with('asdf').and_return(false)
-      allow(doc).to receive(:has_highlight_field?).with('asdf').and_return(false)
-      field_config = double(field: 'asdf', highlight: true, accessor: true)
-      expect(helper.document_has_value?(doc, field_config)).to eq true
-    end
-  end
-
-  describe '#render_index_field_label' do
-    around { |test| Deprecation.silence(Blacklight::BlacklightHelperBehavior) { test.call } }
-
-    let(:doc) { SolrDocument.new({}) }
-
-    before do
-      allow(helper).to receive_messages(document_index_view_type: :current_view)
-    end
-
-    it 'accepts an explicit field label' do
-      expect(helper.render_index_field_label(doc, field: 'xyz', label: 'some label')).to eq 'some label:'
-    end
-
-    it 'calculates the appropriate field label for a field' do
-      allow(helper).to receive(:blacklight_config).and_return(CatalogController.blacklight_config)
-      expect(helper.render_index_field_label(doc, field: 'xyz')).to eq 'Xyz:'
-    end
   end
 
   describe "render_grouped_response?" do
@@ -243,43 +146,6 @@ RSpec.describe BlacklightHelper do
     end
   end
 
-  describe "render_grouped_document_index" do
-    pending 'not implemented'
-  end
-
-  describe "should_show_spellcheck_suggestions?" do
-    around { |test| Deprecation.silence(Blacklight::BlacklightHelperBehavior) { test.call } }
-
-    before do
-      allow(helper).to receive_messages spell_check_max: 5
-    end
-
-    it "does not show suggestions if there are enough results" do
-      response = double(total: 10)
-      expect(helper.should_show_spellcheck_suggestions?(response)).to be false
-    end
-
-    it "only shows suggestions if there are very few results" do
-      response = double(total: 4, spelling: double(words: [1]))
-      expect(helper.should_show_spellcheck_suggestions?(response)).to be true
-    end
-
-    it "only shows suggestions from collations" do
-      response = double(total: 4, spelling: double(words: [], collation: { blah: 1 }))
-      expect(helper.should_show_spellcheck_suggestions?(response)).to be true
-    end
-
-    it "shows suggestions only if there are spelling suggestions available" do
-      response = double(total: 4, spelling: double(words: [], collation: nil))
-      expect(helper.should_show_spellcheck_suggestions?(response)).to be false
-    end
-
-    it "does not show suggestions if spelling is not available" do
-      response = double(total: 4, spelling: nil)
-      expect(helper.should_show_spellcheck_suggestions?(response)).to be false
-    end
-  end
-
   describe "#opensearch_description_tag" do
     subject { helper.opensearch_description_tag 'title', 'href' }
 
@@ -331,17 +197,12 @@ RSpec.describe BlacklightHelper do
         blacklight_config.view.gallery(template: '/my/partial')
       end
 
+      def stub_template(hash)
+        view.view_paths.unshift(ActionView::FixtureResolver.new(hash))
+      end
+
       it 'renders that template' do
-        # Not sure why we need to re-implement rspec's stub_template, but
-        # we already were, and need a Rails 7.1+ safe alternate too
-        # https://github.com/rspec/rspec-rails/commit/4d65bea0619955acb15023b9c3f57a3a53183da8
-        # https://github.com/rspec/rspec-rails/issues/2696
-        replace_hash = { 'my/_partial.html.erb' => 'some content' }
-        if ::Rails.version.to_f >= 7.1
-          controller.prepend_view_path(RSpec::Rails::ViewExampleGroup::StubResolverCache.resolver_for(replace_hash))
-        else
-          view.view_paths.unshift(ActionView::FixtureResolver.new(replace_hash))
-        end
+        stub_template 'my/_partial.html.erb' => 'some content'
 
         response = helper.render_document_index_with_view :gallery, [obj1, obj1]
 
@@ -393,109 +254,4 @@ RSpec.describe BlacklightHelper do
       end
     end
   end
-
-  context "related classes" do
-    let(:presenter_class) { double }
-    let(:blacklight_config) { Blacklight::Configuration.new }
-
-    around { |test| Deprecation.silence(Blacklight::BlacklightHelperBehavior) { test.call } }
-
-    before do
-      allow(helper).to receive(:blacklight_config).and_return(blacklight_config)
-    end
-
-    describe "#index_presenter_class" do
-      it "uses the value defined in the blacklight configuration" do
-        blacklight_config.index.document_presenter_class = presenter_class
-        expect(helper.index_presenter_class(nil)).to eq presenter_class
-      end
-
-      it "defaults to Blacklight::IndexPresenter" do
-        expect(helper.index_presenter_class(nil)).to eq Blacklight::IndexPresenter
-      end
-    end
-
-    describe "#show_presenter_class" do
-      it "uses the value defined in the blacklight configuration" do
-        blacklight_config.show.document_presenter_class = presenter_class
-        expect(helper.show_presenter_class(nil)).to eq presenter_class
-      end
-
-      it "defaults to Blacklight::DocumentPresenter" do
-        expect(helper.show_presenter_class(nil)).to eq Blacklight::ShowPresenter
-      end
-    end
-  end
-
-  describe "#render_document_heading" do
-    around { |test| Deprecation.silence(Blacklight::BlacklightHelperBehavior) { test.call } }
-
-    let(:document) { double }
-
-    before do
-      allow(helper).to receive(:presenter).and_return(double(heading: "Heading"))
-    end
-
-    it "accepts no arguments and render the document heading" do
-      expect(helper.render_document_heading).to have_selector "h4", text: "Heading"
-    end
-
-    it "accepts the tag name as an option" do
-      expect(helper.render_document_heading(tag: "h1")).to have_selector "h1", text: "Heading"
-    end
-
-    it "accepts an explicit document argument" do
-      allow(helper).to receive(:presenter).with(document).and_return(double(heading: "Document Heading"))
-      expect(helper.render_document_heading(document)).to have_selector "h4", text: "Document Heading"
-    end
-
-    it "accepts the document with a tag option" do
-      allow(helper).to receive(:presenter).with(document).and_return(double(heading: "Document Heading"))
-      expect(helper.render_document_heading(document, tag: "h3")).to have_selector "h3", text: "Document Heading"
-    end
-  end
-
-  describe "#presenter" do
-    around { |test| Deprecation.silence(Blacklight::BlacklightHelperBehavior) { test.call } }
-
-    let(:document) { double }
-
-    before do
-      allow(helper).to receive(:index_presenter).and_return(:index_presenter)
-      allow(helper).to receive(:show_presenter).and_return(:show_presenter)
-      allow(helper).to receive(:action_name).and_return(action_name)
-    end
-
-    context "action is show" do
-      let(:action_name) { "show" }
-
-      it "uses the show presenter" do
-        expect(helper.presenter(document)).to eq(:show_presenter)
-      end
-    end
-
-    context "action is citation" do
-      let(:action_name) { "citation" }
-
-      it "uses the show presenter" do
-        expect(helper.presenter(document)).to eq(:show_presenter)
-      end
-    end
-
-    context "action is index" do
-      let(:action_name) { "index" }
-
-      it "uses the index presenter" do
-        expect(helper.presenter(document)).to eq(:index_presenter)
-      end
-    end
-
-    context "action is foo" do
-      let(:action_name) { "foo" }
-
-      it "uses the index presenter (by default)" do
-        expect(helper.presenter(document)).to eq(:index_presenter)
-      end
-    end
-  end
 end

data/spec/helpers/catalog_helper_spec.rb

@@ -164,111 +164,6 @@ RSpec.describe CatalogHelper do
     end
   end
 
-  describe "should_autofocus_on_search_box?" do
-    before do
-      allow(Deprecation).to receive(:warn)
-    end
-
-    it "is focused if we're on a catalog-like index page without query or facet parameters" do
-      allow(helper).to receive_messages(controller: CatalogController.new, action_name: "index", has_search_parameters?: false)
-      expect(helper.should_autofocus_on_search_box?).to be true
-    end
-
-    it "does not be focused if we're not on a catalog controller" do
-      allow(helper).to receive_messages(controller: ApplicationController.new)
-      expect(helper.should_autofocus_on_search_box?).to be false
-    end
-
-    it "does not be focused if we're not on a catalog controller index" do
-      allow(helper).to receive_messages(controller: CatalogController.new, action_name: "show")
-      expect(helper.should_autofocus_on_search_box?).to be false
-    end
-
-    it "does not be focused if a search parameters are provided" do
-      allow(helper).to receive_messages(controller: CatalogController.new, action_name: "index", has_search_parameters?: true)
-      expect(helper.should_autofocus_on_search_box?).to be false
-    end
-  end
-
-  describe "has_thumbnail?" do
-    before do
-      allow(Deprecation).to receive(:warn)
-    end
-
-    let(:document) { SolrDocument.new(data) }
-    let(:data) { {} }
-
-    it "has a thumbnail if a thumbnail_method is configured" do
-      allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(thumbnail_method: :xyz, document_presenter_class: Blacklight::IndexPresenter)))
-      expect(helper.has_thumbnail?(document)).to be true
-    end
-
-    context "if a thumbnail_field is configured and it exists in the document" do
-      let(:data) { { xyz: 'abc' } }
-
-      it "has a thumbnail" do
-        allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(thumbnail_field: :xyz, document_presenter_class: Blacklight::IndexPresenter)))
-        expect(helper.has_thumbnail?(document)).to be true
-      end
-    end
-
-    it "does not have a thumbnail if the thumbnail_field is missing from the document" do
-      allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(thumbnail_field: :xyz, document_presenter_class: Blacklight::IndexPresenter)))
-      allow(document).to receive_messages(has?: false)
-      expect(helper.has_thumbnail?(document)).to be false
-    end
-
-    it "does not have a thumbnail if none of the fields are configured" do
-      allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(document_presenter_class: Blacklight::IndexPresenter)))
-      expect(helper).not_to have_thumbnail(document)
-    end
-  end
-
-  describe "render_thumbnail_tag" do
-    let(:index_presenter) do
-      instance_double(Blacklight::IndexPresenter, thumbnail: thumbnail_presenter)
-    end
-    let(:thumbnail_presenter) { instance_double(Blacklight::ThumbnailPresenter) }
-
-    before do
-      allow(Deprecation).to receive(:warn)
-      allow(helper).to receive(:index_presenter).with(document).and_return(index_presenter)
-    end
-
-    let(:document) { instance_double(SolrDocument) }
-
-    it "calls thumbnail presenter with default values" do
-      expect(thumbnail_presenter).to receive(:thumbnail_tag).with({}, {})
-      helper.render_thumbnail_tag document
-    end
-
-    it "calls thumbnail presenter with provided values" do
-      expect(thumbnail_presenter).to receive(:thumbnail_tag).with({}, { suppress_link: true })
-      helper.render_thumbnail_tag document, {}, suppress_link: true
-    end
-  end
-
-  describe "thumbnail_url" do
-    before do
-      allow(Deprecation).to receive(:warn)
-    end
-
-    it "pulls the configured thumbnail field out of the document" do
-      allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(thumbnail_field: :xyz)))
-      document = instance_double(SolrDocument)
-      allow(document).to receive(:has?).with(:xyz).and_return(true)
-      allow(document).to receive(:first).with(:xyz).and_return("asdf")
-      expect(helper.thumbnail_url(document)).to eq("asdf")
-    end
-
-    it "returns nil if the thumbnail field doesn't exist" do
-      allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(thumbnail_field: :xyz)))
-      document = instance_double(SolrDocument)
-      allow(document).to receive(:has?).with(:xyz).and_return(false)
-      expect(helper.thumbnail_url(document)).to be_nil
-    end
-  end
-
   describe "document_counter_with_offset" do
     it "renders the document index with the appropriate offset" do
       assign(:response, instance_double(Blacklight::Solr::Response, start: 0, grouped?: false))
@@ -299,32 +194,32 @@ RSpec.describe CatalogHelper do
 
     it "pulls data out of a document's field" do
       blacklight_config.index.display_type_field = :type
-      doc = { type: 'book' }
+      doc = { type: 'book' }.with_indifferent_access
       expect(helper.render_document_class(doc)).to eq "blacklight-book"
     end
 
     it "supports multivalued fields" do
       blacklight_config.index.display_type_field = :type
-      doc = { type: %w[book mss] }
+      doc = { type: %w[book mss] }.with_indifferent_access
       expect(helper.render_document_class(doc)).to eq "blacklight-book blacklight-mss"
     end
 
     it "supports empty fields" do
       blacklight_config.index.display_type_field = :type
-      doc = { type: [] }
+      doc = { type: [] }.with_indifferent_access
       expect(helper.render_document_class(doc)).to be_blank
     end
 
     it "supports missing fields" do
       blacklight_config.index.display_type_field = :type
-      doc = {}
+      doc = {}.with_indifferent_access
       expect(helper.render_document_class(doc)).to be_blank
     end
 
     it "supports view-specific field configuration" do
       allow(helper).to receive(:document_index_view_type).and_return(:some_view_type)
       blacklight_config.view.some_view_type(display_type_field: :other_type)
-      doc = { other_type: "document" }
+      doc = { other_type: "document" }.with_indifferent_access
       expect(helper.render_document_class(doc)).to eq "blacklight-document"
     end
   end
@@ -338,11 +233,11 @@ RSpec.describe CatalogHelper do
     end
 
     it "is bookmarked if the document is in the bookmarks" do
-      expect(helper.bookmarked?(bookmarked_document)).to eq true
+      expect(helper.bookmarked?(bookmarked_document)).to be true
     end
 
     it "does not be bookmarked if the document is not listed in the bookmarks" do
-      expect(helper.bookmarked?(SolrDocument.new(id: 'b'))).to eq false
+      expect(helper.bookmarked?(SolrDocument.new(id: 'b'))).to be false
     end
   end
 
@@ -388,11 +283,5 @@ RSpec.describe CatalogHelper do
 
       it { is_expected.to eq "foobar / Format: Book" }
     end
-
-    context 'when the f param is not an array' do
-      let(:params) { ActionController::Parameters.new(q: 'foobar', f: { format: 'Book' }) }
-
-      it { is_expected.to eq "foobar / Format: Book" }
-    end
   end
 end

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/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