blacklight 5.14.0 → 5.15.0

data/lib/blacklight/facet_paginator.rb

@@ -0,0 +1,121 @@
+module Blacklight
+  # Pagination for facet values -- works by setting the limit to max
+  # displayable. You have to ask Solr for limit+1, to get enough
+  # results to see if 'more' are available'. That is, the all_facet_values
+  # arg in constructor should be the result of asking solr for limit+1
+  # values. 
+  # This is a workaround for the fact that Solr itself can't compute
+  # the total values for a given facet field,
+  # so we cannot know how many "pages" there are.
+  #
+  class FacetPaginator
+    extend Deprecation
+
+    self.deprecation_horizon = 'blacklight version 6.0.0'
+    
+    # What request keys will we use for the parameters need. Need to
+    # make sure they do NOT conflict with catalog/index request params,
+    # and need to make them accessible in a list so we can easily
+    # strip em out before redirecting to catalog/index.
+    mattr_accessor :request_keys do
+      { sort: :'facet.sort', page: :'facet.page' }
+    end
+
+    if Rails.version < "4.1"
+      self.request_keys = { sort: :'facet.sort', page: :'facet.page' }
+    end
+
+    attr_reader :offset, :limit, :sort
+    
+    # all_facet_values is a list of facet value objects returned by solr,
+    # asking solr for n+1 facet values.
+    # options:
+    # :limit =>  number to display per page, or (default) nil. Nil means
+    #            display all with no previous or next. 
+    # :offset => current item offset, default 0
+    # :sort => 'count' or 'index', solr tokens for facet value sorting, default 'count'. 
+    def initialize(all_facet_values, arguments)
+      # to_s.to_i will conveniently default to 0 if nil
+      @offset = arguments[:offset].to_s.to_i 
+      @limit = arguments[:limit]
+      @sort = arguments[:sort]
+
+      @all = all_facet_values
+    end
+
+    # The number of records solr gave us when we asked for limit + 1 records at the current offset
+    def total_count
+      @all.size
+    end
+
+    def items
+      items_for_limit(@all)
+    end
+
+    def prev_page
+      current_page - 1 unless first_page?
+    end
+
+    def current_page
+      if limit == 0 #check for divide by zero
+        1
+      else
+        @offset / limit + 1
+      end
+    end
+
+    def next_page
+      current_page + 1 unless last_page?
+    end
+   
+    #@deprecated
+    def has_next?
+      !last_page?
+    end
+    deprecation_deprecate :has_next? => "use #!last_page?"
+
+    #@deprecated
+    def has_previous?
+      !first_page?
+    end
+    deprecation_deprecate :has_next? => "use #!first_page?"
+
+    def last_page?
+      limit.nil? || total_count <= limit
+    end
+
+    def first_page?
+      current_page == 1
+    end
+
+    # We're implementing total_pages so that this matches the API from kaminari, even though we can't
+    # know the total number of pages.
+    # https://github.com/amatsuda/kaminari/blob/v0.16.1/lib/kaminari/models/page_scope_methods.rb#L21
+    def total_pages
+      -1
+    end
+
+    # Pass in a desired solr facet solr key ('count' or 'index', see
+    # http://wiki.apache.org/solr/SimpleFacetParameters#facet.limit
+    # under facet.sort ), and your current request params.
+    # Get back params suitable to passing to an ActionHelper method for
+    # creating a url, to resort by that method.
+    def params_for_resort_url(sort_method, params)
+      # When resorting, we've got to reset the offset to start at beginning,
+      # no way to make it make sense otherwise.
+      params.merge(request_keys[:sort] => sort_method, request_keys[:page] => nil)
+    end
+
+    def as_json(_ = nil)
+      { 'items' => items.as_json, 'limit' => limit, 'offset' => offset, 'sort' => sort }
+    end
+
+    private
+
+    # setting limit to nil implies no limit
+    # @return an array of facets on the page
+    def items_for_limit(values)
+      limit.nil? ? values : values.take(limit)
+    end
+  end
+end

