blacklight 7.13.2 → 7.15.2

data/lib/blacklight/solr/repository.rb

@@ -58,8 +58,17 @@ module Blacklight::Solr
     # @return [Blacklight::Solr::Response] the solr response object
     def send_and_receive(path, solr_params = {})
       benchmark("Solr fetch", level: :debug) do
-        key = blacklight_config.http_method == :post ? :data : :params
-        res = connection.send_and_receive(path, { key => solr_params.to_hash, method: blacklight_config.http_method })
+        res = if solr_params[:json].present?
+                connection.send_and_receive(
+                  path,
+                  data: { params: solr_params.to_hash.except(:json) }.merge(solr_params[:json]).to_json,
+                  method: :post,
+                  headers: { 'Content-Type' => 'application/json' }
+                )
+              else
+                key = blacklight_config.http_method == :post ? :data : :params
+                connection.send_and_receive(path, { key => solr_params.to_hash, method: blacklight_config.http_method })
+              end
 
         solr_response = blacklight_config.response_model.new(res, solr_params, document_model: blacklight_config.document_model, blacklight_config: blacklight_config)
 

data/lib/blacklight/solr/search_builder_behavior.rb

@@ -8,7 +8,8 @@ module Blacklight::Solr
         :default_solr_parameters, :add_query_to_solr, :add_facet_fq_to_solr,
         :add_facetting_to_solr, :add_solr_fields_to_query, :add_paging_to_solr,
         :add_sorting_to_solr, :add_group_config_to_solr,
-        :add_facet_paging_to_solr
+        :add_facet_paging_to_solr, :add_adv_search_clauses,
+        :add_additional_filters
       ]
     end
 
@@ -61,12 +62,62 @@ module Blacklight::Solr
       elsif search_field&.solr_local_parameters.present?
         add_search_field_with_local_parameters(solr_parameters)
       elsif search_state.query_param.is_a? Hash
-        add_multifield_search_query(solr_parameters)
-      elsif blacklight_params[:q]
+        add_additional_filters(solr_parameters, search_state.query_param)
+      elsif search_state.query_param
         solr_parameters[:q] = search_state.query_param
       end
     end
 
+    def add_additional_filters(solr_parameters, additional_filters = nil)
+      q = additional_filters || @additional_filters
+
+      return if q.blank?
+
+      solr_parameters[:q] = if q.values.any?(&:blank?)
+                              # if any field parameters are empty, exclude _all_ results
+                              "{!lucene}NOT *:*"
+                            else
+                              "{!lucene}" + q.map do |field, values|
+                                "#{field}:(#{Array(values).map { |x| solr_param_quote(x) }.join(' OR ')})"
+                              end.join(" AND ")
+                            end
+
+      solr_parameters[:defType] = 'lucene'
+      solr_parameters[:spellcheck] = 'false'
+    end
+
+    # Transform "clause" parameters into the Solr JSON Query DSL
+    def add_adv_search_clauses(solr_parameters)
+      return if search_state.clause_params.blank?
+
+      defaults = { must: [], must_not: [], should: [] }
+      bool_query = (solr_parameters.dig(:json, :query, :bool) || {}).reverse_merge(defaults)
+
+      default_op = blacklight_params[:op]&.to_sym || :must
+
+      search_state.clause_params.each_value do |clause|
+        op, query = adv_search_clause(clause, default_op)
+        bool_query[op] << query if defaults.key?(op) && query
+      end
+
+      return if bool_query.values.all?(&:blank?)
+
+      solr_parameters[:mm] = 1 if default_op == :should
+      solr_parameters[:json] ||= { query: { bool: {} } }
+      solr_parameters[:json][:query] ||= { bool: {} }
+      solr_parameters[:json][:query][:bool] = bool_query.reject { |_k, v| v.blank? }
+    end
+
+    # @return [Array] the first element is the query operator and the second is the value to add
+    def adv_search_clause(clause, default_op)
+      op = clause[:op]&.to_sym || default_op
+      field = (blacklight_config.search_fields || {})[clause[:field]] if clause[:field]
+
+      return unless field&.clause_params && clause[:query].present?
+
+      [op, field.clause_params.transform_values { |v| v.merge(query: clause[:query]) }]
+    end
+
     ##
     # Add any existing facet limits, stored in app-level HTTP query
     # as :f, to solr as appropriate :fq query.
