blacklight 5.9.4 → 5.10.0

data/lib/blacklight/solr/document/more_like_this.rb

@@ -1,5 +1,5 @@
 module Blacklight::Solr::Document::MoreLikeThis
   def more_like_this
-    solr_response.more_like(self).map { |doc| SolrDocument.new(doc, solr_response) }
+    response.more_like(self).map { |doc| self.class.new(doc, response) }
   end
 end

data/lib/blacklight/solr/document/schema_org.rb

@@ -1,7 +1,7 @@
 module Blacklight::Solr::Document::SchemaOrg
-
-  def itemtype
-    "http://schema.org/Thing"
+  include Blacklight::Document::SchemaOrg
+  
+  def self.extended(document)
+    Deprecation.warn Blacklight::Solr::Document::SchemaOrg, "Blacklight::Solr::Document::SchemaOrg is deprecated; use Blacklight::Document::SchemaOrg instead."
   end
-
 end

data/lib/blacklight/solr/document/sms.rb

@@ -1,14 +1,7 @@
-# -*- encoding : utf-8 -*-
-# This module provides the body of an email export based on the document's semantic values
 module Blacklight::Solr::Document::Sms
-
-  # Return a text string that will be the body of the email
-  def to_sms_text
-    semantics = self.to_semantic_values
-    body = []
-    body << I18n.t('blacklight.sms.text.title', :value => semantics[:title].first) unless semantics[:title].blank?
-    body << I18n.t('blacklight.sms.text.author', :value => semantics[:author].first) unless semantics[:author].blank?
-    return body.join unless body.empty?
+  include Blacklight::Document::Sms
+  
+  def self.extended(document)
+    Deprecation.warn Blacklight::Solr::Document::Sms, "Blacklight::Solr::Document::Sms is deprecated; use Blacklight::Document::Sms instead."
   end
-
 end

data/lib/blacklight/solr/facet_paginator.rb

@@ -73,13 +73,13 @@ module Blacklight::Solr
     def has_next?
       !last_page?
     end
-    deprecation_deprecate :has_next?
+    deprecation_deprecate :has_next? => "use #!last_page?"
 
     #@deprecated
     def has_previous?
       !first_page?
     end
-    deprecation_deprecate :has_next?
+    deprecation_deprecate :has_next? => "use #!first_page?"
 
     def last_page?
       limit.nil? || total_count <= limit

data/lib/blacklight/solr/search_builder.rb

