blacklight 5.1.1 → 5.2.0

data/lib/blacklight/solr_helper.rb

@@ -48,26 +48,15 @@ module Blacklight::SolrHelper
   extend ActiveSupport::Concern
   include Blacklight::SearchFields
   include Blacklight::Facet
+  include ActiveSupport::Benchmarkable
 
   included do
     if self.respond_to?(:helper_method)
       helper_method(:facet_limit_for)
     end
 
-    # We want to install a class-level place to keep 
-    # solr_search_params_logic method names. Compare to before_filter,
-    # similar design. Since we're a module, we have to add it in here.
-    # There are too many different semantic choices in ruby 'class variables',
-    # we choose this one for now, supplied by Rails. 
-    class_attribute :solr_search_params_logic
-
-    # Set defaults. Each symbol identifies a _method_ that must be in
-    # this class, taking two parameters (solr_parameters, user_parameters)
-    # Can be changed in local apps or by plugins, eg:
-    # 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, :add_group_config_to_solr ]
+    include Blacklight::RequestBuilders
+
   end
 
   def force_to_utf8(value)
@@ -82,10 +71,32 @@ module Blacklight::SolrHelper
     value
   end
   
+  ##
+  # Execute a solr query
+  # @see [RSolr::Client#send_and_receive]
+  # @overload find(solr_path, params)
+  #   Execute a solr query at the given path with the parameters
+  #   @param [String] solr path (defaults to blacklight_config.solr_path)
+  #   @param [Hash] parameters for RSolr::Client#send_and_receive
+  # @overload find(params)
+  #   @param [Hash] parameters for RSolr::Client#send_and_receive
   def find(*args)
-    path = blacklight_config.solr_path
-    response = blacklight_solr.get(path, :params=> args[1])
-    Blacklight::SolrResponse.new(force_to_utf8(response), args[1])
+    # In later versions of Rails, the #benchmark method can do timing
+    # better for us. 
+    benchmark("Solr fetch", level: :debug) do
+      solr_params = args.extract_options!
+      path = args.first || blacklight_config.solr_path
+      solr_params[:qt] ||= blacklight_config.qt
+      # delete these parameters, otherwise rsolr will pass them through.
+      key = blacklight_config.http_method == :post ? :data : :params
+      res = blacklight_solr.send_and_receive(path, {key=>solr_params.to_hash, method:blacklight_config.http_method})
+      
+      solr_response = Blacklight::SolrResponse.new(force_to_utf8(res), solr_params)
+
+      Rails.logger.debug("Solr query: #{solr_params.inspect}")
+      Rails.logger.debug("Solr response: #{solr_response.inspect}") if defined?(::BLACKLIGHT_VERBOSE_LOGGING) and ::BLACKLIGHT_VERBOSE_LOGGING
+      solr_response
+    end
   rescue Errno::ECONNREFUSED => e
     raise Blacklight::Exceptions::ECONNREFUSED.new("Unable to connect to Solr instance using #{blacklight_solr.inspect}")
   end
@@ -105,281 +116,6 @@ module Blacklight::SolrHelper
     return val
   end
     
