blacklight 3.8.2 → 4.0.0.pre6

data/lib/blacklight.rb

@@ -1,7 +1,6 @@
 # -*- encoding : utf-8 -*-
 require 'kaminari'
 require 'rsolr'
-require 'rsolr-ext'
 
 module Blacklight
 
@@ -24,6 +23,7 @@ module Blacklight
   autoload :Routes, 'blacklight/routes'
 
   autoload :OpenStructWithHashAccess, 'blacklight/utils'
+  autoload :SolrResponse, 'blacklight/solr_response'
 
   extend SearchFields
   
@@ -48,7 +48,7 @@ module Blacklight
   end
 
   def self.solr
-    @solr ||=  RSolr::Ext.connect(Blacklight.solr_config)
+    @solr ||=  RSolr.connect(Blacklight.solr_config)
   end
 
   def self.solr_config

data/lib/blacklight/catalog.rb

@@ -73,6 +73,11 @@ module Blacklight::Catalog
     # displays values and pagination links for a single facet field
     def facet
       @pagination = get_facet_pagination(params[:id], params)
+
+      respond_to do |format|
+        format.html 
+        format.js { render :layout => false }
+      end
     end
     
     # method to serve up XML OpenSearch description and JSON autocomplete response
@@ -111,11 +116,22 @@ module Blacklight::Catalog
           else
             flash[:error] = I18n.t('blacklight.email.errors.to.invalid', :to => params[:to])
           end
-          email.deliver unless flash[:error]
-          redirect_to :back
         else
           flash[:error] = I18n.t('blacklight.email.errors.to.blank')
         end
+
+        unless flash[:error]
+          email.deliver 
+          flash[:success] = "Email sent"
+          redirect_to catalog_path(params['id']) unless request.xhr?
+        end
+      end
+
+      unless !request.xhr? && flash[:success]
+        respond_to do |format|
+          format.js { render :layout => false }
+          format.html
+        end
       end
     end
     
@@ -133,30 +149,36 @@ module Blacklight::Catalog
             else
               email = RecordMailer.sms_record(@documents, {:to => phone_num, :carrier => params[:carrier]}, url_gen_params)
             end
-            email.deliver unless flash[:error]
-            redirect_to :back
+
           else
             flash[:error] = I18n.t('blacklight.sms.errors.carrier.blank')
           end
         else
           flash[:error] = I18n.t('blacklight.sms.errors.to.blank')
         end
+
+        unless flash[:error]
+          email.deliver 
+          flash[:success] = "SMS sent"
+          redirect_to catalog_path(params['id']) unless request.xhr?
+        end
+      end
         
+      unless !request.xhr? && flash[:success]
+        respond_to do |format|
+          format.js { render :layout => false }
+          format.html
+        end
       end
     end
     
-    # DEPRECATED backwards compatible method that will just redirect to the appropriate action.  It will return a 404 if a bad action is supplied (just in case).
-    def send_email_record
-      warn "[DEPRECATION] CatalogController#send_email_record is deprecated.  Please use the email or sms controller action instead."
-      if ["sms","email"].include?(params[:style])
-        redirect_to :action => params[:style] 
-      else
-        render :file => "#{::Rails.root}/public/404.html", :layout => false, :status => 404
-      end
-    end
-
     def librarian_view
       @response, @document = get_solr_response_for_doc_id
+
+      respond_to do |format|
+        format.html
+        format.js { render :layout => false }
+      end
     end
     
     

data/lib/blacklight/configuration.rb

@@ -12,7 +12,8 @@ module Blacklight
           unique_key = ((SolrDocument.unique_key if defined?(SolrDocument)) || 'id')
           
           {
-          :solr_request_handler => 'select',
+          :solr_path => 'select',
+          :qt => 'search',
           :default_solr_params => {},
           :document_solr_request_handler => nil,
           :default_document_solr_params => {},
@@ -21,12 +22,14 @@ module Blacklight
           :spell_max => 5,
           :max_per_page => 100,
           :per_page => [10,20,50,100],
-          :add_facet_fields_to_solr_request => false
+          :add_facet_fields_to_solr_request => false,
+          :add_field_configuration_to_solr_request => false
           }
         end
       end
     end
 
+
     # XXX this isn't very pretty, but it works.
     require 'blacklight/configuration/fields'
     require 'blacklight/configuration/solr_field'
@@ -82,6 +85,11 @@ module Blacklight
       self.add_facet_fields_to_solr_request = true
     end
 
