blacklight 5.9.4 → 5.10.0

data/lib/blacklight/solr.rb

@@ -5,5 +5,6 @@ module Blacklight::Solr
   autoload :FacetPaginator, 'blacklight/solr/facet_paginator'
   autoload :Document, 'blacklight/solr/document'
   autoload :Request, 'blacklight/solr/request'
+  autoload :SearchBuilder, 'blacklight/solr/search_builder'
   
 end

data/lib/blacklight/solr/document.rb

@@ -25,201 +25,18 @@ module Blacklight::Solr::Document
   autoload :MoreLikeThis, 'blacklight/solr/document/more_like_this'
 
   extend ActiveSupport::Concern
-  include Blacklight::Solr::Document::SchemaOrg
-  include Blacklight::Solr::Document::Export
+  include Blacklight::Document
   include Blacklight::Solr::Document::MoreLikeThis
 
-  included do
-    extend ActiveModel::Naming
-    include Blacklight::Solr::Document::Extensions
-  end    
-
-  attr_reader :solr_response, :_source
-
-  def initialize(source_doc={}, solr_response=nil)
-    @_source = source_doc.with_indifferent_access
-    @solr_response = solr_response
-    apply_extensions
-  end
-
-  def to_model
-    self
-  end
-
-  def persisted?
-    true
-  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)
-    if _source_responds_to?(m)
-     _source.send(m, *args, &b)
-   else
-     super
-   end
-  end
-  
-  def respond_to_missing? *args
-    _source_responds_to?(*args) || super
-  end
-
-  def [] *args
-    _source.send :[], *args
-  end
-
-  def _read_attribute(attr)
-    self[attr]
-  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 true if key?(k) and values.empty?
-    return false if self[k].nil?
-    target = self[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 key? k
-    _source.key? k
-  end
-  alias_method :has_key?, :key?
-
   def has_highlight_field? k
-    return false if @solr_response['highlighting'].blank? or @solr_response['highlighting'][self.id].blank?
+    return false if response['highlighting'].blank? or response['highlighting'][self.id].blank?
     
-    @solr_response['highlighting'][self.id].key? k.to_s
+    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 key? key
-      val = self[key]
-      (val.is_a?(Array) and opts[:sep]) ? val.join(opts[:sep]) : val
-    else
-      opts[:default]
-    end
-  end
-
-  def first key
-    Array(self[key]).first
-  end
-
-  def id
-    self[self.class.unique_key]
-  end
-
-  def to_param
-    id.to_s
-  end
-
-  def as_json(options = nil)
-    _source.as_json(options)
-  end
-
-  def to_partial_path
-    'catalog/document'
-  end
-
-   
-  # Returns a hash keyed by semantic tokens (see ExtendableClassMethods#semantic_fields), value is an array of
-  # strings. (Array to handle multi-value fields). If no value(s)
-  # available, empty array is returned. 
-  #
-  # Default implementation here uses ExtendableClassMethods#semantic_fields
-  # to just take values from Solr stored fields. 
-  # Extensions can over-ride this method to provide better/different lookup,
-  # but extensions should call super and modify hash returned, to avoid
-  # unintentionally erasing values provided by other extensions. 
-  def to_semantic_values
-    unless @semantic_value_hash
-      @semantic_value_hash = Hash.new([]) # default to empty array   
-      self.class.field_semantics.each_pair do |key, solr_field|
-        value = self[solr_field]
-        # Make single and multi-values all arrays, so clients
-        # don't have to know.
-        unless value.nil?
-          value = [value] unless value.kind_of?(Array)      
-          @semantic_value_hash[key] = value
-        end
-      end
-    end
-    return @semantic_value_hash
-  end
-  
-  def destroyed?
-    false
-  end
-  
-  def new_record?
-    false
-  end
-
-  # Certain class-level methods needed for the document-specific
-  # extendability architecture
-  module ClassMethods
-
-    attr_writer :unique_key
-    def unique_key
-      @unique_key ||= 'id' 
-    end
-
-    def primary_key
-      unique_key
-    end
-    
-    def base_class
-      self
-    end
-
-    # Returns array of hashes of registered extensions. Each hash
-    # has a :module_obj key and a :condition_proc key. Usually this
-    # method is only used internally in #apply_extensions, but if you
- 
-    # Class-level method for accessing/setting semantic mappings
-    # for solr stored fields. Can be set by local app, key is
-    # a symbol for a semantic, value is a solr _stored_ field.
-    #
-    # Stored field can be single or multi-value. In some cases
-    # clients may only use the first value from a multi-value field.
-    #
-    # Currently documented semantic tokens, not all may be
-    # used by core BL, but some may be used by plugins present
-    # or future. 
-    # :title, :author, :year, :language => User-presentable strings. 
-    def field_semantics
-      @field_semantics ||= {}
-    end    
-  end
-  private
-    
-  def _source_responds_to? *args
-    _source && self != _source && _source.respond_to?(*args)
+    response['highlighting'][self.id][k.to_s].map { |x| x.html_safe }
   end
 
 end

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

@@ -1,41 +1,7 @@
-# -*- encoding : utf-8 -*-
-require 'builder'
-
-# This module provide Dublin Core export based on the document's semantic values
 module Blacklight::Solr::Document::DublinCore
-  def self.extended(document)
-    # Register our exportable formats
-    Blacklight::Solr::Document::DublinCore.register_export_formats( document )
-  end
-
-  def self.register_export_formats(document)
-    document.will_export_as(:xml)
-    document.will_export_as(:dc_xml, "text/xml")
-    document.will_export_as(:oai_dc_xml, "text/xml")
-  end
+  include Blacklight::Document::DublinCore
 
-  def dublin_core_field_names
-    [:contributor, :coverage, :creator, :date, :description, :format, :identifier, :language, :publisher, :relation, :rights, :source, :subject, :title, :type]
-  end
-
-  # dublin core elements are mapped against the #dublin_core_field_names whitelist.
-  def export_as_oai_dc_xml
-    xml = Builder::XmlMarkup.new
-    xml.tag!("oai_dc:dc",
-             'xmlns:oai_dc' => "http://www.openarchives.org/OAI/2.0/oai_dc/",
-             'xmlns:dc' => "http://purl.org/dc/elements/1.1/",
-             'xmlns:xsi' => "http://www.w3.org/2001/XMLSchema-instance",
-             'xsi:schemaLocation' => %{http://www.openarchives.org/OAI/2.0/oai_dc/ http://www.openarchives.org/OAI/2.0/oai_dc.xsd}) do
-       self.to_semantic_values.select { |field, values| dublin_core_field_names.include? field.to_sym }.each do |field,values|
-         values.each do |v|
-           xml.tag! 'dc:' + field.to_s, v
-         end
-       end
-     end
-    xml.target!
+  def self.extended(document)
+    Deprecation.warn Blacklight::Solr::Document::DublinCore, "Blacklight::Solr::Document::DublinCore is deprecated; use Blacklight::Document::DublinCore instead."
   end
-
-  alias_method :export_as_xml, :export_as_oai_dc_xml
-  alias_method :export_as_dc_xml, :export_as_oai_dc_xml
-
 end

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

@@ -1,16 +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::Email
-
-  # Return a text string that will be the body of the email
-  def to_email_text
-    semantics = self.to_semantic_values
-    body = []
-    body << I18n.t('blacklight.email.text.title', :value => semantics[:title].join(" ")) unless semantics[:title].blank?
-    body << I18n.t('blacklight.email.text.author', :value => semantics[:author].join(" ")) unless semantics[:author].blank?
-    body << I18n.t('blacklight.email.text.format', :value => semantics[:format].join(" ")) unless semantics[:format].blank?
-    body << I18n.t('blacklight.email.text.language', :value => semantics[:language].join(" ")) unless semantics[:language].blank?
-    return body.join("\n") unless body.empty?
+  include Blacklight::Document::Email
+  
+  def self.extended(document)
+    Deprecation.warn Blacklight::Solr::Document::Email, "Blacklight::Solr::Document::Email is deprecated; use Blacklight::Document::Email instead."
   end
-
 end

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

@@ -1,107 +1,7 @@
-# == Transformation conventions
-# The main use case for extensions is for transforming a Document to another
-# format. Either to another type of Ruby object, or to an exportable string in
-# a certain format. 
-#
-# The convention for methods contained in extensions that transform to a ruby
-# object is "to_*".  For instance, "to_marc" would return a Ruby Marc object.
-#
-# The convention for methods contained in extensions that transform to an
-# exportable file of some kind is "export_as_*".  For instance,
-# "export_as_marc21" would return a String object containing valid marc21, and
-# "export_as_marcxml" would return a String object containing valid marcxml.
-#
-# The tokens used after "export_as" should normally be the format names as
-# registered with Rails Mime::Type.
-#
-# == Advertising export formats
-#
-# If an extension advertises what export formats it can provide, than those
-# formats will automatically be delivered by the Blacklight catalog/show
-# controller, and potentially automatically advertised in various places
-# that advertise available formats. (HTML link rel=alternate; Atom 
-# link rel=alterate; etc).
-#
-# Export formats are 'registered' by calling the #will_export_as method
-# on a Document instance. An extension would usually do this in a
-# self.extended method, so it can be called on Documents that have
-# the given extension added to them. For instance:
-#
-#   module DemoMarcExtension
-#     def self.extended(document)
-#       document.will_export_as(:marc21, "application/marc")
-#       document.will_export_as(:marcxml, "application/marcxml+xml")
-#     end
-#
-#     def export_as_marc21 ; something ; end
-#     def export_as_marcxml ; something ; end
-#   end
-#
 module Blacklight::Solr::Document::Export
-
-  ##  
-  # Register exportable formats supported by the individual document.
-  # Usually called by an extension in it's self.extended method, to
-  # register the formats that extension can export. 
-  # 
-  # some_document.will_export_as(:some_format, "application/type") means
-  # that the document (usually via an extension) has a method
-  # "export_as_some_format" which returns a String of content that
-  # is described by the mime content_type given. 
-  # 
-  # The format name should ideally _already_ be registered with
-  # Rails Mime::Type, in your application initializer, representing
-  # the content type given.  However, this method will attempt to
-  # register it using Mime::Type.register_alias if it's not previously
-  # registered. This is a bit sketchy though. 
-  def will_export_as(short_name, content_type = nil)
-    #Lookup in Rails Mime::Type, register if needed, otherwise take
-    # content-type from registration if needed. This uses
-    # some 'api' to Mime::Type that may or may not be entirely
-    # public, the fact that a Mime::CONST is registered for every
-    # type. But that's the only way to do the kind of check we need, sorry.
-    if defined?(Mime) && Mime.const_defined?(short_name.to_s.upcase)      
-      mime_type = "Mime::#{short_name.to_s.upcase}".constantize
-      content_type = mime_type.to_s unless content_type      
-    else
-      # not registered, we need to register. Use register_alias to be least
-      # likely to interfere with host app. 
-      Mime::Type.register_alias(content_type, short_name)
-    end
-    
-    # if content_type is nil, look it up from Rails Mime::Type
-    if content_type.nil?
-      # Accurate lookup in Rails Mime::Type is kind of pain, it doesn't
-      # really provide the right API.
-      if defined?(type_const_name)
-        content_type = type_const_name.constantize.to_s
-      end    
-    end    
-    export_formats[short_name] =  {:content_type => content_type}
-  end
-  
-  # Collects formats that this doc can export as.
-  # Returns a hash, keys are format short-names that can
-  # be exported. Hash includes:
-  #  :content-type => mime-content-type
-  #  maybe more later
-  # To see if a given export format is supported by this document,
-  # simply call document.export_formats.keys.include?(:my_format)
-  # Then call #export_as! to do the export. 
-  def export_formats
-    @export_formats ||= {}
-  end
-  
-  # Call with a format shortname, export_as(:marc), simply returns
-  # #export_as_marc . Later we may expand the design to allow you
-  # to register an arbitrary method name instead of insisting
-  # on the convention, so clients should call this method so
-  # they'll still keep working if we do that. 
-  def export_as(short_name)
-    send("export_as_#{short_name.to_s}")
-  end
+  include Blacklight::Document::Export
   
-  def exports_as? short_name
-    respond_to? "export_as_#{short_name.to_s}"
+  def self.extended(document)
+    Deprecation.warn Blacklight::Solr::Document::Export, "Blacklight::Solr::Document::Export is deprecated; use Blacklight::Document::Export instead."
   end
 end

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

@@ -1,56 +1,8 @@
-# = Document Extensions
-# An Blacklight::Solr::Document extension is simply a ruby module which is mixed
-# in to individual Document instances.  The intended use case is for documents
-# containing some particular format of source material, such as Marc. An
-# extension can be registered with your document class, along with a block
-# containing custom logic for which documents to apply the extension to.
-#
-# SolrDocument.use_extension(MyExtension) {|document| my_logic_on_document(document}
-#
-# MyExtension will be mixed-in (using ruby 'extend') only to those documents
-# where the block results in true.
-#
-# == Extension Parameters
-# Every class that includes Blacklight::Solr::Document::Extensions gets a
-# #extension_parameters method for saving arbitrary parameters on class-wide
-# level that can be retrieved by extensions. These are arbitrary, just
-# conventions with a given extension. For instance:
-# SolrDocument.extension_parameters[:marc_source_field] = "solr_stored_field_name"
-#
 module Blacklight::Solr::Document::Extensions
   extend ActiveSupport::Concern
-
-  # Needs to be called in initializer of class including this module, to
-  # apply all registered extensions on a per-document basis
-  def apply_extensions
-    self.class.registered_extensions.each do | registration|
-      self.extend( registration[:module_obj] ) if registration[:condition_proc].nil? || registration[:condition_proc].call( self )
-    end
-  end
-
-  module ClassMethods
-    attr_writer :registered_extensions
-
-    # want to zero out all previously registered extensions you can call:
-    # SolrDocument.registered_extensions = nil
-    def registered_extensions
-      @registered_extensions ||= []
-    end
-
-    def extension_parameters
-      @extension_parameters ||= {}
-    end
-
-    # Register an extension module with the class. A block taking one
-    # parameter can be supplied; the block will be passed an instance of 
-    # a Document, and the extension will be applied only if the block
-    # evaluates as true. If no condition is given, the extension will
-    # be applied to every instance of the class.
-    #
-    # SolrDocument.use_extension( SomeExtensionModule ) { | document | should_apply_some_extension?(document) }
-    # SolrDocument.use_extension( SomeExtensionModule) # will be applied to all docs
-    def use_extension( module_obj, &condition )
-      registered_extensions << {:module_obj => module_obj, :condition_proc => condition}    
-    end
+  include Blacklight::Document::Extensions
+  
+  def self.extended(document)
+    Deprecation.warn Blacklight::Solr::Document::Extensions, "Blacklight::Solr::Document::Extensions is deprecated; use Blacklight::Document::Extensions instead."
   end
 end