@@ -0,0 +1,264 @@
+module Blacklight::Solr
+  class SearchBuilder < Blacklight::SearchBuilder
+    
+    ####
+    # Start with general defaults from BL config. Need to use custom
+    # merge to dup values, to avoid later mutating the original by mistake.
+    def default_solr_parameters(solr_parameters)
+      blacklight_config.default_solr_params.each do |key, value|
+        solr_parameters[key] = if value.respond_to? :deep_dup
+          value.deep_dup
+        elsif value.respond_to? :dup and value.duplicable?
+          value.dup
+        else
+          value
+        end
+      end
+    end
+
+    ##
+    # Take the user-entered query, and put it in the solr params, 
+    # including config's "search field" params for current search field. 
+    # also include setting spellcheck.q. 
+    def add_query_to_solr(solr_parameters)
+      ###
+      # Merge in search field configured values, if present, over-writing general
+      # defaults
+      ###
+      # legacy behavior of user param :qt is passed through, but over-ridden
+      # by actual search field config if present. We might want to remove
+      # this legacy behavior at some point. It does not seem to be currently
+      # rspec'd. 
+      solr_parameters[:qt] = blacklight_params[:qt] if blacklight_params[:qt]
+
+      if search_field     
+        solr_parameters[:qt] = search_field.qt
+        solr_parameters.merge!( search_field.solr_parameters) if search_field.solr_parameters
+      end
+      
+      ##
+      # Create Solr 'q' including the user-entered q, prefixed by any
+      # solr LocalParams in config, using solr LocalParams syntax. 
+      # http://wiki.apache.org/solr/LocalParams
+      ##         
+      if (search_field && hash = search_field.solr_local_parameters)
+        local_params = hash.collect do |key, val|
+          key.to_s + "=" + solr_param_quote(val, :quote => "'")
+        end.join(" ")
+        solr_parameters[:q] = "{!#{local_params}}#{blacklight_params[:q]}"
+
+        ##
+        # Set Solr spellcheck.q to be original user-entered query, without
+        # our local params, otherwise it'll try and spellcheck the local
+        # params!
+        solr_parameters["spellcheck.q"] ||= blacklight_params[:q]
+      elsif blacklight_params[:q].is_a? Hash
+        q = blacklight_params[:q]
+        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[:spellcheck] = 'false'
+      elsif blacklight_params[:q]
+        solr_parameters[:q] = blacklight_params[:q]
+      end
+    end
+
+    ##
+    # Add any existing facet limits, stored in app-level HTTP query
+    # as :f, to solr as appropriate :fq query. 
+    def add_facet_fq_to_solr(solr_parameters)   
+
+      # convert a String value into an Array
+      if solr_parameters[:fq].is_a? String
+        solr_parameters[:fq] = [solr_parameters[:fq]]
+      end
+
+      # :fq, map from :f. 
+      if ( blacklight_params[:f])
+        f_request_params = blacklight_params[:f] 
+        
+        f_request_params.each_pair do |facet_field, value_list|
+          Array(value_list).each do |value|
+            next if value.blank? # skip empty strings
+            solr_parameters.append_filter_query facet_value_to_fq_string(facet_field, value)
+          end              
+        end      
+      end
+    end
+    
+    ##
+    # Add appropriate Solr facetting directives in, including
+    # taking account of our facet paging/'more'.  This is not
+    # about solr 'fq', this is about solr facet.* params. 
+    def add_facetting_to_solr(solr_parameters)
+      # While not used by BL core behavior, legacy behavior seemed to be
+      # to accept incoming params as "facet.field" or "facets", and add them
+      # on to any existing facet.field sent to Solr. Legacy behavior seemed
+      # to be accepting these incoming params as arrays (in Rails URL with []
+      # on end), or single values. At least one of these is used by
+      # Stanford for "faux hieararchial facets". 
+      if blacklight_params.has_key?("facet.field") || blacklight_params.has_key?("facets")
+        solr_parameters[:"facet.field"].concat( [blacklight_params["facet.field"], blacklight_params["facets"]].flatten.compact ).uniq!
+      end                
+
+      blacklight_config.facet_fields.select { |field_name,facet|
+        facet.include_in_request || (facet.include_in_request.nil? && blacklight_config.add_facet_fields_to_solr_request)
+      }.each do |field_name, facet|
+        solr_parameters[:facet] ||= true
+
+        case 
+          when facet.pivot
+            solr_parameters.append_facet_pivot with_ex_local_param(facet.ex, facet.pivot.join(","))
+          when facet.query
+            solr_parameters.append_facet_query facet.query.map { |k, x| with_ex_local_param(facet.ex, x[:fq]) } 
+          else
+            solr_parameters.append_facet_fields with_ex_local_param(facet.ex, facet.field)
+        end
+
+        if facet.sort
+          solr_parameters[:"f.#{facet.field}.facet.sort"] = facet.sort
+        end
+
+        if facet.solr_params
+          facet.solr_params.each do |k, v|
+            solr_parameters[:"f.#{facet.field}.#{k}"] = v
+          end
+        end
+
+        # Support facet paging and 'more'
+        # links, by sending a facet.limit one more than what we
+        # want to page at, according to configured facet limits.
+        solr_parameters[:"f.#{facet.field}.facet.limit"] = (facet_limit_for(field_name) + 1) if facet_limit_for(field_name)
+      end
+    end
+
+    def add_solr_fields_to_query solr_parameters
+      blacklight_config.show_fields.select(&method(:should_add_field_to_request?)).each do |field_name, field|
+        if field.solr_params
+          field.solr_params.each do |k, v|
+            solr_parameters[:"f.#{field.field}.#{k}"] = v
+          end
+        end
+      end
+
+      blacklight_config.index_fields.select(&method(:should_add_field_to_request?)).each do |field_name, field|
+        if field.highlight
+          solr_parameters[:hl] = true
+          solr_parameters.append_highlight_field field.field
+        end
+
+        if field.solr_params
+          field.solr_params.each do |k, v|
+            solr_parameters[:"f.#{field.field}.#{k}"] = v
+          end
+        end
+      end
+    end
+
+    ###
+    # copy paging params from BL app over to solr, changing
+    # app level per_page and page to Solr rows and start. 
+    def add_paging_to_solr(solr_params)
+      # user-provided parameters should override any default row
+      solr_params[:rows] = rows(solr_params[:rows])
+      if page > 1
+        solr_params[:start] = solr_params[:rows].to_i * (page - 1)
+      end
+    end
+
+    ###
+    # copy sorting params from BL app over to solr
+    def add_sorting_to_solr(solr_parameters)
+      solr_parameters[:sort] = sort unless sort.blank?
+    end
+
+    # Remove the group parameter if we've faceted on the group field (e.g. for the full results for a group)
+    def add_group_config_to_solr solr_parameters
+      if blacklight_params[:f] and blacklight_params[:f][grouped_key_for_results]
+        solr_parameters[:group] = false
+      end
+    end
+
+    def with_ex_local_param(ex, value)
+      if ex
+        "{!ex=#{ex}}#{value}"
+      else
+        value
+      end
+    end
+
+    # Look up facet limit for given facet_field. Will look at config, and
+    # if config is 'true' will look up from Solr @response if available. If
+    # no limit is avaialble, returns nil. Used from #add_facetting_to_solr
+    # to supply f.fieldname.facet.limit values in solr request (no @response
+    # available), and used in display (with @response available) to create
+    # a facet paginator with the right limit.
+    def facet_limit_for(facet_field)
+      facet = blacklight_config.facet_fields[facet_field]
+      return if facet.blank?
+
+      if facet.limit
+        facet.limit == true ? blacklight_config.default_facet_limit : facet.limit
+      end
+    end
+
+    ##
+    # A helper method used for generating solr LocalParams, put quotes
+    # around the term unless it's a bare-word. Escape internal quotes
+    # if needed.
+    def solr_param_quote(val, options = {})
+      options[:quote] ||= '"'
+      unless val =~ /^[a-zA-Z0-9$_\-\^]+$/
+        val = options[:quote] +
+          # Yes, we need crazy escaping here, to deal with regexp esc too!
+          val.gsub("'", "\\\\\'").gsub('"', "\\\\\"") +
+          options[:quote]
+      end
+      return val
+    end
+
+    private
+
+    ##
+    # Convert a facet/value pair into a solr fq parameter
+    def facet_value_to_fq_string(facet_field, value) 
+      facet_config = blacklight_config.facet_fields[facet_field]
+
+      local_params = []
+      local_params << "tag=#{facet_config.tag}" if facet_config and facet_config.tag
+
+      prefix = ""
+      prefix = "{!#{local_params.join(" ")}}" unless local_params.empty?
+
+      fq = case
+        when (facet_config and facet_config.query)
+          facet_config.query[value][:fq]
+        when (facet_config and facet_config.date)
+          # in solr 3.2+, this could be replaced by a !term query
+          "#{prefix}#{facet_field}:#{RSolr.solr_escape(value)}"
+        when (value.is_a?(DateTime) or value.is_a?(Date) or value.is_a?(Time))
+          "#{prefix}#{facet_field}:#{RSolr.solr_escape(value.to_time.utc.strftime("%Y-%m-%dT%H:%M:%SZ"))}"
+        when (value.is_a?(TrueClass) or value.is_a?(FalseClass) or value == 'true' or value == 'false'),
+             (value.is_a?(Integer) or (value.to_i.to_s == value if value.respond_to? :to_i)),
+             (value.is_a?(Float) or (value.to_f.to_s == value if value.respond_to? :to_f))
+          "#{prefix}#{facet_field}:#{RSolr.solr_escape(value.to_s)}"
+        when value.is_a?(Range)
+          "#{prefix}#{facet_field}:[#{value.first} TO #{value.last}]"
+        else
+          "{!raw f=#{facet_field}#{(" " + local_params.join(" ")) unless local_params.empty?}}#{value}"
+      end
+    end
+    
+    ##
+    # The key to use to retrieve the grouped field to display 
+    def grouped_key_for_results
+      blacklight_config.index.group
+    end
+  end
+end