data/lib/blacklight/search_builder.rb

@@ -56,6 +56,27 @@ module Blacklight
       builder
     end
 
+    ##
+    # Converse to append, remove processor chain directives,
+    # returning a new builder that's a copy of receiver with
+    # specified change. 
+    #
+    # Methods in argument that aren't currently in processor
+    # chain are ignored as no-ops, rather than raising. 
+    def except *except_processor_chain
+      builder = self.class.new(processor_chain - except_processor_chain, scope)
+          .with(blacklight_params)
+          .merge(@merged_params)
+          .reverse_merge(@reverse_merged_params)
+
+      builder.start(@start) if @start
+      builder.rows(@rows) if @rows
+      builder.page(@page) if @page
+      builder.facet(@facet) if @facet
+
+      builder
+    end
+
     ##
     # Merge additional, repository-specific parameters
     def merge extra_params, &block

data/lib/blacklight/search_helper.rb

@@ -94,14 +94,18 @@ module Blacklight::SearchHelper
 
   # a solr query method
   # @param [Hash,HashWithIndifferentAccess] user_params ({}) the user provided parameters (e.g. query, facets, sort, etc)
-  # @param [Hash,HashWithIndifferentAccess] extra_controller_params ({}) extra parameters to add to the search
   # @param [List<Symbol] processor_chain a list of filter methods to run
+  # @yield [search_builder] optional block yields configured SearchBuilder, caller can modify or create new SearchBuilder to be used. Block should return SearchBuilder to be used. 
   # @return [Blacklight::SolrResponse] the solr response object
   def search_results(user_params, search_params_logic)
     builder = search_builder(search_params_logic).with(user_params)
     builder.page(user_params[:page]) if user_params[:page]
     builder.rows(user_params[:per_page] || user_params[:rows]) if user_params[:per_page] or user_params[:rows]
 
+    if block_given? 
+      builder = yield(builder)
+    end
+
     response = repository.search(builder)
 
     case

data/lib/blacklight/solr/facet_paginator.rb

@@ -1,7 +1,5 @@
 # -*- encoding : utf-8 -*-
 module Blacklight::Solr
-  
-
   # Pagination for facet values -- works by setting the limit to max
   # displayable. You have to ask Solr for limit+1, to get enough
   # results to see if 'more' are available'. That is, the all_facet_values
@@ -11,25 +9,7 @@ module Blacklight::Solr
   # the total values for a given facet field,
   # so we cannot know how many "pages" there are.
   #
-  class FacetPaginator    
-    extend Deprecation
-
-    self.deprecation_horizon = 'blacklight version 6.0.0'
-    
-    # What request keys will we use for the parameters need. Need to
-    # make sure they do NOT conflict with catalog/index request params,
-    # and need to make them accessible in a list so we can easily
-    # strip em out before redirecting to catalog/index.
-    mattr_accessor :request_keys do
-      { sort: :'facet.sort', page: :'facet.page' }
-    end
-
-    if Rails.version < "4.1"
-      self.request_keys = { sort: :'facet.sort', page: :'facet.page' }
-    end
-
-    attr_reader :offset, :limit, :sort
-    
+  class FacetPaginator < Blacklight::FacetPaginator
     # all_facet_values is a list of facet value objects returned by solr,
     # asking solr for n+1 facet values.
     # options:
@@ -38,87 +18,10 @@ module Blacklight::Solr
     # :offset => current item offset, default 0
     # :sort => 'count' or 'index', solr tokens for facet value sorting, default 'count'. 
     def initialize(all_facet_values, arguments)
