blacklight 5.0.3 → 5.1.0

data/gemfiles/rails4.gemfile

@@ -1,10 +1,22 @@
 source 'http://rubygems.org'
 
-file = File.expand_path("../../Gemfile", __FILE__)
+# Please see blacklight.gemspec for dependency information.
+gemspec :path=>"../"
 
-if File.exists?(file)
-  puts "Loading #{file} ..." if $DEBUG # `ruby -d` or `bundle -v`
-  instance_eval File.read(file)
+gem 'rails', '~> 4.0.0'
+
+gem 'activerecord-jdbcsqlite3-adapter', :platform => :jruby
+
+group :test do
+  gem 'simplecov', require: false
+  gem 'coveralls', require: false
+  gem 'devise'
+  gem 'devise-guests'
+  gem "bootstrap-sass"
+  gem 'turbolinks'
 end
 
-gem 'rails', '4.0.3'
+f = File.expand_path(File.dirname(__FILE__) + '/../spec/test_app_templates/Gemfile.extra')
+if File.exists?(f)
+  eval File.read(f), nil, f
+end

data/lib/blacklight/catalog.rb

@@ -27,11 +27,11 @@ module Blacklight::Catalog
         format.html { }
         format.rss  { render :layout => false }
         format.atom { render :layout => false }
-
-        
         format.json do
           render json: render_search_results_as_json
         end
+
+        additional_response_formats(format)
       end
     end
     
@@ -63,7 +63,13 @@ module Blacklight::Catalog
     
     # displays values and pagination links for a single facet field
     def facet
-      @pagination = get_facet_pagination(params[:id], params)
+      @facet = blacklight_config.facet_fields[params[:id]]
+      @response = get_facet_field_response(@facet.field, params)
+      @display_facet = @response.facets.first
+
+      # @pagination was deprecated in Blacklight 5.1
+      @pagination = facet_paginator(@facet, @display_facet)
+
 
       respond_to do |format|
         # Draw the facet selector for users who have javascript disabled:
@@ -149,6 +155,25 @@ module Blacklight::Catalog
     # non-routable methods ->
     #
 
+    def additional_response_formats format
+      blacklight_config.index.respond_to.each do |key, config|
+        format.send key do
+          case config
+          when false
+            raise ActionController::RoutingError.new('Not Found')
+          when Hash
+            render config
+          when Proc
+            instance_exec &config
+          when Symbol, String
+            send config
+          else
+            # no-op, just render the page
+          end
+        end
+      end
+    end
+
     # override this method to change the JSON response from #index 
     def render_search_results_as_json
       {response: {docs: @document_list, facets: search_facets_as_json, pages: pagination_info(@response)}}
@@ -156,6 +181,7 @@ module Blacklight::Catalog
 
     def search_facets_as_json
       facets_from_request.as_json.each do |f|
+        f.delete "options"
         f["label"] = facet_configuration_for_field(f["name"]).label
         f["items"] = f["items"].as_json.each do |i|
           i['label'] ||= i['value']
@@ -172,7 +198,7 @@ module Blacklight::Catalog
     # By default, any search action from a Blacklight::Catalog controller
     # should use the current controller when constructing the route.
     def search_action_url options = {}
-      url_for(options.merge(:action => 'index', :only_path => true))
+      url_for(options.merge(:action => 'index'))
     end
 
     # extract the pagination info from the response object
@@ -225,12 +251,31 @@ module Blacklight::Catalog
       flash[:error].blank?
     end
 
-    # when a request for /catalog/BAD_SOLR_ID is made, this method is executed...
-    def invalid_solr_id_error
-      flash[:notice] = I18n.t('blacklight.search.errors.invalid_solr_id')
-      params.delete(:id)
-      index
-      render "index", :status => 404
+    # when a request for /catalog/BAD_SOLR_ID is made, this method is executed.
+    # Just returns a 404 response, but you can override locally in your own
+    # CatalogController to do something else -- older BL displayed a Catalog#inde
+    # page with a flash message and a 404 status.
+    def invalid_solr_id_error(exception)
+      error_info = {
+        "status" => "404",
+        "error"  => "#{exception.class}: #{exception.message}"
+      }
+
+      respond_to do |format|
+        format.xml  { render :xml  => error_info, :status => 404 }
+        format.json { render :json => error_info, :status => 404 }
+
+        # default to HTML response, even for other non-HTML formats we don't
+        # neccesarily know about, seems to be consistent with what Rails4 does
+        # by default with uncaught ActiveRecord::RecordNotFound in production
+        format.any do
+          # use standard, possibly locally overridden, 404.html file. Even for
+          # possibly non-html formats, this is consistent with what Rails does
+          # on raising an ActiveRecord::RecordNotFound. Rails.root IS needed
+          # for it to work under testing, without worrying about CWD.
+          render :file => "#{Rails.root}/public/404.html", :status => 404, :layout => false, :content_type => 'text/html'
+        end
+      end
     end
 
     def start_new_search_session?

