blacklight 9.0.0.beta7 → 9.0.0.beta8

data/spec/presenters/blacklight/field_presenter_spec.rb

@@ -6,6 +6,8 @@ RSpec.describe Blacklight::FieldPresenter, :api do
   let(:request_context) { double('View context', params: { x: '1' }, search_state: search_state, should_render_field?: true, blacklight_config: config) }
   let(:document) do
     SolrDocument.new(id: 1,
+                     'join_true' => %w[a b c],
+                     'separator_options' => %w[d e f],
                      'link_to_facet_true' => 'x',
                      'link_to_facet_named' => 'x',
                      'qwer' => 'document qwer value',
@@ -30,6 +32,8 @@ RSpec.describe Blacklight::FieldPresenter, :api do
     Blacklight::Configuration.new.configure do |config|
       config.add_index_field 'qwer'
       config.add_index_field 'asdf', helper_method: :render_asdf_index_field
+      config.add_index_field 'join_true', join: true
+      config.add_index_field 'separator_options', separator_options: { words_connector: '<br/>', last_word_connector: '<br/>' }
       config.add_index_field 'link_to_facet_true', link_to_facet: true
       config.add_index_field 'link_to_facet_named', link_to_facet: :some_field
       config.add_index_field 'highlight', highlight: true
@@ -40,6 +44,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
       config.add_index_field 'alias', field: 'qwer'
       config.add_index_field 'with_default', default: 'value'
       config.add_index_field 'with_steps', steps: [custom_step]
+      config.add_index_field :some_field
       config.add_facet_field :link_to_facet_true
       config.add_facet_field :some_field
     end
@@ -51,25 +56,33 @@ RSpec.describe Blacklight::FieldPresenter, :api do
     context 'when an explicit html value is provided' do
       let(:options) { { value: '<b>val1</b>' } }
 
-      it { is_expected.not_to be_html_safe }
+      it { is_expected.to eq(['<b>val1</b>']) }
+
+      it 'does not mark value as html_safe' do
+        expect(result.first).not_to be_html_safe
+      end
     end
 
     context 'when an explicit array value with unsafe characters is provided' do
       let(:options) { { value: ['<a', 'b'] } }
 
-      it { is_expected.to eq('&lt;a and b').and be_html_safe }
+      it { is_expected.to eq(%w[<a b]) }
+
+      it 'does not mark values as html_safe' do
+        expect(subject.all?(&:html_safe?)).not_to be true
+      end
     end
 
     context 'when an explicit array value is provided' do
       let(:options) { { value: %w[a b c] } }
 
-      it { is_expected.to eq 'a, b, and c' }
+      it { is_expected.to eq %w[a b c] }
     end
 
     context 'when an explicit value is provided' do
       let(:options) { { value: 'asdf' } }
 
-      it { is_expected.to eq 'asdf' }
+      it { is_expected.to eq ['asdf'] }
     end
 
     context 'when field has a helper method' do
@@ -77,7 +90,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
         allow(request_context).to receive(:render_asdf_index_field).and_return('custom asdf value')
       end
 
-      it { is_expected.to eq 'custom asdf value' }
+      it { is_expected.to eq ['custom asdf value'] }
     end
 
     context 'when field has link_to_facet with true' do
@@ -88,7 +101,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
 
       let(:field_name) { 'link_to_facet_true' }
 
-      it { is_expected.to eq 'bar' }
+      it { is_expected.to eq ['bar'] }
     end
 
     context 'when field has link_to_facet with a field name' do
@@ -99,7 +112,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
 
       let(:field_name) { 'link_to_facet_named' }
 
-      it { is_expected.to eq 'bar' }
+      it { is_expected.to eq ['bar'] }
     end
 
     context 'when no highlight field is available' do
@@ -120,14 +133,14 @@ RSpec.describe Blacklight::FieldPresenter, :api do
 
       let(:field_name) { 'highlight' }
 
-      it { is_expected.to eq '<em>highlight</em>' }
+      it { is_expected.to eq ['<em>highlight</em>'] }
     end
 
     context 'when no options are provided' do
       let(:field_name) { 'qwer' }
 
       it "checks the document field value" do
-        expect(subject).to eq 'document qwer value'
+        expect(subject).to eq ['document qwer value']
       end
     end
 
@@ -138,7 +151,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
 
       let(:field_name) { 'solr_doc_accessor' }
 
-      it { is_expected.to eq '123' }
+      it { is_expected.to eq ['123'] }
     end
 
     context 'when accessor is set to a value' do
@@ -147,7 +160,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
       it 'calls the accessor with the field_name as the argument' do
         expect(document).to receive(:solr_doc_accessor).with('explicit_accessor').and_return("123")
 
-        expect(subject).to eq '123'
+        expect(subject).to eq ['123']
       end
     end
 
@@ -157,7 +170,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
       it 'calls the accessors on the return of the preceeding' do
         allow(document).to receive_message_chain(:solr_doc_accessor, some_method: "123")
 
-        expect(subject).to eq '123'
+        expect(subject).to eq ['123']
       end
     end
 
@@ -165,26 +178,26 @@ RSpec.describe Blacklight::FieldPresenter, :api do
       let(:field_name) { 'explicit_values_with_context' }
 
       it 'calls the accessors on the return of the preceeding' do
-        expect(subject).to eq '1'
+        expect(subject).to eq ['1']
       end
     end
 
     context 'when the field is an alias' do
       let(:field_name) { 'alias' }
 
-      it { is_expected.to eq 'document qwer value' }
+      it { is_expected.to eq ['document qwer value'] }
     end
 
     context 'when the field has a default' do
       let(:field_name) { 'with_default' }
 
-      it { is_expected.to eq 'value' }
+      it { is_expected.to eq ['value'] }
     end
 
     context 'with steps' do
       let(:field_name) { 'with_steps' }
 
-      it { is_expected.to eq 'Static step' }
+      it { is_expected.to eq ['Static step'] }
     end
 
     context 'for a field with the helper_method option' do
@@ -200,12 +213,80 @@ RSpec.describe Blacklight::FieldPresenter, :api do
           args.first
         end
 
-        expect(result).to include :document, :field, :value, :config, :a
-        expect(result[:document]).to eq document
-        expect(result[:field]).to eq 'field_with_helper'
-        expect(result[:value]).to eq ['value']
-        expect(result[:config]).to eq field_config
-        expect(result[:a]).to eq 1
+        expect(result).to contain_exactly({ document: document, field: field_name,
+                                            value: ['value'], config: field_config, a: 1 })
+      end
+    end
+
+    context 'when joining a field' do
+      context 'with join config' do
+        let(:field_name) { :join_true }
+
+        it { is_expected.to eq ['a, b, and c'] }
+
+        it 'marks the value as html_safe' do
+          expect(result.first).to be_html_safe
+        end
+      end
+
+      context 'with separator_options' do
+        let(:field_name) { :separator_options }
+
+        it { is_expected.to eq ['d<br/>e<br/>f'] }
+
+        it 'marks the value as html_safe' do
+          expect(result.first).to be_html_safe
+        end
+      end
+
+      context 'with join option' do
+        let(:options) { { join: true } }
+        let(:field_name) { 'some_field' }
+
+        it { is_expected.to eq ['1 and 2'] }
+
+        it 'marks the value as html_safe' do
+          expect(result.first).to be_html_safe
+        end
+      end
+    end
+
+    context 'with a single value' do
+      let(:options) { { join: true, value: 1 } }
+
+      it 'is not joined' do
+        expect(result).to eq [1]
+      end
+    end
+
+    context 'with a single html value' do
+      let(:options) { { join: true, value: '<b>value</b>' } }
+
+      it { is_expected.to eq ['<b>value</b>'] }
+
+      it 'does not mark the value as html_safe' do
+        expect(result.first).not_to be_html_safe
+      end
+    end
+
+    context 'when an array containing unsafe characters provided' do
+      let(:options) { { join: true, value: ['<a', 'b'] } }
+
+      it 'html escapes the unsafe characters' do
+        expect(result).to eq ["&lt;a and b"]
+      end
+
+      it 'marks the value as html_safe' do
+        expect(result.first).to be_html_safe
+      end
+    end
+
+    context 'when outside the html context' do
+      let(:field_name) { :join_true }
+      let(:options) { { format: 'json' } }
+
+      it 'does not join the values' do
+        expect(result).to eq %w[a b c]
       end
     end
   end

data/spec/presenters/blacklight/rendering/pipeline_spec.rb

@@ -12,20 +12,15 @@ RSpec.describe Blacklight::Rendering::Pipeline do
     let(:values) { %w[a b] }
     let(:field_config) { Blacklight::Configuration::NullField.new }
 
-    it { is_expected.to eq "a and b" }
-
-    context "when separator_options are in the config" do
-      let(:values) { %w[c d] }
-      let(:field_config) { Blacklight::Configuration::NullField.new(itemprop: nil, separator_options: { two_words_connector: '; ' }) }
-
-      it { is_expected.to eq "c; d" }
-    end
+    it { is_expected.to eq %w[a b] }
 
     context "when itemprop is in the config" do
       let(:values) { ['a'] }
       let(:field_config) { Blacklight::Configuration::NullField.new(itemprop: 'some-prop', separator_options: nil) }
 
-      it { is_expected.to have_css("span[@itemprop='some-prop']", text: "a") }
+      it 'renders the expected markup' do
+        expect(rendered.first).to have_css("span[@itemprop='some-prop']", text: "a")
+      end
     end
 
     it 'sets the operations on the instance as equal to the class variable' do
@@ -37,13 +32,134 @@ RSpec.describe Blacklight::Rendering::Pipeline do
     end
 
     context 'outside of an HTML context' do
-      let(:options) { { format: 'text' } }
+      context 'when options determines format' do
+        let(:options) { { format: 'text' } }
+
+        let(:values) { ['"blah"', "<notatag>"] }
+        let(:field_config) { Blacklight::Configuration::NullField.new itemprop: 'some-prop' }
+
+        it 'does not HTML escape values or inject HTML tags' do
+          expect(rendered).to eq ['"blah"', "<notatag>"]
+        end
+      end
+
+      context 'when context determines format' do
+        let(:values) { ['"blah"', "<notatag>"] }
+        let(:field_config) { Blacklight::Configuration::NullField.new itemprop: 'some-prop' }
+        let(:controller) { CatalogController.new }
+        let(:search_state) { Blacklight::SearchState.new({ format: 'text' }, controller.blacklight_config, controller) }
+
+        before { allow(context).to receive(:search_state).and_return(search_state) }
+
+        it 'does not HTML escape values or inject HTML tags' do
+          expect(rendered).to eq ['"blah"', '<notatag>']
+        end
+      end
+    end
+
+    context 'when link_to_facet is in the config' do
+      let(:values) { %w[book manuscript] }
+      let(:field_config) { Blacklight::Configuration::Field.new(field: 'format', key: 'format', link_to_facet: true) }
+      let(:controller) { CatalogController.new }
+      let(:search_state) { Blacklight::SearchState.new({}, controller.blacklight_config, controller) }
+
+      before do
+        allow(context).to receive(:search_state).and_return(search_state)
+        allow(context).to receive(:search_action_path) { |f| "/catalog?f[format][]=#{f['f']['format'].first}" }
+        allow(context).to receive(:link_to) { |value, link|  ActiveSupport::SafeBuffer.new("<a href=#{link}>#{value}</a>") }
+      end
+
+      it 'renders html' do
+        expect(rendered).to eq ["<a href=/catalog?f[format][]=book>book</a>", "<a href=/catalog?f[format][]=manuscript>manuscript</a>"]
+      end
+
+      context 'outside html context' do
+        let(:values) { %w[book manuscript] }
+        let(:field_config) { Blacklight::Configuration::Field.new(field: 'format', link_to_facet: true) }
+        let(:search_state) { Blacklight::SearchState.new({ format: 'json' }, CatalogController.blacklight_config, CatalogController.new) }
+
+        it 'does not render html' do
+          expect(rendered).to eq %w[book manuscript]
+        end
+      end
+    end
+
+    context 'when joining values' do
+      context 'with join in the config' do
+        let(:field_config) { Blacklight::Configuration::NullField.new(join: true) }
+
+        it 'joins the values' do
+          expect(rendered).to eq ['a and b']
+        end
+      end
+
+      context 'with join is in the options' do
+        let(:options) { { join: true } }
+        let(:field_config) { Blacklight::Configuration::NullField.new }
+
+        it 'joins the values' do
+          expect(rendered).to eq ['a and b']
+        end
+      end
+
+      context 'with separator_options in the config' do
+        let(:values) { %w[c d] }
+        let(:field_config) { Blacklight::Configuration::NullField.new(separator_options: { two_words_connector: '; ' }) }
+
+        it { is_expected.to eq ["c; d"] }
+      end
+
+      context 'with a single value' do
+        let(:values) { [1] }
+        let(:field_config) { Blacklight::Configuration::NullField.new(join: true) }
+
+        it 'does not run the join step' do
+          expect(rendered).to eq [1]
+        end
+      end
+
+      context 'with a single html value' do
+        let(:values) { ['<b>value</b>'] }
+        let(:field_config) { Blacklight::Configuration::NullField.new(join: true) }
+
+        it 'does not escape the html' do
+          expect(rendered).to eq ['<b>value</b>']
+        end
+
+        it 'does not mark the value as html_safe' do
+          expect(rendered.first).not_to be_html_safe
+        end
+      end
+
+      context 'with an array of values containing unsafe characters' do
+        let(:values) { ['<a', 'b'] }
+        let(:field_config) { Blacklight::Configuration::NullField.new(join: true) }
+
+        it 'escapes the unsafe characters' do
+          expect(rendered).to eq ["&lt;a and b"]
+        end
+
+        it 'marks the joined value as html_safe' do
+          expect(rendered.first).to be_html_safe
+        end
+      end
+
+      context 'outside the html context' do
+        let(:values) { %w[a b <c] }
+        let(:field_config) { Blacklight::Configuration::Field.new(join: true) }
+        let(:options) { { format: 'json' } }
+
+        it 'does not run the join step' do
+          expect(rendered).to eq %w[a b <c]
+        end
 
-      let(:values) { ['"blah"', "<notatag>"] }
-      let(:field_config) { Blacklight::Configuration::NullField.new itemprop: 'some-prop' }
+        it 'does not escape unsafe html characters' do
+          expect(rendered.last).to eq '<c'
+        end
 
-      it 'does not HTML escape values or inject HTML tags' do
-        expect(rendered).to eq '"blah" and <notatag>'
+        it 'does not mark the values as html_safe' do
+          expect(rendered.none?(&:html_safe?)).to be true
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: blacklight
 version: !ruby/object:Gem::Version
-  version: 9.0.0.beta7
+  version: 9.0.0.beta8
 platform: ruby
 authors:
 - Jonathan Rochkind
@@ -738,7 +738,6 @@ files:
 - app/views/shared/_flash_msg.html.erb
 - app/views/shared/_footer.html.erb
 - app/views/shared/_modal.html.erb
-- app/views/shared/_sitelinks_search_box.html.erb
 - app/views/shared/_user_util_links.html.erb
 - blacklight.gemspec
 - compose.yaml
@@ -799,6 +798,7 @@ files:
 - lib/blacklight/solr/document.rb
 - lib/blacklight/solr/facet_paginator.rb
 - lib/blacklight/solr/facet_search_builder_behavior.rb
+- lib/blacklight/solr/field_reflection_search_builder.rb
 - lib/blacklight/solr/repository.rb
 - lib/blacklight/solr/request.rb
 - lib/blacklight/solr/response.rb
@@ -811,6 +811,7 @@ files:
 - lib/blacklight/solr/response/response.rb
 - lib/blacklight/solr/response/spelling.rb
 - lib/blacklight/solr/search_builder_behavior.rb
+- lib/blacklight/solr/single_doc_search_builder.rb
 - lib/blacklight/version.rb
 - lib/generators/blacklight/assets/importmap_generator.rb
 - lib/generators/blacklight/assets/propshaft_generator.rb
@@ -911,7 +912,6 @@ files:
 - spec/features/search_results_spec.rb
 - spec/features/search_sort_spec.rb
 - spec/features/search_spec.rb
-- spec/features/sitelinks_search_box_spec.rb
 - spec/features/sms_spec.rb
 - spec/fixtures/sample_solr_documents.yml
 - spec/helpers/blacklight/configuration_helper_behavior_spec.rb
@@ -1031,7 +1031,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.1
 specification_version: 4
 summary: Blacklight provides a discovery interface for any Solr (http://lucene.apache.org/solr)
   index.
@@ -1096,7 +1096,6 @@ test_files:
 - spec/features/search_results_spec.rb
 - spec/features/search_sort_spec.rb
 - spec/features/search_spec.rb
-- spec/features/sitelinks_search_box_spec.rb
 - spec/features/sms_spec.rb
 - spec/fixtures/sample_solr_documents.yml
 - spec/helpers/blacklight/configuration_helper_behavior_spec.rb

data/app/views/shared/_sitelinks_search_box.html.erb

@@ -1,12 +0,0 @@
-<script type="application/ld+json">
-  {
-    "@context": "http://schema.org",
-    "@type": "WebSite",
-    "url": "<%= root_url %>",
-    "potentialAction": {
-      "@type": "SearchAction",
-      "target": "<%= root_url %>?q={search_term_string}",
-      "query-input": "required name=search_term_string"
-    }
-  }
-</script>

data/spec/features/sitelinks_search_box_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe 'Sitelinks search box' do
-  it 'is home page' do
-    visit root_path
-    expect(page).to have_css 'script[type="application/ld+json"]', visible: :hidden
-  end
-
-  it 'on search page' do
-    visit search_catalog_path q: 'book'
-    expect(page).to have_no_css 'script[type="application/ld+json"]', visible: :hidden
-  end
-end