blacklight 4.3.0 → 4.4.0

data/lib/blacklight/configuration.rb

@@ -18,7 +18,7 @@ module Blacklight
           :document_solr_request_handler => nil,
           :default_document_solr_params => {},
           :show => OpenStructWithHashAccess.new(:html_title => unique_key, :heading => unique_key),
-          :index => OpenStructWithHashAccess.new(:show_link => unique_key),
+          :index => OpenStructWithHashAccess.new(:show_link => unique_key, :record_display_type => 'format', :group => false),
           :spell_max => 5,
           :max_per_page => 100,
           :per_page => [10,20,50,100],

data/lib/blacklight/controller.rb

@@ -99,14 +99,17 @@ module Blacklight::Controller
       current_user_bookmarks = current_user.bookmarks.all.collect(&:document_id)
 
       guest_user.searches.all.reject { |s| current_user_searches.include?(s.query_params)}.each do |s| 
-        s.user_id = current_user.id 
-        s.save 
+        current_user.searches << s
+        s.save!
       end
 
       guest_user.bookmarks.all.reject { |b| current_user_bookmarks.include?(b.document_id)}.each do |b| 
-        b.user_id = current_user.id 
-        b.save
+        current_user.bookmarks << b
+        b.save!
       end
+
+      # let guest_user know we've moved some bookmarks from under it
+      guest_user.reload if guest_user.persisted?
     end
 
     ##

data/lib/blacklight/facet.rb

@@ -0,0 +1,79 @@
+# These are methods that are used at both the view helper and controller layers
+# They are only dependent on `blacklight_config` and `@response`
+#
+module Blacklight
+  module Facet
+    def facets_from_request(fields = facet_field_names)
+      fields.map { |solr_field| facet_by_field_name(solr_field) }.compact
+    end
+
+    def facet_field_names
+      blacklight_config.facet_fields.keys
+    end
+
+    def facet_configuration_for_field(field)
+      blacklight_config.facet_fields[field] || Blacklight::Configuration::FacetField.new(:field => field).normalize!
+    end
+
+
+    # Get a FacetField object from the @response
+    def facet_by_field_name solr_field
+      case solr_field
+        when String, Symbol
+          extract_solr_facet_by_field_name(solr_field)
+        when Blacklight::Configuration::FacetField
+          extract_solr_facet_by_field_name(solr_field.field)
+        else
+          solr_field
+        end
+    end
+
+    private
+
+    # Get the solr response for the solr field :field
+    def extract_solr_facet_by_field_name facet_name
+      facet_field = facet_configuration_for_field(facet_name)
+      case 
+        when (facet_field.respond_to?(:query) and facet_field.query)
+          create_rsolr_facet_field_response_for_query_facet_field facet_name, facet_field 
+        when (facet_field.respond_to?(:pivot) and facet_field.pivot)
+          create_rsolr_facet_field_response_for_pivot_facet_field facet_name, facet_field   
+        else
+          @response.facet_by_field_name(facet_name)
+      end
+    end
+
+    def create_rsolr_facet_field_response_for_query_facet_field facet_name, facet_field
+      salient_facet_queries = facet_field.query.map { |k, x| x[:fq] }
+      items = []
+      @response.facet_queries.select { |k,v| salient_facet_queries.include?(k) }.reject { |value, hits| hits == 0 }.map do |value,hits|
+        salient_fields = facet_field.query.select { |key, val| val[:fq] == value }
+        key = ((salient_fields.keys if salient_fields.respond_to? :keys) || salient_fields.first).first
+        items << Blacklight::SolrResponse::Facets::FacetItem.new(:value => key, :hits => hits, :label => facet_field.query[key][:label])
+      end
+   
+      Blacklight::SolrResponse::Facets::FacetField.new facet_name, items
+    end
+
+
+    def create_rsolr_facet_field_response_for_pivot_facet_field facet_name, facet_field
+      items = []
+      (@response.facet_pivot[facet_field.pivot.join(",")] || []).map do |lst|
+        items << construct_pivot_field(lst)
+      end
+   
+      Blacklight::SolrResponse::Facets::FacetField.new facet_name, items
+    end
+
+    def construct_pivot_field lst, parent_fq = {}
+      items = []
+
+      lst[:pivot].each do |i|
+        items << construct_pivot_field(i, parent_fq.merge({ lst[:field] => lst[:value] }))
+      end if lst[:pivot]
+
+      Blacklight::SolrResponse::Facets::FacetItem.new(:value => lst[:value], :hits => lst[:count], :field => lst[:field], :items => items, :fq => parent_fq)
+
+    end
+  end
+end

