blacklight 7.16.0 → 7.17.0

data/lib/blacklight/solr/search_builder_behavior.rb

@@ -66,7 +66,7 @@ module Blacklight::Solr
       elsif search_state.query_param.is_a? Hash
         add_additional_filters(solr_parameters, search_state.query_param)
       elsif search_state.query_param
-        solr_parameters[:q] = search_state.query_param
+        solr_parameters.append_query search_state.query_param
       end
     end
 
@@ -75,14 +75,16 @@ module Blacklight::Solr
 
       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
+      if q.values.any?(&:blank?)
+        # if any field parameters are empty, exclude _all_ results
+        solr_parameters.append_query "{!lucene}NOT *:*"
+      else
+        composed_query = q.map do |field, values|
+          "#{field}:(#{Array(values).map { |x| solr_param_quote(x) }.join(' OR ')})"
+        end.join(" AND ")
+
+        solr_parameters.append_query "{!lucene}#{composed_query}"
+      end
 
       solr_parameters[:defType] = 'lucene'
       solr_parameters[:spellcheck] = 'false'
@@ -91,9 +93,7 @@ module Blacklight::Solr
     def add_search_field_with_json_query_parameters(solr_parameters)
       bool_query = search_field.clause_params.transform_values { |v| v.merge(query: search_state.query_param) }
 
-      solr_parameters[:json] ||= { query: { bool: { must: [] } } }
-      solr_parameters[:json][:query] ||= { bool: { must: [] } }
-      solr_parameters[:json][:query][:bool][:must] << bool_query
+      solr_parameters.append_boolean_query(:must, bool_query)
     end
 
     # Transform "clause" parameters into the Solr JSON Query DSL
@@ -101,21 +101,15 @@ module Blacklight::Solr
       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
+      solr_parameters[:mm] = 1 if default_op == :should && search_state.clause_params.values.any? { |clause| }
 
       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?)
+        next unless defaults.key?(op)
 
-      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? }
+        solr_parameters.append_boolean_query(op, query)
+      end
     end
 
     # @return [Array] the first element is the query operator and the second is the value to add
@@ -141,7 +135,7 @@ module Blacklight::Solr
         if filter.config.filter_query_builder
           filter_query, subqueries = filter.config.filter_query_builder.call(self, filter, solr_parameters)
 
-          solr_parameters.append_filter_query(filter_query)
+          solr_parameters.append_filter_query(filter_query) if filter_query
           solr_parameters.merge!(subqueries) if subqueries
         else
           filter.values.reject(&:blank?).each do |value|
@@ -158,6 +152,21 @@ module Blacklight::Solr
       end
     end
 
+    def add_solr_facet_json_params(solr_parameters, field_name, facet, **additional_parameters)
+      solr_parameters[:json] ||= { facet: {} }
+      solr_parameters[:json][:facet] ||= {}
+
+      field_config = facet.json.respond_to?(:reverse_merge) ? facet.json : {}
+
+      field_config = field_config.reverse_merge(
+        type: 'terms',
+        field: facet.field,
+        limit: facet_limit_with_pagination(field_name)
+      ).merge(additional_parameters)
+
+      solr_parameters[:json][:facet][field_name] = field_config.select { |_k, v| v.present? }
+    end
+
     ##
     # Add appropriate Solr facetting directives in, including
     # taking account of our facet paging/'more'.  This is not
@@ -166,6 +175,11 @@ module Blacklight::Solr
       facet_fields_to_include_in_request.each do |field_name, facet|
         solr_parameters[:facet] ||= true
 
+        if facet.json
+          add_solr_facet_json_params(solr_parameters, field_name, facet)
+          next
+        end
+
         if facet.pivot
           solr_parameters.append_facet_pivot with_ex_local_param(facet.ex, facet.pivot.join(","))
         elsif facet.query
@@ -235,9 +249,7 @@ module Blacklight::Solr
 
       facet_config = blacklight_config.facet_fields[facet]
 
-      # Now override with our specific things for fetching facet values
-      facet_ex = facet_config.respond_to?(:ex) ? facet_config.ex : nil
-      solr_params[:"facet.field"] = with_ex_local_param(facet_ex, facet_config.field)
+      solr_params[:rows] = 0
 
       limit = if solr_params["facet.limit"]
                 solr_params["facet.limit"].to_i