+    # Add any configured facet fields to the default solr parameters hash
+    def add_field_configuration_to_solr_request!
+      self.add_field_configuration_to_solr_request = true
+    end
+
     def facet_fields_to_add_to_solr
       return facet_fields.reject { |k,v| v[:query] }.map { |k,v| v.field } if self.add_facet_fields_to_solr_request
 

data/lib/blacklight/mash.rb

@@ -0,0 +1,151 @@
+# This class has dubious semantics and we only have it so that people can write
+# params[:key] instead of params['key'].
+class Mash < Hash
+
+  # @param constructor<Object>
+  #   The default value for the mash. Defaults to an empty hash.
+  #
+  # @details [Alternatives]
+  #   If constructor is a Hash, a new mash will be created based on the keys of
+  #   the hash and no default value will be set.
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash) 
+      super() 
+      update(constructor) 
+    else 
+      super(constructor) 
+    end 
+  end
+
+  # @param key<Object> The default value for the mash. Defaults to nil.
+  #
+  # @details [Alternatives]
+  #   If key is a Symbol and it is a key in the mash, then the default value will
+  #   be set to the value matching the key.
+  def default(key = nil) 
+    if key.is_a?(Symbol) && include?(key = key.to_s) 
+      self[key] 
+    else 
+      super 
+    end 
+  end 
+ 
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer) 
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+  # @param key<Object> The key to set.
+  # @param value<Object>
+  #   The value to set the key to.
+  #
+  # @see Mash#convert_key
+  # @see Mash#convert_value
+  def []=(key, value) 
+    regular_writer(convert_key(key), convert_value(value)) 
+  end
+
+  # @param other_hash<Hash>
+  #   A hash to update values in the mash with. The keys and the values will be
+  #   converted to Mash format.
+  #
+  # @return <Mash> The updated mash.
+  def update(other_hash) 
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) } 
+    self 
+  end 
+ 
+  alias_method :merge!, :update
+
+  # @param key<Object> The key to check for. This will be run through convert_key.
+  #
+  # @return <TrueClass, FalseClass> True if the key exists in the mash.
+  def key?(key) 
+    super(convert_key(key)) 
+  end 
+
+  # def include? def has_key? def member?
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  # @param key<Object> The key to fetch. This will be run through convert_key.
+  # @param *extras<Array> Default value.
+  #
+  # @return <Object> The value at key or the default value.
+  def fetch(key, *extras) 
+    super(convert_key(key), *extras) 
+  end
+
+  # @param *indices<Array>
+  #   The keys to retrieve values for. These will be run through +convert_key+.
+  #
+  # @return <Array> The values at each of the provided keys
+  def values_at(*indices) 
+    indices.collect {|key| self[convert_key(key)]} 
+  end
+
+  # @return <Mash> A duplicate of this mash.
+  def dup 
+    Mash.new(self) 
+  end
+
+  # @param hash<Hash> The hash to merge with the mash.
+  #
+  # @return <Mash> A new mash with the hash values merged in.
+  def merge(hash) 
+    self.dup.update(hash) 
+  end
+
+  # @param key<Object>
+  #   The key to delete from the mash.\
+  def delete(key) 
+    super(convert_key(key)) 
+  end
+
+  # Used to provide the same interface as Hash.
+  #
+  # @return <Mash> This mash unchanged.
+  def stringify_keys!; self end
+ 
+  # @return <Hash> The mash as a Hash with string keys.
+  def to_hash 
+    Hash.new(default).merge(self) 
+  end 
+ 
+  protected
+  # @param key<Object> The key to convert.
+  #
+  # @param <Object>
+  #   The converted key. If the key was a symbol, it will be converted to a
+  #   string.
+  #
+  # @api private
+  def convert_key(key) 
+    key.kind_of?(Symbol) ? key.to_s : key 
+  end
+
+  # @param value<Object> The value to convert.
+  #
+  # @return <Object>
+  #   The converted value. A Hash or an Array of hashes, will be converted to
+  #   their Mash equivalents.
+  #
+  # @api private
+  def convert_value(value) 
+    case value 
+    when Hash 
+      value.to_mash 
+    when Array 
+      value.collect { |e| convert_value(e) } 
+    else 
+      value 
+    end 
+  end
+end
+
+unless Hash.respond_to?(:to_mash)
+  class Hash
+    def to_mash
+      Mash.new(self)
+    end
+  end
+end

data/lib/blacklight/solr/document.rb

@@ -1,6 +1,5 @@
 # -*- encoding : utf-8 -*-
 require 'rsolr'
-require 'rsolr-ext'
 ##
 ##
 # = Introduction
@@ -10,8 +9,7 @@ require 'rsolr-ext'
 # provided for you which is pretty much a blank class "include"ing
 # Blacklight::Solr::Document.
 #