data/lib/blacklight/routes.rb

@@ -62,7 +62,6 @@ module Blacklight
           post 'catalog/email'
           get 'catalog/sms', :as => "sms_catalog"
           get 'catalog/endnote', :as => "endnote_catalog"
-          get 'catalog/send_email_record', :as => "send_email_record_catalog"
           get "catalog/facet/:id", :to => 'catalog#facet', :as => 'catalog_facet'
 
 

data/lib/blacklight/solr/document.rb

@@ -109,6 +109,10 @@ module Blacklight::Solr::Document
     id
   end
 
+  def as_json(options = nil)
+    @_source.as_json(options)
+  end
+
   def to_partial_path
     'catalog/document'
   end

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

@@ -94,7 +94,7 @@ module Blacklight::Solr::Document::MarcExport
          export_text << "&amp;rft.pub=" + ((publisher_info.nil? or publisher_info['b'].nil?) ? "" : CGI::escape(publisher_info['b']))
          export_text << "&amp;rft.format=" + (format.nil? ? "" : CGI::escape(format))
      end
-     export_text unless export_text.blank?
+     export_text.html_safe unless export_text.blank?
   end
 
 

data/lib/blacklight/solr_helper.rb

@@ -47,6 +47,7 @@
 module Blacklight::SolrHelper
   extend ActiveSupport::Concern
   include Blacklight::SearchFields
+  include Blacklight::Facet
 
   included do
     if self.respond_to?(:helper_method)
@@ -66,7 +67,7 @@ module Blacklight::SolrHelper
     # CatalogController.include ModuleDefiningNewMethod
     # CatalogController.solr_search_params_logic += [:new_method]
     # CatalogController.solr_search_params_logic.delete(:we_dont_want)
-    self.solr_search_params_logic = [: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 ]
+    self.solr_search_params_logic = [: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 ]
   end
 
   def force_to_utf8(value)
@@ -95,7 +96,7 @@ module Blacklight::SolrHelper
   # if needed. 
   def solr_param_quote(val, options = {})
     options[:quote] ||= '"'
-    unless val =~ /^[a-zA-Z$_\-\^]+$/
+    unless val =~ /^[a-zA-Z0-9$_\-\^]+$/
       val = options[:quote] +
         # Yes, we need crazy escaping here, to deal with regexp esc too!
         val.gsub("'", "\\\\\'").gsub('"', "\\\\\"") + 
@@ -327,13 +328,14 @@ module Blacklight::SolrHelper
         if blacklight_config.add_facet_fields_to_solr_request
           case 
             when facet.pivot
-              solr_parameters[:'facet.pivot'] << facet.pivot.join(",")
+              solr_parameters[:'facet.pivot'] << with_ex_local_param(facet.ex, facet.pivot.join(","))
             when facet.query
-              solr_parameters[:'facet.query'] += facet.query.map { |k, x| x[:fq] } 
+              solr_parameters[:'facet.query'] += facet.query.map { |k, x| with_ex_local_param(facet.ex, x[:fq]) } 
    
             when facet.ex
-              idx = solr_parameters[:'facet.field'].index(facet.field)
-              solr_parameters[:'facet.field'][idx] = "{!ex=#{facet.ex}}#{solr_parameters[:'facet.field'][idx]}" unless idx.nil?
+              if idx = solr_parameters[:'facet.field'].index(facet.field)
+                solr_parameters[:'facet.field'][idx] = with_ex_local_param(facet.ex, solr_parameters[:'facet.field'][idx])
+              end
           end
 
           if facet.sort
@@ -348,6 +350,14 @@ module Blacklight::SolrHelper
       end
     end
 
+    def with_ex_local_param(ex, value)
+      if ex
+        "{!ex=#{ex}}#{value}"
+      else
+        value
+      end
+    end
+
     def add_solr_fields_to_query solr_parameters, user_parameters
       return unless blacklight_config.add_field_configuration_to_solr_request
       blacklight_config.index_fields.each do |field_name, field|