@@ -250,13 +262,21 @@ module Blacklight::Solr
       prefix = search_state.facet_prefix
       offset = (page - 1) * limit
 
+      if facet_config.json
+        add_solr_facet_json_params(solr_parameters, facet, facet_config, limit: limit + 1, offset: offset, sort: sort, prefix: prefix)
+        return
+      end
+
+      # Now override with our specific things for fetching facet values
+      facet_ex = facet_config.respond_to?(:ex) ? facet_config.ex : nil
+      solr_params[:"facet.field"] = with_ex_local_param(facet_ex, facet_config.field)
+
       # Need to set as f.facet_field.facet.* to make sure we
       # override any field-specific default in the solr request handler.
       solr_params[:"f.#{facet_config.field}.facet.limit"] = limit + 1
       solr_params[:"f.#{facet_config.field}.facet.offset"] = offset
       solr_params[:"f.#{facet_config.field}.facet.sort"] = sort if sort
       solr_params[:"f.#{facet_config.field}.facet.prefix"] = prefix if prefix
-      solr_params[:rows] = 0
     end
 
     def with_ex_local_param(ex, value)
@@ -395,7 +415,7 @@ module Blacklight::Solr
     def add_search_field_query_builder_params(solr_parameters)
       q, additional_parameters = search_field.query_builder.call(self, search_field, solr_parameters)
 
-      solr_parameters[:q] = q
+      solr_parameters.append_query q
       solr_parameters.merge!(additional_parameters) if additional_parameters
     end
 
@@ -403,7 +423,7 @@ module Blacklight::Solr
       local_params = search_field.solr_local_parameters.map do |key, val|
         key.to_s + "=" + solr_param_quote(val, quote: "'")
       end.join(" ")
-      solr_parameters[:q] = "{!#{local_params}}#{search_state.query_param}"
+      solr_parameters.append_query "{!#{local_params}}#{search_state.query_param}"
 
       ##
       # Set Solr spellcheck.q to be original user-entered query, without

data/lib/generators/blacklight/assets_generator.rb

@@ -68,11 +68,15 @@ module Blacklight
     private
 
     def turbolinks?
-      @turbolinks ||= IO.read("app/assets/javascripts/application.js").include?('turbolinks')
+      @turbolinks ||= application_js.include?('turbolinks')
     end
 
     def has_blacklight_assets?
-      IO.read("app/assets/javascripts/application.js").include?('blacklight/blacklight')
+      application_js.include?('blacklight/blacklight')
+    end
+
+    def application_js
+      IO.read(File.expand_path("app/assets/javascripts/application.js", destination_root))
     end
   end
 end

data/lib/generators/blacklight/user_generator.rb

@@ -47,7 +47,7 @@ module Blacklight
     # Add Blacklight to the user model
     def inject_blacklight_user_behavior
       file_path = "app/models/#{model_name.underscore}.rb"
-      if File.exist?(file_path)
+      if File.exist?(File.expand_path(file_path, destination_root))
         inject_into_class file_path, model_name.classify do
           "\n  # Connects this user object to Blacklights Bookmarks." \
           "\n  include Blacklight::User\n"

data/spec/components/blacklight/document_component_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 RSpec.describe Blacklight::DocumentComponent, type: :component do
-  subject(:component) { described_class.new(document: document, **attr) }
+  subject(:component) { described_class.new(document: document, presenter: view_context.document_presenter(document), **attr) }
 
   let(:attr) { {} }
   let(:view_context) { controller.view_context }
@@ -47,7 +47,7 @@ RSpec.describe Blacklight::DocumentComponent, type: :component do
     component.with(:embed, 'Embed')
     component.with(:metadata, 'Metadata')
     component.with(:thumbnail, 'Thumbnail')
-    component.with(:actions, 'Actions')
+    component.with(:actions) { 'Actions' }
 
     expect(rendered).to have_content 'Title'
     expect(rendered).to have_content 'Embed'
@@ -65,7 +65,7 @@ RSpec.describe Blacklight::DocumentComponent, type: :component do
 
   context 'with a provided body' do
     it 'opts-out of normal component content' do
-      component.with(:body, 'Body content')
+      component.with(:body) { 'Body content' }
 
       expect(rendered).to have_content 'Body content'
       expect(rendered).not_to have_selector 'header'

