blacklight 7.15.1 → 7.17.2

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/lib/blacklight/configuration/view_config_spec.rb

@@ -9,7 +9,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')
-      expect(subject.display_label(key)).to eq 'x'
+      expect(subject.display_label).to eq 'x'
     end
   end
 end

data/spec/lib/blacklight/open_struct_with_hash_access_spec.rb

@@ -123,6 +123,18 @@ RSpec.describe Blacklight::OpenStructWithHashAccess do
     end
   end
 
+  describe '#reverse_merge' do
+    before do
+      @h = described_class.new
+      @h[:a] = 1
+      @h[:b] = 2
+    end
+
+    it 'reverse merges the object with the hash, preserving the object class' do
+      expect(@h.reverse_merge(b: 3, c: 4)).to have_attributes a: 1, b: 2, c: 4
+    end
+  end
+
   describe "#to_json" do
     subject { described_class.new a: 1, b: 2 }
 
@@ -145,4 +157,12 @@ RSpec.describe Blacklight::OpenStructWithHashAccess do
       expect(copy.b[:c]).to eq 2
     end
   end
+
+  describe "#try" do
+    subject { described_class.new a: 1 }
+
+    it "works (and doesn't throw a stack error...)" do
+      expect(subject.try(:a)).to eq 1
+    end
+  end
 end

data/spec/models/blacklight/configuration_spec.rb

@@ -557,4 +557,68 @@ RSpec.describe "Blacklight::Configuration", api: true do
       expect(config.facet_paginator_class).to eq Blacklight::Solr::FacetPaginator
     end
   end
+
+  describe '#view_config' do
+    before do
+      config.index.title_field = 'title_tsim'
+    end
+
+    context 'with a view that does not exist' do
+      it 'defaults to the index config' do
+        expect(config.view_config('this-doesnt-exist')).to have_attributes config.index.to_h
+      end
+    end
+
+    context 'with the :show view' do
+      it 'includes the show config' do
+        expect(config.view_config(:show)).to have_attributes config.show.to_h
+      end
+
+      it 'uses the show document presenter' do
+        expect(config.view_config(:show)).to have_attributes document_presenter_class: Blacklight::ShowPresenter
+      end
+
+      it 'includes index config defaults' do
+        expect(config.view_config(:show)).to have_attributes title_field: 'title_tsim'
+      end
+    end
+
+    context 'with just an action name' do
+      it 'includes the action config' do
+        expect(config.view_config(action_name: :show)).to have_attributes config.show.to_h
+      end
+
+      it 'includes the default action mapping configuration' do
+        config.action_mapping.default.whatever = :some_value
+
+        expect(config.view_config(action_name: :show)).to have_attributes whatever: :some_value
+      end
+
+      it 'includes the action-specific mappings' do
+        config.action_mapping.foo.document_presenter_class = Blacklight::DocumentPresenter
+
+        expect(config.view_config(action_name: :foo)).to have_attributes config.action_mapping.foo.to_h
+      end
+
+      it 'allows the action mapping to specific a parent configuration with some more defaults' do
+        config.action_mapping.foo.parent_config = :bar
+        config.action_mapping.bar.whatever = :bar_value
+
+        expect(config.view_config(action_name: :foo)).to have_attributes whatever: :bar_value
+      end
+
+      context 'with the :citation action' do
+        it 'also includes the show config' do
+          expect(config.view_config(action_name: :citation)).to have_attributes config.show.to_h
+        end
+      end
+    end
+
+    context 'with a view' do
+      it 'includes the configuration-level view parameters' do
+        expect(config.view_config(:atom)).to have_attributes config.index.to_h.except(:partials)
+        expect(config.view_config(:atom)).to have_attributes partials: [:document]
+      end
+    end
+  end
 end

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, {})

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

@@ -259,6 +259,23 @@ RSpec.describe Blacklight::Solr::SearchBuilderBehavior, api: true do
       end
     end
 
+    describe 'with a json facet' do
+      let(:user_params) { { f: { json_facet: ['value'] } }.with_indifferent_access }
+
+      before do
+        blacklight_config.add_facet_field 'json_facet', field: 'foo', json: { bar: 'baz' }
+      end
+
+      it "has proper solr parameters" do
+        expect(subject[:fq]).to include('{!term f=foo}value')
+        expect(subject.dig(:json, :facet, 'json_facet')).to include(
+          field: 'foo',
+          type: 'terms',
+          bar: 'baz'
+        )
+      end
+    end
+
     describe 'with multi-valued facets' do
       let(:user_params) { { f_inclusive: { format: %w[Book Movie CD] } } }
 
@@ -321,6 +338,38 @@ RSpec.describe Blacklight::Solr::SearchBuilderBehavior, api: true do
       end
     end
 
+    describe "solr json query parameters from the fielded search" do
+      let(:user_params) { subject_search_params }
+
+      before do
+        blacklight_config.search_fields['subject'].solr_parameters = {
+          some: :parameter
+        }
+
+        blacklight_config.search_fields['subject'].clause_params = {
+          edismax: {
+            another: :parameter
+          }
+        }
+      end
+
+      it 'sets solr parameters from the field' do
+        expect(subject[:some]).to eq :parameter
+      end
+
+      it 'does not set a q parameter' do
+        expect(subject).not_to have_key :q
+      end
+
+      it 'includes the user query in the JSON query DSL request' do
+        expect(subject.dig(:json, :query, :bool, :must, 0, :edismax)).to include query: 'wome'
+      end
+
+      it 'includes addtional clause parameters for the field' do
+        expect(subject.dig(:json, :query, :bool, :must, 0, :edismax)).to include another: :parameter
+      end
+    end
+
     describe "overriding of qt parameter" do
       let(:user_params) do
         { qt: 'overridden' }