data/lib/blacklight/solr_helper.rb

@@ -1,264 +1,9 @@
-# -*- encoding : utf-8 -*-
-# SolrHelper is a controller layer mixin. It is in the controller scope: request params, session etc.
-# 
-# NOTE: Be careful when creating variables here as they may be overriding something that already exists.
-# The ActionController docs: http://api.rubyonrails.org/classes/ActionController/Base.html
-#
-# Override these methods in your own controller for customizations:
-# 
-#   class CatalogController < ActionController::Base
-#   
-#     include Blacklight::Catalog
-#   
-#     def solr_search_params
-#       super.merge :per_page=>10
-#     end
-#   end
-#
-# Or by including in local extensions:
-#   module LocalSolrHelperExtension
-#     [ local overrides ]
-#   end
-#
-#   class CatalogController < ActionController::Base
-#   
-#     include Blacklight::Catalog
-#     include LocalSolrHelperExtension
-#   
-#     def solr_search_params
-#       super.merge :per_page=>10
-#     end
-#   end
-#
-# Or by using ActiveSupport::Concern:
-#
-#   module LocalSolrHelperExtension
-#     extend ActiveSupport::Concern
-#     include Blacklight::SolrHelper
-#
-#     [ local overrides ]
-#   end
-#
-#   class CatalogController < ApplicationController
-#     include LocalSolrHelperExtension
-#     include Blacklight::Catalog
-#   end  
-
-module Blacklight::SolrHelper
-  extend ActiveSupport::Concern
-  extend Deprecation
-  self.deprecation_horizon = 'blacklight 6.0'
-
-  include Blacklight::RequestBuilders
-
-  ##
-  # Execute a solr query
-  # @see [Blacklight::SolrRepository#send_and_receive]
-  # @return [Blacklight::SolrResponse] the solr response object
-  def find *args
-    solr_params = args.extract_options!
-    path = args.first || blacklight_config.solr_path
-
-    solr_params[:qt] ||= blacklight_config.qt
-
-    solr_repository.send_and_receive path, solr_params
-  end
-  deprecation_deprecate :find
-
-  # returns a params hash for finding a single solr document (CatalogController #show action)
-  def solr_doc_params(id=nil)
-    default_solr_doc_params(id)
-  end
-  deprecation_deprecate :solr_doc_params
-
-  # a solr query method
-  # given a user query, return a solr response containing both result docs and facets
-  # - mixes in the Blacklight::Solr::SpellingSuggestions module
-  #   - the response will have a spelling_suggestions method
-  # Returns a two-element array (aka duple) with first the solr response object,
-  # and second an array of SolrDocuments representing the response.docs
-  def get_search_results(user_params = params || {}, extra_controller_params = {})
-    solr_response = query_solr(user_params, extra_controller_params)
-
-    case
-    when (solr_response.grouped? && grouped_key_for_results)
-      [solr_response.group(grouped_key_for_results), []]
-    when (solr_response.grouped? && solr_response.grouped.length == 1)
-      [solr_response.grouped.first, []]
-    else
-      [solr_response, solr_response.documents]
-    end
-  end
-
-  	
-  # a solr query method
-  # given a user query,
-  # @return [Blacklight::SolrResponse] the solr response object
-  def query_solr(user_params = params || {}, extra_controller_params = {})
-    solr_params = self.solr_search_params(user_params).merge(extra_controller_params)
-
-    solr_repository.search(solr_params)
-  end
-
-  # a solr query method
-  # retrieve a solr document, given the doc id
-  # @return [Blacklight::SolrResponse, Blacklight::SolrDocument] the solr response object and the first document
-  def get_solr_response_for_doc_id(id=nil, extra_controller_params={})
-    if id.nil?
-      Deprecation.warn Blacklight::SolrHelper, "Calling #get_solr_response_for_doc_id without an explicit id argument is deprecated"
-      id ||= params[:id]
+module Blacklight
+  module SolrHelper
+    extend ActiveSupport::Concern
+    included do
+      include Blacklight::SearchHelper
+      Deprecation.warn Blacklight::SolrHelper, "Blacklight::SolrHelper is deprecated; use Blacklight::SearchHelper instead"
     end