@@ -84,8 +135,13 @@ module Blacklight::Solr
           solr_parameters.merge!(subqueries) if subqueries
         else
           filter.values.reject(&:blank?).each do |value|
-            filter_query, subqueries = facet_value_to_fq_string(filter.config.key, value)
-            solr_parameters.append_filter_query(filter_query)
+            filter_query, subqueries = if value.is_a?(Array)
+                                         facet_inclusive_value_to_fq_string(filter.key, value.reject(&:blank?))
+                                       else
+                                         facet_value_to_fq_string(filter.config.key, value)
+                                       end
+
+            solr_parameters.append_filter_query filter_query
             solr_parameters.merge!(subqueries) if subqueries
           end
         end
@@ -250,16 +306,17 @@ module Blacklight::Solr
 
     ##
     # Convert a facet/value pair into a solr fq parameter
-    def facet_value_to_fq_string(facet_field, value)
+    def facet_value_to_fq_string(facet_field, value, use_local_params: true)
       facet_config = blacklight_config.facet_fields[facet_field]
 
       solr_field = facet_config.field if facet_config && !facet_config.query
       solr_field ||= facet_field
 
       local_params = []
-      local_params << "tag=#{facet_config.tag}" if facet_config && facet_config.tag
 
-      prefix = "{!#{local_params.join(' ')}}" unless local_params.empty?
+      if use_local_params
+        local_params << "tag=#{facet_config.tag}" if facet_config && facet_config.tag
+      end
 
       if facet_config && facet_config.query
         if facet_config.query[value]
@@ -269,12 +326,34 @@ module Blacklight::Solr
           '-*:*'
         end
       elsif value.is_a?(Range)
+        prefix = "{!#{local_params.join(' ')}}" unless local_params.empty?
         "#{prefix}#{solr_field}:[#{value.first} TO #{value.last}]"
       else
         "{!term f=#{solr_field}#{(' ' + local_params.join(' ')) unless local_params.empty?}}#{convert_to_term_value(value)}"
       end
     end
 
+    def facet_inclusive_value_to_fq_string(facet_field, values)
+      return if values.blank?
+
+      return facet_value_to_fq_string(facet_field, values.first) if values.length == 1
+
+      facet_config = blacklight_config.facet_fields[facet_field]
+
+      local_params = []
+      local_params << "tag=#{facet_config.tag}" if facet_config && facet_config.tag
+
+      solr_filters = values.each_with_object({}).with_index do |(v, h), index|
+        h["f_inclusive.#{facet_field}.#{index}"] = facet_value_to_fq_string(facet_field, v, use_local_params: false)
+      end
+
+      filter_query = solr_filters.keys.map do |k|
+        "{!query v=$#{k}}"
+      end.join(' OR ')
+
+      ["{!lucene#{(' ' + local_params.join(' ')) unless local_params.empty?}}#{filter_query}", solr_filters]
+    end
+
     def convert_to_term_value(value)
       if value.is_a?(DateTime) || value.is_a?(Time)
         value.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
@@ -322,20 +401,5 @@ module Blacklight::Solr
       # params!
       solr_parameters["spellcheck.q"] ||= search_state.query_param
     end
-
-    def add_multifield_search_query(solr_parameters)
-      q = search_state.query_param
-      solr_parameters[:q] = if q.values.any?(&:blank?)
-                              # if any field parameters are empty, exclude _all_ results
-                              "{!lucene}NOT *:*"
-                            else
-                              "{!lucene}" + q.map do |field, values|
-                                "#{field}:(#{Array(values).map { |x| solr_param_quote(x) }.join(' OR ')})"
-                              end.join(" AND ")
-                            end
-
-      solr_parameters[:defType] = 'lucene'
-      solr_parameters[:spellcheck] = 'false'
-    end
   end
 end

data/package.json