-
- # returns a params hash for searching solr.
-  # The CatalogController #index action uses this.
-  # Solr parameters can come from a number of places. From lowest
-  # precedence to highest:
-  #  1. General defaults in blacklight config (are trumped by)
-  #  2. defaults for the particular search field identified by  params[:search_field] (are trumped by) 
-  #  3. certain parameters directly on input HTTP query params 
-  #     * not just any parameter is grabbed willy nilly, only certain ones are allowed by HTTP input)
-  #     * for legacy reasons, qt in http query does not over-ride qt in search field definition default. 
-  #  4.  extra parameters passed in as argument.
-  #
-  # spellcheck.q will be supplied with the [:q] value unless specifically
-  # specified otherwise. 
-  #
-  # Incoming parameter :f is mapped to :fq solr parameter.
-  def solr_search_params(user_params = params || {})
-    solr_parameters = Blacklight::Solr::Request.new
-    solr_search_params_logic.each do |method_name|
-      send(method_name, solr_parameters, user_params)
-    end
-
-    return solr_parameters
-  end
-    
-  
-    ####
-    # 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, user_params)
-      blacklight_config.default_solr_params.each do |key, value|
-        solr_parameters[key] = value.dup rescue value
-      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_params)
-
-      # Now any over-rides from current URL?
-      solr_params[:rows] = user_params[:rows].to_i  unless user_params[:rows].blank?
-      solr_params[:rows] = user_params[:per_page].to_i  unless user_params[:per_page].blank?
-
-      # Do we need to translate :page to Solr :start?
-      unless user_params[:page].blank?
-        # already set solr_params["rows"] might not be the one we just set,
-        # could have been from app defaults too. But we need one.
-        # raising is consistent with prior RSolr magic keys behavior.
-        # We could change this to default to 10, or to raise on startup
-        # from config instead of at runtime.
-        if solr_params[:rows].blank?
-          raise Exception.new("To use pagination when no :per_page is supplied in the URL, :rows must be configured in blacklight_config default_solr_params")
-        end
-        solr_params[:start] = solr_params[:rows].to_i * (user_params[:page].to_i - 1)
-        solr_params[:start] = 0 if solr_params[:start].to_i < 0
-      end
-
-      solr_params[:rows] ||= blacklight_config.per_page.first unless blacklight_config.per_page.blank?
-
-      solr_params[:rows] = blacklight_config.max_per_page if solr_params[:rows].to_i > blacklight_config.max_per_page
-    end
-
-    ###
-    # copy sorting params from BL app over to solr
-    def add_sorting_to_solr(solr_parameters, user_params)
-      if user_params[:sort].blank? and sort_field = blacklight_config.default_sort_field
-        # no sort param provided, use default
-        solr_parameters[:sort] = sort_field.sort unless sort_field.sort.blank?
-      elsif sort_field = blacklight_config.sort_fields[user_params[:sort]]
-        # check for sort field key  
-        solr_parameters[:sort] = sort_field.sort unless sort_field.sort.blank?
-      else 
-        # just pass the key through
-        solr_parameters[:sort] = user_params[:sort]
-      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, user_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] = user_parameters[:qt] if user_parameters[:qt]
-      
-      search_field_def = search_field_def_for_key(user_parameters[:search_field])
-      if (search_field_def)     
-        solr_parameters[:qt] = search_field_def.qt
-        solr_parameters.merge!( search_field_def.solr_parameters) if search_field_def.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_def && hash = search_field_def.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}}#{user_parameters[:q]}"
-      else
-        solr_parameters[:q] = user_parameters[:q] if user_parameters[:q]
-      end
-            
-
-      ##
-      # Set Solr spellcheck.q to be original user-entered query, without
-      # our local params, otherwise it'll try and spellcheck the local
-      # params! Unless spellcheck.q has already been set by someone,
-      # respect that.
-      #
-      # TODO: Change calling code to expect this as a symbol instead of
-      # a string, for consistency? :'spellcheck.q' is a symbol. Right now
-      # rspec tests for a string, and can't tell if other code may
-      # insist on a string. 
-      solr_parameters["spellcheck.q"] = user_parameters[:q] unless solr_parameters["spellcheck.q"]
-    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, user_params)   
-
-      # 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 ( user_params[:f])
-        f_request_params = user_params[:f] 
-        
-        f_request_params.each_pair do |facet_field, value_list|
-          Array(value_list).each do |value|
-            solr_parameters.append_filter_query facet_value_to_fq_string(facet_field, value)
-          end              
-        end      
-      end
-    end
-
-    ##
-    # 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),
-             (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))
-             (value.is_a?(DateTime) or value.is_a?(Date) or value.is_a?(Time))
-          "#{prefix}#{facet_field}:#{value}"
-        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
-    
-    ##
-    # 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, user_params)
-      # 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 user_params.has_key?("facet.field") || user_params.has_key?("facets")
-        solr_parameters[:"facet.field"].concat( [user_params["facet.field"], user_params["facets"]].flatten.compact ).uniq!
-      end                
-
-
-      if blacklight_config.add_facet_fields_to_solr_request
-        solr_parameters[:facet] = true
-        solr_parameters.append_facet_fields blacklight_config.facet_fields_to_add_to_solr
-      end
-         
-      blacklight_config.facet_fields.each do |field_name, facet|
-
-        if blacklight_config.add_facet_fields_to_solr_request
-          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]) } 
-   
-            when facet.ex
-              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
-            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
-
-        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 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.show_fields.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.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
-
-    # 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
   # given a user query, return a solr response containing both result docs and facets
   # - mixes in the Blacklight::Solr::SpellingSuggestions module
