blacklight 7.13.0 → 7.15.0

data/lib/blacklight/configuration/field.rb

@@ -44,7 +44,7 @@ module Blacklight
 
     def default_label
       if self.key.respond_to?(:titleize)
-        self.key.try(:titleize)
+        self.key.titleize
       else
         self.key.to_s.titleize
       end

data/lib/blacklight/configuration/fields.rb

@@ -151,7 +151,7 @@ module Blacklight
           repository = repository_class.new(self)
           repository.reflect_fields
         rescue => e
-          Blacklight.logger.warn "Error retrieving field metadata: #{e}"
+          Blacklight.logger&.warn "Error retrieving field metadata: #{e}"
           false
         end
 

data/lib/blacklight/configuration/sort_field.rb

@@ -6,7 +6,7 @@ module Blacklight
 
     def normalize! blacklight_config = nil
       super
-      self.field ||= label.try(:parameterize)
+      self.field ||= label&.parameterize
       self.field ||= sort
 
       self.sort ||= self.field

data/lib/blacklight/routes/searchable.rb

@@ -8,6 +8,7 @@ module Blacklight
 
       def call(mapper, _options = {})
         mapper.match '/', action: 'index', as: 'search', via: [:get, :post]
+        mapper.get '/advanced', action: 'advanced_search', as: 'advanced_search'
 
         mapper.post ":id/track", action: 'track', as: 'track'
         mapper.get ":id/raw", action: 'raw', as: 'raw', defaults: { format: 'json' }

data/lib/blacklight/search_builder.rb

@@ -28,6 +28,7 @@ module Blacklight
 
       @blacklight_params = {}
       @search_state = Blacklight::SearchState.new(@blacklight_params, @scope&.blacklight_config, @scope)
+      @additional_filters = {}
       @merged_params = {}
       @reverse_merged_params = {}
     end
@@ -47,6 +48,7 @@ module Blacklight
       params_will_change!
       @search_state = @search_state.reset(@search_state.params.merge(q: conditions))
       @blacklight_params = @search_state.params.dup
+      @additional_filters = conditions
       self
     end
 

data/lib/blacklight/search_state.rb

@@ -82,7 +82,7 @@ module Blacklight
 
     def has_constraints?
       Deprecation.silence(Blacklight::SearchState) do
-        !(query_param.blank? && filter_params.blank? && filters.blank?)
+        !(query_param.blank? && filter_params.blank? && filters.blank? && clause_params.blank?)
       end
     end
 
@@ -90,6 +90,10 @@ module Blacklight
       params[:q]
     end
 
+    def clause_params
+      params[:clause] || {}
+    end
+
     def filter_params
       params[:f] || {}
     end

data/lib/blacklight/search_state/filter_field.rb

@@ -36,12 +36,16 @@ module Blacklight
         end
 
         params = new_state.params
+        param = :f
         value = as_url_parameter(item)
+        param = :f_inclusive if value.is_a?(Array)
 
         # value could be a string
         params[param] = (params[param] || {}).dup
 
-        if config.single
+        if value.is_a? Array
+          params[param][key] = value
+        elsif config.single
           params[param][key] = [value]
         else
           params[param][key] = Array(params[param][key] || []).dup
@@ -60,7 +64,10 @@ module Blacklight
         end
 
         params = new_state.params
+
+        param = :f
         value = as_url_parameter(item)
+        param = :f_inclusive if value.is_a?(Array)
 
         # need to dup the facet values too,
         # if the values aren't dup'd, then the values
@@ -86,7 +93,10 @@ module Blacklight
       # @return [Array] an array of applied filters
       def values
         params = search_state.params
-        Array(params.dig(param, key)) || []
+        f = Array(params.dig(:f, key))
+        f_inclusive = [params.dig(:f_inclusive, key)] if params.dig(:f_inclusive, key).present?
+
+        f + (f_inclusive || [])
       end
       delegate :any?, to: :values
 
@@ -100,15 +110,15 @@ module Blacklight
         value = as_url_parameter(item)
         params = search_state.params
 
-        (params.dig(param, key) || []).include?(value)
+        if value.is_a?(Array)
+          (params.dig(:f_inclusive, key) || []).to_set == value.to_set
+        else
+          (params.dig(:f, key) || []).include?(value)
+        end
       end
 
       private
 
-      def param
-        :f
-      end
-
       # TODO: this code is duplicated in Blacklight::FacetsHelperBehavior
       def as_url_parameter(item)
         if item.respond_to? :value

data/lib/blacklight/solr/repository.rb

@@ -41,7 +41,7 @@ module Blacklight::Solr
     # @return [boolean] true if the repository is reachable
     def ping
       response = connection.send_and_receive 'admin/ping', {}
-      Blacklight.logger.info("Ping [#{connection.uri}] returned: '#{response['status']}'")
+      Blacklight.logger&.info("Ping [#{connection.uri}] returned: '#{response['status']}'")
       response['status'] == "OK"
     end
 
@@ -58,13 +58,22 @@ 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)
 
-        Blacklight.logger.debug("Solr query: #{blacklight_config.http_method} #{path} #{solr_params.to_hash.inspect}")
-        Blacklight.logger.debug("Solr response: #{solr_response.inspect}") if defined?(::BLACKLIGHT_VERBOSE_LOGGING) && ::BLACKLIGHT_VERBOSE_LOGGING
+        Blacklight.logger&.debug("Solr query: #{blacklight_config.http_method} #{path} #{solr_params.to_hash.inspect}")
+        Blacklight.logger&.debug("Solr response: #{solr_response.inspect}") if defined?(::BLACKLIGHT_VERBOSE_LOGGING) && ::BLACKLIGHT_VERBOSE_LOGGING
         solr_response
       end
     rescue Errno::ECONNREFUSED => e

data/lib/blacklight/solr/response.rb

@@ -93,7 +93,7 @@ class Blacklight::Solr::Response < ActiveSupport::HashWithIndifferentAccess
       value.each { |v| force_to_utf8(v) }
     when String
       if value.encoding != Encoding::UTF_8
-        Blacklight.logger.warn "Found a non utf-8 value in Blacklight::Solr::Response. \"#{value}\" Encoding is #{value.encoding}"
+        Blacklight.logger&.warn "Found a non utf-8 value in Blacklight::Solr::Response. \"#{value}\" Encoding is #{value.encoding}"
         value.dup.force_encoding('UTF-8')
       else
         value

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