@@ -1,7 +1,7 @@
 {
   "name": "blacklight-frontend",
   "version": "7.10.0",
-  "description": "[![Build Status](https://travis-ci.org/projectblacklight/blacklight.png?branch=master)](https://travis-ci.org/projectblacklight/blacklight) [![Gem Version](https://badge.fury.io/rb/blacklight.png)](http://badge.fury.io/rb/blacklight) [![Coverage Status](https://coveralls.io/repos/github/projectblacklight/blacklight/badge.svg?branch=master)](https://coveralls.io/github/projectblacklight/blacklight?branch=master)",
+  "description": "[![Build Status](https://travis-ci.com/projectblacklight/blacklight.png?branch=master)](https://travis-ci.com/projectblacklight/blacklight) [![Gem Version](https://badge.fury.io/rb/blacklight.png)](http://badge.fury.io/rb/blacklight) [![Coverage Status](https://coveralls.io/repos/github/projectblacklight/blacklight/badge.svg?branch=master)](https://coveralls.io/github/projectblacklight/blacklight?branch=master)",
   "main": "app/assets/javascripts/blacklight",
   "scripts": {
     "js-compile-bundle": "shx cat app/javascript/blacklight/core.js app/javascript/blacklight/autocomplete.js app/javascript/blacklight/bookmark_toggle.js app/javascript/blacklight/button_focus.js app/javascript/blacklight/checkbox_submit.js app/javascript/blacklight/facet_load.js app/javascript/blacklight/modal.js app/javascript/blacklight/search_context.js | shx sed \"s/^(import|export).*//\" | babel --filename app/javascript/blacklight/blacklight.js > app/assets/javascripts/blacklight/blacklight.js"

data/spec/components/blacklight/advanced_search_form_component_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Blacklight::AdvancedSearchFormComponent, type: :component do
+  subject(:render) do
+    component.render_in(view_context)
+  end
+
+  let(:component) { described_class.new(url: '/whatever', response: response, params: params) }
+  let(:response) { Blacklight::Solr::Response.new({ facet_counts: { facet_fields: { format: { 'Book' => 10, 'CD' => 5 } } } }.with_indifferent_access, {}) }
+  let(:params) { {} }
+
+  let(:rendered) do
+    Capybara::Node::Simple.new(render)
+  end
+
+  let(:view_context) { controller.view_context }
+
+  before do
+    allow(view_context).to receive(:facet_limit_for).and_return(nil)
+  end
+
+  context 'with additional parameters' do
+    let(:params) { { some: :parameter, an_array: [1, 2] } }
+
+    it 'adds additional parameters as hidden fields' do
+      expect(rendered).to have_field 'some', with: 'parameter', type: :hidden
+      expect(rendered).to have_field 'an_array[]', with: '1', type: :hidden
+      expect(rendered).to have_field 'an_array[]', with: '2', type: :hidden
+    end
+  end
+
+  it 'has text fields for each search field' do
+    expect(rendered).to have_selector '.advanced-search-field', count: 4
+    expect(rendered).to have_field 'clause_0_field', with: 'all_fields', type: :hidden
+    expect(rendered).to have_field 'clause_1_field', with: 'title', type: :hidden
+    expect(rendered).to have_field 'clause_2_field', with: 'author', type: :hidden
+    expect(rendered).to have_field 'clause_3_field', with: 'subject', type: :hidden
+  end
+
+  it 'has filters' do
+    expect(rendered).to have_selector '.blacklight-format'
+    expect(rendered).to have_field 'f_inclusive[format][]', with: 'Book'
+    expect(rendered).to have_field 'f_inclusive[format][]', with: 'CD'
+  end
+
+  it 'has a sort field' do
+    expect(rendered).to have_select 'sort', options: %w[relevance year author title]
+  end
+end

data/spec/components/blacklight/constraint_layout_component_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 
 RSpec.describe Blacklight::ConstraintLayoutComponent, type: :component do
   subject(:render) do
-    render_inline(described_class.new(params))
+    render_inline(described_class.new(**params))
   end
 
   let(:rendered) do

data/spec/components/blacklight/document_component_spec.rb

@@ -33,6 +33,8 @@ RSpec.describe Blacklight::DocumentComponent, type: :component do
   end
 
   before do
+    # Every call to view_context returns a different object. This ensures it stays stable.
+    allow(controller).to receive(:view_context).and_return(view_context)
     allow(controller).to receive(:current_or_guest_user).and_return(User.new)
     allow(controller).to receive(:blacklight_config).and_return(blacklight_config)
     allow(view_context).to receive(:search_session).and_return({})
@@ -149,4 +151,19 @@ RSpec.describe Blacklight::DocumentComponent, type: :component do
     expect(rendered).to have_selector 'dd', text: 'Title'
     expect(rendered).not_to have_selector 'dt', text: 'ISBN:'
   end
+
+  context 'with a thumbnail component' do
+    let(:attr) { { thumbnail_component: thumbnail_component_class } }
+    let(:thumbnail_component_class) do
+      Class.new(ViewComponent::Base) do
+        def render_in(view_context)
+          view_context.capture { 'Thumb!' }
+        end
+      end
+    end
+
+    it 'uses the provided thumbnail component' do
+      expect(rendered).to have_content 'Thumb!'
+    end
+  end
 end

data/spec/components/blacklight/facet_field_checkboxes_component_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Blacklight::FacetFieldCheckboxesComponent, type: :component do
+  subject(:render) do
+    render_inline(described_class.new(facet_field: facet_field))
+  end
+
+  let(:rendered) do
+    Capybara::Node::Simple.new(render)
+  end
+
+  let(:facet_field) do
+    instance_double(
+      Blacklight::FacetFieldPresenter,
+      facet_field: Blacklight::Configuration::NullField.new(key: 'field'),
+      paginator: paginator,
+      key: 'field',
+      label: 'Field',
+      active?: false,
+      collapsed?: false,
+      modal_path: nil,
+      html_id: 'facet-field',
+      search_state: search_state
+    )
+  end
+
+  let(:paginator) do
+    instance_double(Blacklight::FacetPaginator, items: [
+                      double(label: 'a', hits: 10, value: 'a'),
+                      double(label: 'b', hits: 33, value: 'b'),
+                      double(label: 'c', hits: 3, value: 'c')
+                    ])
+  end
+
+  let(:search_state) { Blacklight::SearchState.new(params.with_indifferent_access, Blacklight::Configuration.new) }
+  let(:params) { { f: { field: ['a'] } } }
+
+  it 'renders a collapsible card' do
+    expect(rendered).to have_selector '.card'
+    expect(rendered).to have_button 'Field'
+    expect(rendered).to have_selector 'button[data-target="#facet-field"]'
+    expect(rendered).to have_selector '#facet-field.collapse.show'
+  end
+
+  it 'renders the facet items' do
+    expect(rendered).to have_selector 'ul.facet-values'
+    expect(rendered).to have_selector 'li', count: 3
+
+    expect(rendered).to have_field 'f_inclusive[field][]', with: 'a'
+    expect(rendered).to have_field 'f_inclusive[field][]', with: 'b'
+    expect(rendered).to have_field 'f_inclusive[field][]', with: 'c'
+  end
+end

data/spec/components/blacklight/facet_field_list_component_spec.rb

@@ -20,7 +20,8 @@ RSpec.describe Blacklight::FacetFieldListComponent, type: :component do
       active?: false,
       collapsed?: false,
       modal_path: nil,
-      html_id: 'facet-field'
+      html_id: 'facet-field',
+      values: []
     )
   end
 
@@ -53,7 +54,8 @@ RSpec.describe Blacklight::FacetFieldListComponent, type: :component do
         active?: true,
         collapsed?: false,
         modal_path: nil,
-        html_id: 'facet-field'
+        html_id: 'facet-field',
+        values: []
       )
     end
 