@@ -405,25 +141,9 @@ module Blacklight::SolrHelper
   # given a user query,
   # Returns a solr response object
   def query_solr(user_params = params || {}, extra_controller_params = {})
-    # In later versions of Rails, the #benchmark method can do timing
-    # better for us. 
-    bench_start = Time.now
     solr_params = self.solr_search_params(user_params).merge(extra_controller_params)
-    solr_params[:qt] ||= blacklight_config.qt
-    path = blacklight_config.solr_path
 
-    # delete these parameters, otherwise rsolr will pass them through.
-    key = blacklight_config.http_method == :post ? :data : :params
-    res = blacklight_solr.send_and_receive(path, {key=>solr_params.to_hash, method:blacklight_config.http_method})
-    
-    solr_response = Blacklight::SolrResponse.new(force_to_utf8(res), solr_params)
-
-    Rails.logger.debug("Solr query: #{solr_params.inspect}")
-    Rails.logger.debug("Solr response: #{solr_response.inspect}") if defined?(::BLACKLIGHT_VERBOSE_LOGGING) and ::BLACKLIGHT_VERBOSE_LOGGING
-    Rails.logger.debug("Solr fetch: #{self.class}#query_solr (#{'%.1f' % ((Time.now.to_f - bench_start.to_f)*1000)}ms)")
-    
-
-    solr_response
+    find(solr_params)
   end
   
   # returns a params hash for finding a single solr document (CatalogController #show action)
@@ -432,11 +152,15 @@ module Blacklight::SolrHelper
   def 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({
-      :id => id # this assumes the document request handler will map the 'id' param to the unique key field
+      # 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] ||= 'document'
+    p[:qt] ||= blacklight_config.document_solr_request_handler
 
     p
   end
@@ -445,7 +169,7 @@ module Blacklight::SolrHelper
   # retrieve a solr document, given the doc id
   def get_solr_response_for_doc_id(id=nil, extra_controller_params={})
     solr_params = solr_doc_params(id).merge(extra_controller_params)
-    solr_response = find((blacklight_config.document_solr_request_handler || blacklight_config.qt), solr_params)
+    solr_response = find(blacklight_config.document_solr_path, solr_params)
     raise Blacklight::Exceptions::InvalidSolrID.new if solr_response.docs.empty?
     document = SolrDocument.new(solr_response.docs.first, solr_response)
     [solr_response, document]
@@ -474,7 +198,7 @@ module Blacklight::SolrHelper
       :spellcheck => 'false'
     }.merge(extra_solr_params)
     
-    solr_response = find(blacklight_config.qt, self.solr_search_params().merge(solr_params) )
+    solr_response = find(self.solr_search_params().merge(solr_params) )
     document_list = solr_response.docs.collect{|doc| SolrDocument.new(doc, solr_response) }
     [solr_response,document_list]
   end
@@ -496,7 +220,6 @@ module Blacklight::SolrHelper
     # Now override with our specific things for fetching facet values
     solr_params[:"facet.field"] = with_ex_local_param((facet_config.ex if facet_config.respond_to?(:ex)), facet_field)
 
-
     limit =  
       if respond_to?(:facet_list_limit)
         facet_list_limit.to_s.to_i
@@ -521,7 +244,7 @@ module Blacklight::SolrHelper
   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)
     # Make the solr call
-    find(blacklight_config.qt, solr_params)
+    find(solr_params)
   end
 
   # a solr query method
@@ -555,7 +278,7 @@ module Blacklight::SolrHelper
     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 = find(blacklight_config.qt, solr_params)
+    solr_response = find(solr_params)
     SolrDocument.new(solr_response.docs.first, solr_response) unless solr_response.docs.empty?
   end
 
@@ -574,7 +297,7 @@ module Blacklight::SolrHelper
 
     solr_params[:fl] = '*'
     solr_params[:facet] = false
-    solr_response = find(blacklight_config.qt, solr_params)
+    solr_response = find(solr_params)
 
     document_list = solr_response.docs.collect{|doc| SolrDocument.new(doc, solr_response) }
 
@@ -603,7 +326,7 @@ module Blacklight::SolrHelper
   # where the field is the "field" argument passed in.
   def get_opensearch_response(field=nil, extra_controller_params={})
     solr_params = solr_opensearch_params().merge(extra_controller_params)