-# Blacklight::Solr::Document mixes in Rsolr::Ext::Model to the calling class.
-# It also provides some DefaultFinders.
+# Blacklight::Solr::Document provides some DefaultFinders.
 #
 # It also provides support for Document Extensions, which advertise supported
 # transformation formats.
@@ -25,28 +23,92 @@ module Blacklight::Solr::Document
   autoload :Sms, 'blacklight/solr/document/sms'
   autoload :Extensions, 'blacklight/solr/document/extensions'
   autoload :Export, 'blacklight/solr/document/export'
+  autoload :MoreLikeThis, 'blacklight/solr/document/more_like_this'
 
   extend ActiveSupport::Concern
   include Blacklight::Solr::Document::Export
+  include Blacklight::Solr::Document::MoreLikeThis
 
   included do
     extend ActiveModel::Naming
-    include RSolr::Ext::Model
-    include RSolrExtOverrides
     include Blacklight::Solr::Document::Extensions
-
   end    
 
-  module RSolrExtOverrides
-    def id
-      self[self.class.unique_key]
+  attr_reader :solr_response
+
+  def initialize(source_doc={}, solr_response=nil)
+    @_source = source_doc.with_indifferent_access
+    @solr_response = solr_response
+    apply_extensions
+  end
+
+  # the wrapper method to the @_source object.
+  # If a method is missing, it gets sent to @_source
+  # with all of the original params and block
+  def method_missing(m, *args, &b)
+    @_source.send(m, *args, &b)
+  end
+
+  def [] *args
+    @_source.send :[], *args
+  end
+
+  # Helper method to check if value/multi-values exist for a given key.
+  # The value can be a string, or a RegExp
+  # Multiple "values" can be given; only one needs to match.
+  # 
+  # Example:
+  # doc.has?(:location_facet)
+  # doc.has?(:location_facet, 'Clemons')
+  # doc.has?(:id, 'h009', /^u/i)
+  def has?(k, *values)
+    return if @_source[k].nil?
+    return true if @_source.key?(k) and values.empty?
+    target = @_source[k]
+    if target.is_a?(Array)
+      values.each do |val|
+        return target.any?{|tv| val.is_a?(Regexp) ? (tv =~ val) : (tv==val)}
+      end
+    else
+      return values.any? {|val| val.is_a?(Regexp) ? (target =~ val) : (target == val)}
     end
+  end
 
-    def to_param
-      id
+  def has_highlight_field? k
+    return false if @solr_response['highlighting'].blank? or @solr_response['highlighting'][self.id].blank?
+    
+    @solr_response['highlighting'][self.id].key? k.to_s
+  end
+
+  def highlight_field k
+    return nil unless has_highlight_field? k
+    @solr_response['highlighting'][self.id][k.to_s].map { |x| x.html_safe }
+
+  end
+
+  # helper
+  # key is the name of the field
+  # opts is a hash with the following valid keys:
+  #  - :sep - a string used for joining multivalued field values
+  #  - :default - a value to return when the key doesn't exist
+  # if :sep is nil and the field is a multivalued field, the array is returned
+  def get(key, opts={:sep=>', ', :default=>nil})
+    if @_source.key? key
+      val = @_source[key]
+      (val.is_a?(Array) and opts[:sep]) ? val.join(opts[:sep]) : val
+    else
+      opts[:default]
     end
   end
 
+  def id
+    self[self.class.unique_key]
+  end
+
+  def to_param
+    id
+  end
+
   def to_partial_path
     'catalog/document'
   end

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

@@ -20,14 +20,6 @@
 module Blacklight::Solr::Document::Extensions
   extend ActiveSupport::Concern
 
-  included do
-    # after_initialize hook comes from RSolr::Ext::Model, I think.
-    # We need to make sure all extensions get applied.
-    after_initialize do 
-       apply_extensions 
-    end
-  end
-
   # Needs to be called in initializer of class including this module, to
   # apply all registered extensions on a per-document basis
   def apply_extensions

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

@@ -134,8 +134,13 @@ module Blacklight::Solr::Document::MarcExport
       java_import java.text.Normalizer
       Normalizer.normalize(text, Normalizer::Form::NFC).to_s
     else 
-      require 'unicode'
-      Unicode.normalize_C(text)
+      begin
+        require 'unicode'
+        Unicode.normalize_C(text)
+      rescue LoadError
+        Blacklight.logger.warn "Unable to load unicode library in #export_as_refworks_marc_txt; skipping unicode normalization"
+        text
+      end
     end
   end