-      # to_s.to_i will conveniently default to 0 if nil
-      @offset = arguments[:offset].to_s.to_i 
-      @limit = arguments[:limit]
-      # count is solr's default
-      @sort = arguments[:sort] || "count" 
-
-      @all = all_facet_values
-    end
-
-    # The number of records solr gave us when we asked for limit + 1 records at the current offset
-    def total_count
-      @all.size
-    end
-
-    def items
-      items_for_limit(@all)
-    end
-
-    def prev_page
-      current_page - 1 unless first_page?
-    end
-
-    def current_page
-      if limit == 0 #check for divide by zero
-        1
-      else
-        @offset / limit + 1
-      end
-    end
-
-    def next_page
-      current_page + 1 unless last_page?
-    end
-   
-    #@deprecated
-    def has_next?
-      !last_page?
-    end
-    deprecation_deprecate :has_next? => "use #!last_page?"
-
-    #@deprecated
-    def has_previous?
-      !first_page?
-    end
-    deprecation_deprecate :has_next? => "use #!first_page?"
-
-    def last_page?
-      limit.nil? || total_count <= limit
-    end
+      super
 
-    def first_page?
-      current_page == 1
-    end
-
-    # We're implementing total_pages so that this matches the API from kaminari, even though we can't
-    # know the total number of pages.
-    # https://github.com/amatsuda/kaminari/blob/v0.16.1/lib/kaminari/models/page_scope_methods.rb#L21
-    def total_pages
-      -1
-    end
-
-    # Pass in a desired solr facet solr key ('count' or 'index', see
-    # http://wiki.apache.org/solr/SimpleFacetParameters#facet.limit
-    # under facet.sort ), and your current request params.
-    # Get back params suitable to passing to an ActionHelper method for
-    # creating a url, to resort by that method.
-    def params_for_resort_url(sort_method, params)
-      # When resorting, we've got to reset the offset to start at beginning,
-      # no way to make it make sense otherwise.
-      params.merge(request_keys[:sort] => sort_method, request_keys[:page] => nil)
-    end
-
-    def as_json(_ = nil)
-      { 'items' => items.as_json, 'limit' => limit, 'offset' => offset, 'sort' => sort }
+      # count is solr's default
+      @sort ||= 'count'
     end
-
-    private
-      # setting limit to nil implies no limit
-      # @return an array of facets on the page
-      def items_for_limit(values)
-        limit.nil? ? values : values.take(limit)
-      end
   end
 end

data/lib/blacklight/solr_response/spelling.rb

@@ -80,6 +80,8 @@ module Blacklight::SolrResponse::Spelling
           unless suggestions.nil?
             if suggestions.index("collation")
               suggestions[suggestions.index("collation") + 1]
+            elsif spellcheck.key?("collations")
+              spellcheck['collations'].last
             end
           end
         end

data/spec/features/sitelinks_search_box.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+feature 'Sitelinks search box' do
+  scenario 'is home page' do
+    visit root_path
+    expect(page).to have_css 'script[type="application/ld+json"]'
+  end
+  scenario 'on search page' do
+    visit catalog_index_path q: 'book'
+    expect(page).to_not have_css 'script[type="application/ld+json"]'
+  end
+end

data/spec/helpers/blacklight_helper_spec.rb

@@ -48,65 +48,20 @@ describe BlacklightHelper do
   end
 
   describe "render_link_rel_alternates" do
-      class MockDocumentAppHelper
-        include Blacklight::Solr::Document
-      end
-      module MockExtension
-         def self.extended(document)
-           document.will_export_as(:weird, "application/weird")
-           document.will_export_as(:weirder, "application/weirder")
-           document.will_export_as(:weird_dup, "application/weird")
-         end
-         def export_as_weird ; "weird" ; end
-         def export_as_weirder ; "weirder" ; end
-         def export_as_weird_dup ; "weird_dup" ; end
-      end
-      MockDocumentAppHelper.use_extension(MockExtension)
-      def mock_document_app_helper_url *args
-        solr_document_url(*args)
-      end
-    before(:each) do
-      @doc_id = "MOCK_ID1"
-      @document = MockDocumentAppHelper.new(:id => @doc_id)
-      render_params = {:controller => "controller", :action => "action"}
-      allow(helper).to receive(:params).and_return(render_params)
-    end
-    it "generates <link rel=alternate> tags" do
+    let(:document) { double }
+    let(:result) { double }
+    let(:presenter) { Blacklight::DocumentPresenter.new(document, self) }
 