data/spec/models/blacklight/solr/facet_paginator_spec.rb

@@ -20,5 +20,9 @@ RSpec.describe Blacklight::Solr::FacetPaginator, api: true do
     it 'defaults to "index" if no limit is given' do
       expect(described_class.new([]).sort).to eq 'index'
     end
+
+    it 'handles json facet api-style parameter sorts' do
+      expect(described_class.new([], sort: { count: :desc }).sort).to eq 'count'
+    end
   end
 end

data/spec/models/blacklight/solr/request_spec.rb

@@ -1,36 +1,69 @@
 # frozen_string_literal: true
 
 RSpec.describe Blacklight::Solr::Request, api: true do
-  before do
-    subject[:qt] = 'hey'
-    subject[:fq] = ["what's up.", "dood"]
-    subject['q'] = "what's"
-    subject[:wt] = "going"
-    subject[:start] = "on"
-    subject[:rows] = "Man"
-    subject['hl'] = "I"
-    subject['hl.fl'] = "wish"
-    subject['group'] = "I"
-    subject['defType'] = "had"
-    subject['spellcheck'] = "a"
-    subject['spellcheck.q'] = "fleece"
-    subject['f.title_facet.facet.limit'] = "vest"
-    subject['facet.field'] = []
+  context 'with some solr parameter keys' do
+    before do
+      subject[:qt] = 'hey'
+      subject[:fq] = ["what's up.", "dood"]
+      subject['q'] = "what's"
+      subject[:wt] = "going"
+      subject[:start] = "on"
+      subject[:rows] = "Man"
+      subject['hl'] = "I"
+      subject['hl.fl'] = "wish"
+      subject['group'] = "I"
+      subject['defType'] = "had"
+      subject['spellcheck'] = "a"
+      subject['spellcheck.q'] = "fleece"
+      subject['f.title_facet.facet.limit'] = "vest"
+      subject['facet.field'] = []
+    end
+
+    it "accepts valid parameters" do
+      expect(subject.to_hash).to eq("defType" => "had",
+                                    "f.title_facet.facet.limit" => "vest",
+                                    "fq" => ["what's up.", "dood"],
+                                    "group" => "I",
+                                    "hl" => "I",
+                                    "hl.fl" => "wish",
+                                    "q" => "what's",
+                                    "qt" => "hey",
+                                    "rows" => "Man",
+                                    "spellcheck" => "a",
+                                    "spellcheck.q" => "fleece",
+                                    "start" => "on",
+                                    "wt" => "going")
+    end
+  end
+
+  describe '#append_query' do
+    it 'populates the q parameter' do
+      subject.append_query 'this is my query'
+      expect(subject['q']).to eq 'this is my query'
+    end
+
+    it 'handles multiple queries by converting it to a boolean query' do
+      subject.append_query 'this is my query'
+      subject.append_query 'another:query'
+      expect(subject).not_to have_key 'q'
+      expect(subject.dig('json', 'query', 'bool', 'must')).to match_array ['this is my query', 'another:query']
+    end
   end
 
-  it "accepts valid parameters" do
-    expect(subject.to_hash).to eq("defType" => "had",
-                                  "f.title_facet.facet.limit" => "vest",
-                                  "fq" => ["what's up.", "dood"],
-                                  "group" => "I",
-                                  "hl" => "I",
-                                  "hl.fl" => "wish",
-                                  "q" => "what's",
-                                  "qt" => "hey",
-                                  "rows" => "Man",
-                                  "spellcheck" => "a",
-                                  "spellcheck.q" => "fleece",
-                                  "start" => "on",
-                                  "wt" => "going")
+  describe '#append_boolean_query' do
+    it 'populates the boolean query with the queries' do
+      subject.append_boolean_query :must, 'required'
+      subject.append_boolean_query :should, 'optional'
+      subject.append_boolean_query :should, 'also optional'
+
+      expect(subject.dig('json', 'query', 'bool')).to include should: ['optional', 'also optional'], must: ['required']
+    end
+
+    it 'converts existing q parameters to a boolean query' do
+      subject['q'] = 'some query'
+      subject.append_boolean_query :must, 'also required'
+
+      expect(subject.dig('json', 'query', 'bool', 'must')).to match_array ['some query', 'also required']
+    end
   end
 end