data/lib/blacklight/configuration.rb

@@ -20,7 +20,12 @@ module Blacklight
           :document_solr_request_handler => nil,
           :default_document_solr_params => {},
           :show => ViewConfig::Show.new(:partials => [:show_header, :show]),
-          :index => ViewConfig::Index.new(:partials => [:index_header, :thumbnail, :index], :title_field => unique_key, :display_type_field => 'format', :group => false),
+          :index => ViewConfig::Index.new(:partials => [:index_header, :thumbnail, :index],
+            :title_field => unique_key,
+            :display_type_field => 'format',
+            :group => false,
+            :respond_to => OpenStructWithHashAccess.new()
+            ),
           :view => NestedOpenStructWithHashAccess.new(ViewConfig, 'list'),
           :spell_max => 5,
           :max_per_page => 100,

data/lib/blacklight/configuration/fields.rb

@@ -74,12 +74,30 @@ module Blacklight
             args[0] = args[0].to_s
             field_config_from_key_and_hash(config_key, *args)
           when Array
-            field_config_from_array(config_key, *args)
+            field_config_from_array(config_key, *args, &block)
+            return # we've iterated over the array above.
           else
             field_config_from_field_or_hash(config_key, *args)
         end
 
-        return if field_config.is_a? Array
+        # look up any dynamic fields
+        if field_config.field.to_s =~ /\*/ and luke_fields
+          salient_fields = luke_fields.select do |k,v| 
+            k =~ Regexp.new("^" + field_config.field.to_s.gsub('*', '.+') + "$")
+          end
+
+          salient_fields.each do |field, luke_config|
+            config = field_config.dup
+            config.field = field
+            if self[config_key.pluralize][ config.field ]
+              self[config_key.pluralize][ config.field ] = config.merge(self[config_key.pluralize][ config.field ])
+            else
+              add_solr_field(config_key, config, &block)
+            end
+          end
+
+          return
+        end
   
         if block_given?
           yield field_config
@@ -94,6 +112,22 @@ module Blacklight
       end
 
       protected
+      def luke_fields
+        if @table[:luke_fields] === false
+          return nil
+        end
+
+        @table[:luke_fields] ||= begin
+          if has_key? :blacklight_solr
+            blacklight_solr.get('admin/luke', params: { fl: '*', 'json.nl' => 'map' })['fields']
+          end
+        rescue
+          false
+        end
+
+        @table[:luke_fields] || nil
+      end
+
       # Add a solr field by a solr field name and hash 
       def field_config_from_key_and_hash config_key, solr_field, field_or_hash = {}
         field_config = field_config_from_field_or_hash(config_key, field_or_hash)
@@ -103,9 +137,9 @@ module Blacklight
       end
 
       # Add multiple solr fields using a hash or Field instance
-      def field_config_from_array config_key, array_of_fields_or_hashes
+      def field_config_from_array config_key, array_of_fields_or_hashes, &block
         array_of_fields_or_hashes.map do |field_or_hash| 
-          add_solr_field(config_key, field_or_hash)
+          add_solr_field(config_key, field_or_hash, &block)
         end
       end
 

data/lib/blacklight/controller.rb

@@ -23,7 +23,7 @@ module Blacklight::Controller
     # extra head content
     helper_method :has_user_authentication_provider?
     helper_method :blacklight_config
-    helper_method :search_action_url
+    helper_method :search_action_url, :search_action_path
 
 
     # This callback runs when a user first logs in
@@ -50,6 +50,15 @@ module Blacklight::Controller
       catalog_index_url *args
     end
 