@@ -359,6 +369,13 @@ module Blacklight::SolrHelper
       end
     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, user_parameters
+      if user_parameters[:f] and user_parameters[:f][grouped_key_for_results]
+        solr_parameters[:group] = false
+      end
+    end
+
 
   
   # a solr query method
@@ -369,8 +386,16 @@ module Blacklight::SolrHelper
   # 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)
-    document_list = solr_response.docs.collect {|doc| SolrDocument.new(doc, solr_response)} 
-    return [solr_response, document_list]
+
+    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
+      document_list = solr_response.docs.collect {|doc| SolrDocument.new(doc, solr_response)} 
+      [solr_response, document_list]
+    end
   end
 
   	
@@ -580,4 +605,10 @@ module Blacklight::SolrHelper
     return limit
   end
 
+  ##
+  # The key to use to retrieve the grouped field to display 
+  def grouped_key_for_results
+    blacklight_config.index.group
+  end
+
 end

data/lib/blacklight/solr_response.rb

@@ -1,8 +1,16 @@
+require 'kaminari'
+
 class Blacklight::SolrResponse < HashWithIndifferentAccess
 
+  require  'blacklight/solr_response/pagination_methods'
+
   autoload :Spelling, 'blacklight/solr_response/spelling'
   autoload :Facets, 'blacklight/solr_response/facets'
   autoload :MoreLikeThis, 'blacklight/solr_response/more_like_this'
+  autoload :GroupResponse, 'blacklight/solr_response/group_response'
+  autoload :Group, 'blacklight/solr_response/group'
+
+  include PaginationMethods
 
   attr_reader :request_params
   def initialize(data, request_params)
@@ -18,7 +26,6 @@ class Blacklight::SolrResponse < HashWithIndifferentAccess
     self['responseHeader']
   end
   
-
   def update(other_hash) 
     other_hash.each_pair { |key, value| self[key] = value } 
     self 
@@ -34,7 +41,7 @@ class Blacklight::SolrResponse < HashWithIndifferentAccess
 
   def docs
     @docs ||= begin
-      response['docs']
+      response['docs'] || []
     end
   end
 
@@ -42,9 +49,34 @@ class Blacklight::SolrResponse < HashWithIndifferentAccess
     self['spelling']
   end
 
+  def grouped
+    @groups ||= self["grouped"].map do |field, group|
+      # grouped responses can either be grouped by:
+      #   - field, where this key is the field name, and there will be a list
+      #        of documents grouped by field value, or:
+      #   - function, where the key is the function, and the documents will be
+      #        further grouped by function value, or:
+      #   - query, where the key is the query, and the matching documents will be
+      #        in the doclist on THIS object
+      if group["groups"] # field or function
+        GroupResponse.new field, group, self
+      else # query
+        Group.new field, group, self
+      end
+    end
+  end
+
+  def group key
+    grouped.select { |x| x.key == key }.first
+  end
+
+  def grouped?
+    self.has_key? "grouped"
+  end
+
   module Response
     def response
-      self[:response]
+      self[:response] || {}
     end
     
     # short cut to response['numFound']

data/lib/blacklight/solr_response/facets.rb

@@ -20,6 +20,10 @@ module Blacklight::SolrResponse::Facets
     def label
       super || value
     end
+
+    def as_json(props = nil)
+      table.as_json(props)
+    end
   end
   
   # represents a facet; which is a field and its values

data/lib/blacklight/solr_response/group.rb

@@ -0,0 +1,33 @@
+class Blacklight::SolrResponse::Group
+
+  include Blacklight::SolrResponse::PaginationMethods
+
+  attr_reader :key, :group, :response
+  
+  def initialize key, group, response
+    @key = key
+    @group = group
+    @response = response
+  end
+
+  def doclist
+    group[:doclist]
+  end
+
+  # short cut to response['numFound']
+  def total
+    doclist[:numFound].to_s.to_i
+  end
+    
+  def start
+    doclist[:start].to_s.to_i
+  end
+
+  def docs
+    doclist[:docs].map {|doc| SolrDocument.new(doc, response)}
+  end
+
+  def field
+    response.group_field
+  end
+end

data/lib/blacklight/solr_response/group_response.rb