data/spec/models/blacklight/solr/response/facets_spec.rb

@@ -160,6 +160,12 @@ RSpec.describe Blacklight::Solr::Response::Facets, api: true do
       expect(missing.label).to eq "[Missing]"
       expect(missing.fq).to eq "-some_field:[* TO *]"
     end
+
+    it 'extracts the missing field data to a separate facet field attribute' do
+      missing = subject.aggregations["some_field"].missing
+
+      expect(missing).to have_attributes(label: '[Missing]', hits: 2)
+    end
   end
 
   describe "query facets" do
@@ -278,4 +284,107 @@ RSpec.describe Blacklight::Solr::Response::Facets, api: true do
       expect(field.items.first.items.first.fq).to eq('field_a' => 'a')
     end
   end
+
+  describe 'json facets' do
+    subject { Blacklight::Solr::Response.new(response, {}, blacklight_config: blacklight_config) }
+
+    let(:response) do
+      {
+        facets: {
+          "count": 32,
+          "categories": {
+            "buckets": [
+              {
+                "val": "electronics",
+                "count": 12,
+                "max_price": 60
+              },
+              {
+                "val": "currency",
+                "count": 4
+              },
+              {
+                "val": "memory",
+                "count": 3
+              }
+            ]
+          }
+        }
+      }
+    end
+    let(:facet_config) do
+      Blacklight::Configuration::FacetField.new(key: 'categories', json: true, query: false)
+    end
+
+    let(:blacklight_config) { double(facet_fields: { 'categories' => facet_config }) }
+    let(:field) { subject.aggregations['categories'] }
+
+    it 'has access to the original response data' do
+      expect(field.data).to include 'buckets'
+    end
+
+    it 'converts buckets into facet items' do
+      expect(field.items.length).to eq 3
+    end
+
+    context 'with nested buckets' do
+      let(:response) do
+        {
+          facets: {
+            "categories": {
+              "buckets": [
+                {
+                  "val": "electronics",
+                  "count": 12,
+                  "top_manufacturer": {
+                    "buckets": [{
+                      "val": "corsair",
+                      "count": 3
+                    }]
+                  }
+                },
+                {
+                  "val": "currency",
+                  "count": 4,
+                  "top_manufacturer": {
+                    "buckets": [{
+                      "val": "boa",
+                      "count": 1
+                    }]
+                  }
+                }
+              ]
+            }
+          }
+        }
+      end
+
+      it 'converts nested buckets into pivot facets' do
+        expect(field.items.first).to have_attributes hits: 12
+        expect(field.items.first.items.first).to have_attributes field: 'top_manufacturer', value: 'corsair', hits: 3, fq: { "categories" => "electronics" }
+      end
+    end
+
+    context 'with missing values' do
+      let(:response) do
+        {
+          facets: {
+            "categories": {
+              "missing" => { "count" => 13 },
+              "buckets" => [{ "val" => "India", "count" => 2 }, { "val" => "Iran", "count" => 2 }]
+            }
+          }
+        }
+      end
+
+      it 'converts "missing" facet data into a missing facet item' do
+        expect(field.items.length).to eq 2
+        expect(field.missing).to have_attributes(hits: 13)
+      end
+    end
+
+    it 'exposes any extra query function results' do
+      expect(field.items.first.data).to include 'max_price' => 60
+    end
+  end
 end

data/spec/models/blacklight/solr/response_spec.rb

@@ -120,6 +120,16 @@ RSpec.describe Blacklight::Solr::Response, api: true do
     expect(r.params['test']).to eq :test
   end
 
+  it 'extracts json params' do
+    raw_response = eval(mock_query_response)
+    raw_response['responseHeader']['params']['test'] = 'from query'
+    raw_response['responseHeader']['params'].delete('rows')
+    raw_response['responseHeader']['params']['json'] = { limit: 5, params: { test: 'from json params' } }.to_json
+    r = described_class.new(raw_response, raw_response['params'])
+    expect(r.params['test']).to eq 'from query'
+    expect(r.rows).to eq 5
+  end
+
   it 'provides the solr-returned params and "rows" should be 11' do
     raw_response = eval(mock_query_response)
     r = described_class.new(raw_response, {})