-
-    old_solr_doc_params = Deprecation.silence(Blacklight::SolrHelper) do
-      solr_doc_params(id)
-    end
-
-    if default_solr_doc_params(id) != old_solr_doc_params
-      Deprecation.warn Blacklight::SolrHelper, "The #solr_doc_params method is deprecated. Instead, you should provide a custom SolrRepository implementation for the additional behavior you're offering"
-      extra_controller_params = extra_controller_params.merge(old_solr_doc_params)
-    end
-
-    solr_response = solr_repository.find id, extra_controller_params
-    [solr_response, solr_response.documents.first]
-  end
-  
-  ##
-  # Retrieve a set of documents by id
-  # @overload get_solr_response_for_document_ids(ids, extra_controller_params)
-  # @overload get_solr_response_for_document_ids(ids, user_params, extra_controller_params)
-  def get_solr_response_for_document_ids(ids=[], *args)
-    # user_params = params || {}, extra_controller_params = {}
-    if args.length == 1
-      user_params = params
-      extra_controller_params = args.first || {}
-    else
-      user_params, extra_controller_params = args
-      user_params ||= params
-      extra_controller_params ||= {}
-    end
-
-    solr_response = query_solr(user_params, extra_controller_params.merge(solr_document_ids_params(ids)))
-
-    [solr_response, solr_response.documents]
-  end
-
-  # given a field name and array of values, get the matching SOLR documents
-  # @return [Blacklight::SolrResponse, Array<Blacklight::SolrDocument>] the solr response object and a list of solr documents
-  def get_solr_response_for_field_values(field, values, extra_controller_params = {})
-    solr_response = query_solr(params, extra_controller_params.merge(solr_documents_by_field_values_params(field, values)))
-
-    [solr_response, solr_response.documents]
-  end
-  deprecation_deprecate :get_solr_response_for_field_values
-
-  ##
-  # Get the solr response when retrieving only a single facet field
-  # @return [Blacklight::SolrResponse] the solr response
-  def get_facet_field_response(facet_field, user_params = params || {}, extra_controller_params = {})
-    solr_params = solr_facet_params(facet_field, user_params, extra_controller_params)
-    query_solr(user_params, extra_controller_params.merge(solr_facet_params(facet_field, user_params, extra_controller_params)))
-  end
-
-  # a solr query method
-  # used to paginate through a single facet field's values
-  # /catalog/facet/language_facet
-  def get_facet_pagination(facet_field, user_params=params || {}, extra_controller_params={})
-    # Make the solr call
-    response = get_facet_field_response(facet_field, user_params, extra_controller_params)
-
-    limit = response.params[:"f.#{facet_field}.facet.limit"].to_s.to_i - 1
-
-    # Actually create the paginator!
-    # NOTE: The sniffing of the proper sort from the solr response is not
-    # currently tested for, tricky to figure out how to test, since the
-    # default setup we test against doesn't use this feature.
-    return     Blacklight::Solr::FacetPaginator.new(response.facets.first.items,
-      :offset => response.params[:"f.#{facet_field}.facet.offset"],
-      :limit => limit,
-      :sort => response.params[:"f.#{facet_field}.facet.sort"] || response.params["facet.sort"]
-    )
-  end
-  deprecation_deprecate :get_facet_pagination
-
-  # a solr query method
-  # this is used when selecting a search result: we have a query and a
-  # position in the search results and possibly some facets
-  # Pass in an index where 1 is the first document in the list, and
-  # the Blacklight app-level request params that define the search.
-  # @return [Blacklight::SolrDocument, nil] the found document or nil if not found
-  def get_single_doc_via_search(index, request_params)
-    solr_params = solr_search_params(request_params)
-
-    solr_params[:start] = (index - 1) # start at 0 to get 1st doc, 1 to get 2nd.
-    solr_params[:rows] = 1
-    solr_params[:fl] = '*'
-    solr_response = solr_repository.search(solr_params)
-    solr_response.documents.first
-  end
-  deprecation_deprecate :get_single_doc_via_search
-
-  # Get the previous and next document from a search result
-  # @return [Blacklight::SolrResponse, Array<Blacklight::SolrDocument>] the solr response and a list of the first and last document
-  def get_previous_and_next_documents_for_search(index, request_params, extra_controller_params={})
-
-    solr_response = query_solr(request_params, extra_controller_params.merge(previous_and_next_document_params(index)))
-
-    document_list = solr_response.documents
-
-    # only get the previous doc if there is one
-    prev_doc = document_list.first if index > 0
-    next_doc = document_list.last if (index + 1) < solr_response.total
-
-    [solr_response, [prev_doc, next_doc]]
-  end
-  
-  # a solr query method
-  # does a standard search but returns a simplified object.
-  # an array is returned, the first item is the query string,
-  # the second item is an other array. This second array contains
-  # all of the field values for each of the documents...
-  # where the field is the "field" argument passed in.
-  def get_opensearch_response(field=nil, request_params = params || {}, extra_controller_params={})
-    field ||= blacklight_config.view_config('opensearch').title_field
-
-    response = query_solr(request_params, solr_opensearch_params(field).merge(extra_controller_params))
-
-    [response.params[:q], response.documents.flat_map {|doc| doc[field] }.uniq]
-  end
-
-  ##
-  # The key to use to retrieve the grouped field to display 
-  def grouped_key_for_results
-    blacklight_config.index.group
-  end
-
-  def solr_repository
-    @solr_repository ||= Blacklight::SolrRepository.new(blacklight_config)
-  end
-
-  def blacklight_solr
-    solr_repository.blacklight_solr
-  end
-  deprecation_deprecate :blacklight_solr
-
-  private
-
-  ##
-  # @deprecated
-  def default_solr_doc_params(id=nil)
-    id ||= params[:id]
-
-    # add our document id to the document_unique_id_param query parameter
-    p = blacklight_config.default_document_solr_params.merge({
-      # this assumes the request handler will map the unique id param
-      # to the unique key field using either solr local params, the
-      # real-time get handler, etc.
-      blacklight_config.document_unique_id_param => id
-    })
-
-    p[:qt] ||= blacklight_config.document_solr_request_handler
-
-    p
   end
-
 end