-      response = render_link_rel_alternates(@document)
-
-      tmp_value = Capybara.ignore_hidden_elements
-      Capybara.ignore_hidden_elements = false
-      @document.export_formats.each_pair do |format, spec|
-        expect(response).to have_selector("link[href$='.#{ format  }']") do |matches|
-          expect(matches).to have(1).match
-          tag = matches[0]
-          expect(tag.attributes["rel"].value).to eq "alternate"
-          expect(tag.attributes["title"].value).to eq format.to_s
-          expect(tag.attributes["href"].value).to eq mock_document_app_helper_url(@document, :format =>format)
-        end
-      end
-      Capybara.ignore_hidden_elements = tmp_value
-    end
-    it "respects :unique=>true" do
-      response = render_link_rel_alternates(@document, :unique => true)
-      tmp_value = Capybara.ignore_hidden_elements
-      Capybara.ignore_hidden_elements = false
-      expect(response).to have_selector("link[type='application/weird']", :count => 1)
-      Capybara.ignore_hidden_elements = tmp_value
-    end
-    it "excludes formats from :exclude" do
-      response = render_link_rel_alternates(@document, :exclude => [:weird_dup])
+    before { allow(helper).to receive(:presenter).and_return(presenter) }
 
-      tmp_value = Capybara.ignore_hidden_elements
-      Capybara.ignore_hidden_elements = false
-      expect(response).to_not have_selector("link[href$='.weird_dup']")
-      Capybara.ignore_hidden_elements = tmp_value
+    it "generates <link rel=alternate> tags" do
+      expect(presenter).to receive(:link_rel_alternates).and_return(result)
+      expect(helper.render_link_rel_alternates(document)).to eq result
     end
 
-    it "should be html safe" do
-      response = render_link_rel_alternates(@document)
-      expect(response).to be_html_safe
+    it "sends parameters" do
+      expect(presenter).to receive(:link_rel_alternates).with(unique: true).and_return(result)
+      expect(helper.render_link_rel_alternates(document, unique: true)).to eq result
     end
   end
 

data/spec/helpers/catalog_helper_spec.rb

@@ -323,4 +323,43 @@ describe CatalogHelper do
     end
   end
 
+  describe "#render_search_to_page_title_filter" do
+    before do
+      allow(helper).to receive(:blacklight_config).and_return(blacklight_config)
+    end
+
+    let :blacklight_config do
+      Blacklight::Configuration.new
+    end
+
+    it "should render a facet with a single value" do
+      expect(helper.render_search_to_page_title_filter('foo', ['bar'])).to eq "Foo: bar"
+    end
+
+    it "should render a facet with two values" do
+      expect(helper.render_search_to_page_title_filter('foo', ['bar', 'baz'])).to eq "Foo: bar and baz"
+    end
+
+    it "should render a facet with more than two values" do
+      expect(helper.render_search_to_page_title_filter('foo', ['bar', 'baz', 'foobar'])).to eq "Foo: 3 selected"
+    end
+  end
+
+  describe "#render_search_to_page_title" do
+    before do
+      allow(helper).to receive(:blacklight_config).and_return(blacklight_config)
+      allow(helper).to receive(:default_search_field).and_return(Blacklight::Configuration::SearchField.new(:key => 'default_search_field', :display_label => 'Default'))
+      allow(helper).to receive(:label_for_search_field).with(nil).and_return('')
+    end
+
+    let :blacklight_config do
+      Blacklight::Configuration.new
+    end
+
+    let(:params) { {'q' => 'foobar', "f" => {"format" => ["Book"]}} }
+
+    it "should render a page title" do
+      expect(helper.render_search_to_page_title(params)).to eq "foobar / Format: Book"
+    end
+  end
 end