@@ -72,7 +74,8 @@ RSpec.describe Blacklight::FacetFieldListComponent, type: :component do
         active?: false,
         collapsed?: true,
         modal_path: nil,
-        html_id: 'facet-field'
+        html_id: 'facet-field',
+        values: []
       )
     end
 
@@ -97,7 +100,8 @@ RSpec.describe Blacklight::FacetFieldListComponent, type: :component do
         active?: false,
         collapsed?: false,
         modal_path: '/catalog/facet/modal',
-        html_id: 'facet-field'
+        html_id: 'facet-field',
+        values: []
       )
     end
 
@@ -105,4 +109,35 @@ RSpec.describe Blacklight::FacetFieldListComponent, type: :component do
       expect(rendered).to have_link 'more Field', href: '/catalog/facet/modal'
     end
   end
+
+  context 'with inclusive facets' do
+    let(:facet_field) do
+      instance_double(
+        Blacklight::FacetFieldPresenter,
+        paginator: paginator,
+        facet_field: Blacklight::Configuration::NullField.new(key: 'field'),
+        key: 'field',
+        label: 'Field',
+        active?: false,
+        collapsed?: false,
+        modal_path: nil,
+        html_id: 'facet-field',
+        values: [%w[a b c]],
+        search_state: search_state
+      )
+    end
+
+    let(:search_state) { Blacklight::SearchState.new(params.with_indifferent_access, Blacklight::Configuration.new) }
+    let(:params) { { f_inclusive: { field: %w[a b c] } } }
+
+    it 'displays the constraint above the list' do
+      expect(rendered).to have_content 'Any of:'
+      expect(rendered).to have_selector '.inclusive_or .facet-label', text: 'a'
+      expect(rendered).to have_link '[remove]', href: 'http://test.host/catalog?f_inclusive%5Bfield%5D%5B%5D=b&f_inclusive%5Bfield%5D%5B%5D=c'
+      expect(rendered).to have_selector '.inclusive_or .facet-label', text: 'b'
+      expect(rendered).to have_link '[remove]', href: 'http://test.host/catalog?f_inclusive%5Bfield%5D%5B%5D=a&f_inclusive%5Bfield%5D%5B%5D=c'
+      expect(rendered).to have_selector '.inclusive_or .facet-label', text: 'c'
+      expect(rendered).to have_link '[remove]', href: 'http://test.host/catalog?f_inclusive%5Bfield%5D%5B%5D=a&f_inclusive%5Bfield%5D%5B%5D=b'
+    end
+  end
 end