-    response = find(blacklight_config.qt, solr_params)
+    response = find(solr_params)
     a = [solr_params[:q]]
     a << response.docs.map {|doc| doc[solr_params[:fl]].to_s }
   end
@@ -618,14 +341,12 @@ module Blacklight::SolrHelper
   # 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 and @response
-      limit = @response.params["f.#{facet_field}.facet.limit"] || 
-          @response.params["facet.limit"]
+    if facet.limit and @response and @response.facet_by_field_name(facet_field)
+      limit = @response.facet_by_field_name(facet_field).limit
 
-      if limit.blank? # we didn't get or a set a limit, so infer one.
+      if limit.nil? # we didn't get or a set a limit, so infer one.
         facet.limit if facet.limit != true
       elsif limit == -1 # limit -1 is solr-speak for unlimited
         nil
@@ -650,4 +371,10 @@ module Blacklight::SolrHelper
   def blacklight_solr_config
     Blacklight.solr_config
   end
+
+  private
+
+  def should_add_to_solr field_name, field
+    field.include_in_request || (field.include_in_request.nil? && blacklight_config.add_field_configuration_to_solr_request)
+  end
 end

data/lib/blacklight/solr_response/facets.rb

@@ -60,10 +60,14 @@ module Blacklight::SolrResponse::Facets
         values_and_hits.each_slice(2) do |k,v|
           items << FacetItem.new(:value => k, :hits => v)
         end
+        options[:sort] = (params[:"f.#{facet_field_name}.facet.sort"] || params[:'facet.sort'])
+        if params[:"f.#{facet_field_name}.facet.limit"] || params[:"facet.limit"]
+          options[:limit] = (params[:"f.#{facet_field_name}.facet.limit"] || params[:"facet.limit"]).to_i
+        end
 
-        options[:sort] = params[:"f.#{facet_field_name}.facet.sort"] || params['facet.sort']
-        options[:offset] = params[:"f.#{facet_field_name}.facet.offset"].to_i
-
+        if params[:"f.#{facet_field_name}.facet.offset"] || params[:'facet.offset']
+          options[:offset] = (params[:"f.#{facet_field_name}.facet.offset"] || params[:'facet.offset']).to_i
+        end
         FacetField.new(facet_field_name, items, options)
       end
     end

data/lib/blacklight/utils.rb

@@ -1,29 +1,48 @@
 require 'ostruct'
 module Blacklight
+  ##
+  # An OpenStruct that responds to common Hash methods
   class OpenStructWithHashAccess < OpenStruct
-    delegate :keys, :each, :map, :has_key?, :empty?, :delete, :length, :reject!, :select!, :include, :fetch, :to => :to_h
+    delegate :keys, :each, :map, :has_key?, :empty?, :delete, :length, :reject!, :select!, :include, :fetch, :to_json, :as_json, :to => :to_h
 
-    def []=(key, value)
-      send "#{key}=", value
-    end
+    if ::RUBY_VERSION < '2.0'
+      def []=(key, value)
+        send "#{key}=", value
+      end
 
-    def [](key)
-      send key
+      def [](key)
+        send key
+      end
     end
 
+    ##
+    # Expose the internal hash
+    # @return [Hash]
     def to_h
       @table
     end
 
+    ##
+    # Merge the values of this OpenStruct with another OpenStruct or Hash
+    # @param [Hash,#to_h]
+    # @return [OpenStructWithHashAccess] a new instance of an OpenStructWithHashAccess
     def merge other_hash
       self.class.new to_h.merge((other_hash if other_hash.is_a? Hash) || other_hash.to_h)
     end
 
+    ##
+    # Merge the values of another OpenStruct or Hash into this object
+    # @param [Hash,#to_h]
+    # @return [OpenStructWithHashAccess] a new instance of an OpenStructWithHashAccess
     def merge! other_hash
       @table.merge!((other_hash if other_hash.is_a? Hash) || other_hash.to_h)
     end 
   end
 
+
+  ##
+  # An OpenStruct refinement that converts any hash-keys into  
+  # additional instances of NestedOpenStructWithHashAccess
   class NestedOpenStructWithHashAccess < OpenStructWithHashAccess
     attr_reader :nested_class
     delegate :default_proc=, :to => :to_h
@@ -54,18 +73,28 @@ module Blacklight
       set_default_proc!
     end
 
+    ##
+    # Add an new key to the object, with a default default
     def << key
       @table[key]
     end
 