@@ -0,0 +1,49 @@
+class Blacklight::SolrResponse::GroupResponse
+
+  include Blacklight::SolrResponse::PaginationMethods
+
+  attr_reader :key, :group, :response
+
+  def initialize key, group, response
+    @key = key
+    @group = group
+    @response = response
+  end
+
+  alias_method :group_field, :key
+
+  def groups
+    @groups ||= group["groups"].map do |g|
+      Blacklight::SolrResponse::Group.new g[:groupValue], g, self
+    end
+  end
+
+  def group_limit
+    params.fetch(:'group.limit', 1).to_s.to_i
+  end
+
+  def total
+    # ngroups is only available in Solr 4.1+
+    # fall back on the number of facet items for that field?
+    (group["ngroups"] || (response.facet_by_field_name(key) || []).length).to_s.to_i
+  end
+    
+  def start
+    params[:start].to_s.to_i
+  end
+
+  def method_missing meth, *args, &block
+
+    if response.respond_to? meth
+      response.send(meth, *args, &block)
+    else
+      super
+    end
+
+  end
+
+  def respond_to? meth
+    response.respond_to?(meth) || super
+  end
+
+end

data/lib/blacklight/solr_response/pagination_methods.rb

@@ -0,0 +1,27 @@
+module Blacklight::SolrResponse::PaginationMethods
+
+  include Kaminari::PageScopeMethods
+
+  def limit_value #:nodoc:
+    rows
+  end
+
+  def offset_value #:nodoc:
+    start
+  end
+
+  def total_count #:nodoc:
+    total
+  end
+
+  ## Methods in kaminari master that we'd like to use today.
+  # Next page number in the collection
+  def next_page
+    current_page + 1 unless last_page?
+    end
+
+  # Previous page number in the collection
+  def prev_page
+    current_page - 1 unless first_page?
+  end
+end

data/lib/blacklight/user.rb

@@ -6,46 +6,44 @@ module Blacklight::User
   # SEE ALSO:  The /lib/blacklight/engine.rb class for how when this 
   # is injected into the hosting application through ActiveRecord::Base extend
   def self.included(base)
-    base.send :has_many, :bookmarks, :dependent => :destroy, :as => :user
-    base.send :has_many, :searches,  :dependent => :destroy, :as => :user
-    base.send :include, InstanceMethods
+    if base.respond_to? :has_many
+      base.send :has_many, :bookmarks, :dependent => :destroy, :as => :user
+      base.send :has_many, :searches,  :dependent => :destroy, :as => :user
+    end
   end
 
-  # The following methods will be included in any active model object
-  # that calls "is_blacklight_user"
+  # This is left for backwards-compatibility
+  # Remove this in Blacklight 5.x
   module InstanceMethods
+    include Blacklight::User
+  end
 
-    def has_bookmarks?
-      bookmarks.count > 0
-    end
+  def has_bookmarks?
+    bookmarks.any?
+  end
     
-    def has_searches?
-      searches.count > 0
-    end
+  def has_searches?
+    searches.any?
+  end
     
-    def bookmarked_document_ids
-      self.bookmarks.map{|bm|bm.document_id}
-    end
+  def bookmarked_document_ids
+    self.bookmarks.pluck(:document_id)
+  end
     
-    # see #current_bookmark_for, is easier
-    def document_is_bookmarked?(document_id)
-      bookmarked_document_ids.include? document_id
-    end
+  # see #current_bookmark_for, is easier
+  def document_is_bookmarked?(document_id)
+    bookmarked_document_ids.include? document_id.to_s
+  end
     
-    # returns a Bookmark object if there is one for document_id, else
-    # nil. 
-    def existing_bookmark_for(document_id)
-      # to_a, we don't want to go to the database, we want to use cached
-      # copy. 
-      self.bookmarks.to_a.find {|b| b.document_id == document_id}
-    end
+  # returns a Bookmark object if there is one for document_id, else
+  # nil. 
+  def existing_bookmark_for(document_id)
+    self.bookmarks.where(:document_id => document_id).first
+  end
     
-    def documents_to_bookmark=(docs)
-      docs.each do |doc|
-        self.bookmarks.create(doc) unless bookmarked_document_ids.include?(doc[:document_id])
-      end
+  def documents_to_bookmark=(docs)
+    docs.reject { |doc| document_is_bookmarked?(doc[:document_id]) }.each do |doc|
+      self.bookmarks.create(doc) 
     end
-
-  end # /InstanceMethods
-
+  end
 end