data/spec/components/blacklight/hidden_search_state_component_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::HiddenSearchStateComponent, type: :component do
+  subject(:render) { render_inline(instance) }
+
+  let(:params) do
+    { q: "query",
+      search_field: "search_field",
+      per_page: 10,
+      extra_arbitrary_key: "arbitrary_value",
+      f: { field1: %w[a b], field2: ["z"] } }
+  end
+  let(:instance) { described_class.new(params: params) }
+  let(:generated) { Capybara::Node::Simple.new("<div>#{render.to_html}</div>") }
+
+  it "converts a hash with nested complex data to Rails-style hidden form fields" do
+    expect(generated).to have_selector("input[type='hidden'][name='q'][value='query']", visible: :hidden)
+    expect(generated).to have_selector("input[type='hidden'][name='per_page'][value='10']", visible: :hidden)
+    expect(generated).to have_selector("input[type='hidden'][name='extra_arbitrary_key'][value='arbitrary_value']", visible: :hidden)
+    expect(generated).to have_selector("input[type='hidden'][name='f[field2][]'][value='z']", visible: :hidden)
+    expect(generated).to have_selector("input[type='hidden'][name='f[field1][]'][value='a']", visible: :hidden)
+    expect(generated).to have_selector("input[type='hidden'][name='f[field1][]'][value='b']", visible: :hidden)
+  end
+end

data/spec/controllers/catalog_controller_spec.rb

@@ -301,6 +301,15 @@ RSpec.describe CatalogController, api: true do
     end
   end
 
+  describe 'GET advanced_search' do
+    it 'renders an advanced search form' do
+      get :advanced_search
+      expect(response).to be_successful
+
+      assert_facets_have_values(assigns(:response).aggregations)
+    end
+  end
+
   # SHOW ACTION
   describe "show action" do
     describe "with format :html" do