+    ##
+    # Add a new key/value to the object; if it's a Hash, turn it
+    # into another NestedOpenStructWithHashAccess
     def []=(key, value)
       if value.is_a? Hash
         send "#{key}=", nested_class.new(value)
-      else
+      elsif ::RUBY_VERSION < '2.0'
         send "#{key}=", value
+      else
+        super
       end
     end
 
+    ##
+    # Before serializing, we need to reset the default proc
+    # so it can be serialized appropriately
     def marshal_dump
       h = to_h.dup
       h.default = nil
@@ -73,6 +102,9 @@ module Blacklight
       [nested_class, h]
     end
 
+    ##
+    # After deserializing, we need to re-add the default proc
+    # to the internal hash
     def marshal_load x
       @nested_class = x.first
       super x.last

data/lib/blacklight.rb

@@ -10,14 +10,16 @@ module Blacklight
   autoload :Solr, 'blacklight/solr'
   
   autoload :SolrHelper, 'blacklight/solr_helper'
+  autoload :RequestBuilders, 'blacklight/request_builders'
   
   autoload :Exceptions, 'blacklight/exceptions'
 
   autoload :User, 'blacklight/user'
 
-  autoload :Controller, 'blacklight/controller'
-  autoload :Base, 'blacklight/base'
-  autoload :Catalog,    'blacklight/catalog'
+  autoload :Controller,        'blacklight/controller'
+  autoload :Base,              'blacklight/base'
+  autoload :Catalog,           'blacklight/catalog'
+  autoload :DocumentPresenter, 'blacklight/document_presenter'
 
   autoload :Routes, 'blacklight/routes'
 

data/lib/generators/blacklight/install_generator.rb

@@ -3,9 +3,10 @@ module Blacklight
     
     source_root File.expand_path('../templates', __FILE__)
     
-    argument     :model_name, :type => :string , :default => "user"
-    class_option :devise    , :type => :boolean, :default => false, :aliases => "-d", :desc => "Use Devise as authentication logic."
-    class_option :marc      , :type => :boolean, :default => false, :aliases => "-m", :desc => "Generate MARC-based demo ."
+    argument     :model_name  , type: :string , default: "user"
+    class_option :devise      , type: :boolean, default: false, aliases: "-d", desc: "Use Devise as authentication logic."
+    class_option :jettywrapper, type: :boolean, default: false, desc: "Use jettywrapper to download and control Jetty"
+    class_option :marc        , type: :boolean, default: false, aliases: "-m", desc: "Generate MARC-based demo ."
 
     desc """
   This generator makes the following changes to your application:
@@ -17,7 +18,18 @@ module Blacklight
 
 
   Thank you for Installing Blacklight.
-         """ 
+         """
+
+    def install_jettywrapper
+      return unless options[:jettywrapper]
+      gem "jettywrapper", "~> 1.7"
+
+      copy_file "config/jetty.yml"
+
+      append_to_file "Rakefile",
+        "\nZIP_URL = \"https://github.com/projectblacklight/blacklight-jetty/archive/v4.6.0.zip\"\n" +
+        "require 'jettywrapper'\n"
+    end
 
     def bundle_install
       Bundler.with_clean_env do
@@ -93,4 +105,4 @@ EOF
       copy_file "blacklight.en.yml", "config/locales/blacklight.en.yml"
     end
   end
-end
+end

data/lib/generators/blacklight/models_generator.rb

@@ -57,7 +57,6 @@ This generator makes the following changes to your application:
     # Copy all files in templates/config directory to host config
     def create_configuration_files
       copy_file "config/solr.yml", "config/solr.yml"
-      copy_file "config/jetty.yml", "config/jetty.yml"
     end
 
 

data/lib/generators/blacklight/templates/catalog_controller.rb

@@ -10,6 +10,12 @@ class CatalogController < ApplicationController
       :qt => 'search',
       :rows => 10 
     }
+    
+    # solr path which will be added to solr base url before the other solr params.
+    #config.solr_path = 'select' 
+    
+    # items to show per page, each number in the array represent another option to choose from.
+    #config.per_page = [10,20,50,100]
 
     ## Default parameters to send on single-document requests to Solr. These settings are the Blackligt defaults (see SolrHelper#solr_doc_params) or 
     ## parameters included in the Blacklight-jetty document requestHandler.