+    def search_action_path *args
+
+      if args.first.is_a? Hash
+        args.first[:only_path] = true
+      end
+
+      search_action_url *args
+    end
+
     # Returns a list of Searches from the ids in the user's history.
     def searches_from_history
       session[:history].blank? ? Search.none : Search.where(:id => session[:history]).order("updated_at desc")

data/lib/blacklight/facet.rb

@@ -3,6 +3,14 @@
 #
 module Blacklight
   module Facet
+
+    def facet_paginator field_config, display_facet
+      Blacklight::Solr::FacetPaginator.new(display_facet.items, 
+        sort: display_facet.sort,
+        offset: display_facet.offset,     
+        limit: facet_limit_for(field_config.field))
+    end
+
     def facets_from_request(fields = facet_field_names)
       fields.map { |solr_field| facet_by_field_name(solr_field) }.compact
     end

data/lib/blacklight/solr_helper.rb

@@ -322,6 +322,13 @@ module Blacklight::SolrHelper
           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'
@@ -341,11 +348,26 @@ module Blacklight::SolrHelper
 
     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
 
@@ -465,13 +487,14 @@ module Blacklight::SolrHelper
   # method facet_list_limit, otherwise 20. 
   def solr_facet_params(facet_field, user_params=params || {}, extra_controller_params={})
     input = user_params.deep_merge(extra_controller_params)
+    facet_config = blacklight_config.facet_fields[facet_field]
 
     # First start with a standard solr search params calculations,
     # for any search context in our request params. 
     solr_params = solr_search_params(user_params).merge(extra_controller_params)
     
     # Now override with our specific things for fetching facet values
-    solr_params[:"facet.field"] = facet_field
+    solr_params[:"facet.field"] = with_ex_local_param((facet_config.ex if facet_config.respond_to?(:ex)), facet_field)
 
 
     limit =  
@@ -493,26 +516,31 @@ module Blacklight::SolrHelper
     return solr_params
   end
   
+  ##
+  # Get the solr response when retrieving only a single facet field
+  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)
+  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={})
-    
-    solr_params = solr_facet_params(facet_field, user_params, extra_controller_params)
-    
     # Make the solr call
-    response =find(blacklight_config.qt, solr_params)
+    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
 
-    limit = solr_params[:"f.#{facet_field}.facet.limit"] -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 => solr_params[:"f.#{facet_field}.facet.offset"], 
+      :offset => response.params[:"f.#{facet_field}.facet.offset"], 
       :limit => limit,
-      :sort => response["responseHeader"]["params"][:"f.#{facet_field}.facet.sort"] || response["responseHeader"]["params"]["facet.sort"]
+      :sort => response.params[:"f.#{facet_field}.facet.sort"] || response.params["facet.sort"]
     )
   end
   
@@ -590,23 +618,23 @@ module Blacklight::SolrHelper
   # a facet paginator with the right limit. 
   def facet_limit_for(facet_field)
     facet = blacklight_config.facet_fields[facet_field]
-    return nil if facet.blank?
-        
-    limit = facet.limit
-
-    if ( limit == true && @response && 
-         @response["responseHeader"] && 
-         @response["responseHeader"]["params"])
-     limit =
-       @response["responseHeader"]["params"]["f.#{facet_field}.facet.limit"] || 
-       @response["responseHeader"]["params"]["facet.limit"]
-       limit = (limit.to_i() -1) if limit
-       limit = nil if limit == -2 # -1-1==-2, unlimited. 
-    elsif limit == true
-      limit = nil
-    end
 
-    return limit
+    return if facet.blank?
+
+    if facet.limit and @response
+      limit = @response.params["f.#{facet_field}.facet.limit"] || 
+          @response.params["facet.limit"]
+
+      if limit.blank? # 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
+      else
+        limit.to_i - 1 # we added 1 to find out if we needed to paginate
+      end
+    elsif (facet.limit and facet.limit != true)
+      facet.limit
+    end
   end
 
   ##

data/lib/blacklight/solr_response/facets.rb

@@ -29,8 +29,21 @@ module Blacklight::SolrResponse::Facets
   # represents a facet; which is a field and its values
   class FacetField
     attr_reader :name, :items
-    def initialize name, items
+    def initialize name, items, options = {}
       @name, @items = name, items