data/spec/lib/blacklight/facet_paginator_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'Blacklight::Solr::FacetPaginator' do
+describe Blacklight::FacetPaginator do
 
   let(:f1) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '792', value: 'Book') }
   let(:f2) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '65', value: 'Musical Score') }
@@ -14,7 +14,7 @@ describe 'Blacklight::Solr::FacetPaginator' do
   let(:limit) { 6 }
 
   context 'on the first page of two pages' do
-    subject { Blacklight::Solr::FacetPaginator.new(seven_facet_values, limit: limit) }
+    subject { described_class.new(seven_facet_values, limit: limit) }
     it { should be_first_page }
     it { should_not be_last_page }
     its(:current_page) { should eq 1 }
@@ -26,7 +26,7 @@ describe 'Blacklight::Solr::FacetPaginator' do
   end
 
   context 'on the last page of two pages' do
-    subject { Blacklight::Solr::FacetPaginator.new([f7], offset: 6, limit: limit) }
+    subject { described_class.new([f7], offset: 6, limit: limit) }
     it { should_not be_first_page }
     it { should be_last_page }
     its(:current_page) { should eq 2 }
@@ -38,7 +38,7 @@ describe 'Blacklight::Solr::FacetPaginator' do
   end
 
   context 'on the second page of three pages' do
-    subject { Blacklight::Solr::FacetPaginator.new(seven_facet_values, offset: 6, limit: limit) }
+    subject { described_class.new(seven_facet_values, offset: 6, limit: limit) }
     it { should_not be_first_page }
     it { should_not be_last_page }
     its(:current_page) { should eq 2 }
@@ -50,15 +50,15 @@ describe 'Blacklight::Solr::FacetPaginator' do
   end
 
   context 'on the first page of one page' do
-    subject { Blacklight::Solr::FacetPaginator.new(six_facet_values, offset: 0, limit: limit) }
+    subject { described_class.new(six_facet_values, offset: 0, limit: limit) }
     it { should be_first_page }
     it { should be_last_page }
   end
 
   describe "params_for_resort_url" do
-    let(:sort_key) { Blacklight::Solr::FacetPaginator.request_keys[:sort] }
-    let(:page_key) { Blacklight::Solr::FacetPaginator.request_keys[:page] }
-    subject { Blacklight::Solr::FacetPaginator.new([], offset: 100, limit: limit, sort: 'index') }
+    let(:sort_key) { described_class.request_keys[:sort] }
+    let(:page_key) { described_class.request_keys[:page] }
+    subject { described_class.new([], offset: 100, limit: limit, sort: 'index') }
 
     it 'should know a manually set sort, and produce proper sort url' do
         expect(subject.sort).to eq 'index'
@@ -71,7 +71,7 @@ describe 'Blacklight::Solr::FacetPaginator' do
   end
 
   context "for a nil :limit" do
-    subject { Blacklight::Solr::FacetPaginator.new(seven_facet_values, offset: 0, limit: nil) }
+    subject { described_class.new(seven_facet_values, offset: 0, limit: nil) }
     it "should return all the items" do
       expect(subject.items).to eq seven_facet_values
     end
@@ -79,16 +79,16 @@ describe 'Blacklight::Solr::FacetPaginator' do
   end
 
   describe "#as_json" do
-    subject { Blacklight::Solr::FacetPaginator.new([f1], offset: 0, limit: nil).as_json }
+    subject { described_class.new([f1], offset: 0, limit: nil).as_json }
     it "should be well structured" do
       expect(subject).to eq("items" => [{"hits"=>"792", "value"=>"Book"}], "limit" => nil,
-       "offset" => 0, "sort" => "count")
+       "offset" => 0, "sort" => nil)
     end
   end
 
   describe "#total_pages" do
     # this method is just for API compatability with kaminari 0.16.1
-    subject { Blacklight::Solr::FacetPaginator.new([f1], offset: 0, limit: nil).total_pages }
+    subject { described_class.new([f1], offset: 0, limit: nil).total_pages }
     it { should eq -1 }
   end
 end