+      @options = options
+    end
+
+    def limit
+      @options[:limit]
+    end
+
+    def sort
+      @options[:sort] || 'index'
+    end
+
+    def offset
+      @options[:offset] || 0
     end
   end
   
@@ -40,15 +53,20 @@ module Blacklight::SolrResponse::Facets
   # end
   # "caches" the result in the @facets instance var
   def facets
-    @facets ||= (
+    @facets ||= begin
       facet_fields.map do |(facet_field_name,values_and_hits)|
         items = []
+        options = {}
         values_and_hits.each_slice(2) do |k,v|
           items << FacetItem.new(:value => k, :hits => v)
         end
-        FacetField.new(facet_field_name, items)
+
+        options[:sort] = params[:"f.#{facet_field_name}.facet.sort"] || params['facet.sort']
+        options[:offset] = params[:"f.#{facet_field_name}.facet.offset"].to_i
+
+        FacetField.new(facet_field_name, items, options)
       end
-    )
+    end
   end
   
   # pass in a facet field name and get back a Facet instance

data/spec/controllers/catalog_controller_spec.rb

@@ -155,6 +155,49 @@ describe CatalogController do
       end
     end
 
+    describe "with additional formats from configuration" do
+      let(:blacklight_config) { Blacklight::Configuration.new }
+
+      before :each do
+        @controller.stub blacklight_config: blacklight_config
+        @controller.stub get_search_results: [double, double]
+      end
+
+      it "should not render when the config is false" do
+        blacklight_config.index.respond_to.yaml = false
+        expect { get :index, format: 'yaml' }.to raise_error ActionController::RoutingError
+      end
+
+      it "should render the default when the config is true" do
+        # TODO: this should really stub a template and see if it gets rendered,
+        # but how to do that is non-obvious..
+        blacklight_config.index.respond_to.yaml = true
+        expect { get :index, format: 'yaml' }.to raise_error ActionView::MissingTemplate
+      end
+
+      it "should pass a hash to the render call" do
+        blacklight_config.index.respond_to.yaml = { nothing: true, layout: false }
+        get :index, format: 'yaml'
+        expect(response.body).to be_blank
+      end
+
+      it "should evaluate a proc" do
+        blacklight_config.index.respond_to.yaml = lambda { render text: "" }
+        get :index, format: 'yaml'
+        expect(response.body).to be_empty
+      end
+
+      it "with a symbol, it should call a controller method" do
+        subject.should_receive(:render_some_yaml) do
+          subject.render nothing: true, layout: false
+        end
+
+        blacklight_config.index.respond_to.yaml = :render_some_yaml
+        get :index, format: 'yaml'
+        expect(response.body).to be_blank
+      end
+    end
+
   end # describe index action
 
   describe "update action" do
@@ -421,10 +464,21 @@ describe CatalogController do
         controller.stub(:find => @mock_response, 
                         :get_single_doc_via_search => @mock_document)
       get :show, :id=>"987654321"
-      expect(request.flash[:notice]).to eq "Sorry, you have requested a record that doesn't exist."
-      expect(response).to render_template('index')
       expect(response.status).to eq 404
+      expect(response.content_type).to eq Mime::HTML
     end
+    it "should return status 404 for a record that doesn't exist even for non-html format" do
+      @mock_response = double()
+      @mock_response.stub(:docs => [])
+      @mock_document = double()
+      controller.stub(:find => @mock_response,
+                      :get_single_doc_via_search => @mock_document)
+
+      get :show, :id=>"987654321", :format => "xml"
+      expect(response.status).to eq 404
+      expect(response.content_type).to eq Mime::XML
+    end
+
     it "should redirect the user to the root url for a bad search" do
       req = {}
       res = {}
@@ -483,6 +537,9 @@ describe CatalogController do
       it "should be successful" do
         get :facet, id: 'format'
         expect(response).to be_successful
+        expect(assigns[:response]).to be_kind_of Blacklight::SolrResponse
+        expect(assigns[:facet]).to be_kind_of Blacklight::Configuration::FacetField
+        expect(assigns[:display_facet]).to be_kind_of Blacklight::SolrResponse::Facets::FacetField
         expect(assigns[:pagination]).to be_kind_of Blacklight::Solr::FacetPaginator
       end
     end