blacklight 5.11.3 → 5.12.0

data/lib/blacklight/solr_repository.rb

@@ -43,7 +43,7 @@ module Blacklight
         key = blacklight_config.http_method == :post ? :data : :params
         res = connection.send_and_receive(path, {key=>solr_params.to_hash, method:blacklight_config.http_method})
 
-        solr_response = blacklight_config.response_model.new(res, solr_params, document_model: blacklight_config.document_model)
+        solr_response = blacklight_config.response_model.new(res, solr_params, document_model: blacklight_config.document_model, blacklight_config: blacklight_config)
 
         Blacklight.logger.debug("Solr query: #{solr_params.inspect}")
         Blacklight.logger.debug("Solr response: #{solr_response.inspect}") if defined?(::BLACKLIGHT_VERBOSE_LOGGING) and ::BLACKLIGHT_VERBOSE_LOGGING

data/lib/blacklight/solr_response.rb

@@ -1,4 +1,5 @@
 class Blacklight::SolrResponse < HashWithIndifferentAccess
+  extend Deprecation
 
   require  'blacklight/solr_response/pagination_methods'
 
@@ -16,44 +17,35 @@ class Blacklight::SolrResponse < HashWithIndifferentAccess
   include MoreLikeThis
 
   attr_reader :request_params
-  attr_accessor :document_model
+  attr_accessor :document_model, :blacklight_config
 
   def initialize(data, request_params, options = {})
     super(force_to_utf8(data))
     @request_params = request_params
     self.document_model = options[:solr_document_model] || options[:document_model] || SolrDocument
+    self.blacklight_config = options[:blacklight_config]
   end
 
   def header
-    self['responseHeader']
+    self['responseHeader'] || {}
   end
-  
-  def update(other_hash) 
-    other_hash.each_pair { |key, value| self[key] = value } 
-    self 
-  end 
 
   def params
-      (header and header['params']) ? header['params'] : request_params
+    header['params'] || request_params
   end
 
   def rows
-      params[:rows].to_i
+    params[:rows].to_i
   end
 
   def sort
     params[:sort]
   end
 
-  def docs
-    @docs ||= begin
-      response['docs'] || []
-    end
-  end
-  
   def documents
-    docs.collect{|doc| document_model.new(doc, self) }
+    @documents ||= (response['docs'] || []).collect{|doc| document_model.new(doc, self) }
   end
+  alias_method :docs, :documents
 
   def grouped
     @groups ||= self["grouped"].map do |field, group|

data/lib/blacklight/solr_response/facets.rb

@@ -1,6 +1,7 @@
 require 'ostruct'
 
 module Blacklight::SolrResponse::Facets
+  extend Deprecation
   
   # represents a facet value; which is a field value and its hit count
   class FacetItem < OpenStruct
@@ -67,40 +68,29 @@ module Blacklight::SolrResponse::Facets
     end
     
   end
-  
+
+  ##
+  # Get all the Solr facet data (fields, queries, pivots) as a hash keyed by 
+  # both the Solr field name and/or by the blacklight field name
+  def aggregations
+    @aggregations ||= {}.merge(facet_field_aggregations).merge(facet_query_aggregations).merge(facet_pivot_aggregations)
+  end
+
   # @response.facets.each do |facet|
   #   facet.name
   #   facet.items
   # end
   # "caches" the result in the @facets instance var
   def 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
-        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
-
-        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
+    aggregations.values
   end
-  
+  deprecation_deprecate facets: :aggregations
+
   # pass in a facet field name and get back a Facet instance
   def facet_by_field_name(name)
-    @facets_by_field_name ||= {}
-    @facets_by_field_name[name] ||= (
-      facets.detect{|facet|facet.name.to_s == name.to_s}
-    )
+    aggregations[name]
   end
+  deprecation_deprecate facet_by_field_name: :aggregations
   
   def facet_counts
     @facet_counts ||= self['facet_counts'] || {}
@@ -108,7 +98,16 @@ module Blacklight::SolrResponse::Facets
 
   # Returns the hash of all the facet_fields (ie: {'instock_b' => ['true', 123, 'false', 20]}
   def facet_fields
-    @facet_fields ||= facet_counts['facet_fields'] || {}
+    @facet_fields ||= begin
+      val = facet_counts['facet_fields'] || {}
+
+      # this is some old solr (1.4? earlier?) serialization of facet fields
+      if val.is_a? Array
+        Hash[val]
+      else
+        val
+      end
+    end
   end
 
   # Returns all of the facet queries
@@ -120,5 +119,114 @@ module Blacklight::SolrResponse::Facets
   def facet_pivot
     @facet_pivot ||= facet_counts['facet_pivot'] || {}
   end
+
+  private
+  ##
+  # Convert Solr responses of various json.nl flavors to 
+  def list_as_hash solr_list
+    # map
+    if solr_list.values.first.is_a? Hash
+      solr_list
+    else
+      solr_list.each_with_object({}) do |(key, values), hash|
+        hash[key] = if values.first.is_a? Array
+          # arrarr
+          Hash[values]
+        else
+          # flat
+          Hash[values.each_slice(2).to_a]
+        end
+      end
+    end
+  end
+
+  ##
+  # Convert Solr's facet_field response into
+  # a hash of Blacklight::SolrResponse::Facet::FacetField objects
+  def facet_field_aggregations
+    list_as_hash(facet_fields).each_with_object({}) do |(facet_field_name, values), hash|
+      items = []
+      options = {}
+      values.each do |value, hits|
+        i = FacetItem.new(value: value, hits: hits)
+
+        # solr facet.missing serialization
+        if value.nil?
+          i.label = I18n.t(:"blacklight.search.fields.facet.missing.#{facet_field_name}", default: [:"blacklight.search.facets.missing"])
+          i.fq = "-#{facet_field_name}:[* TO *]"
+        end
+
+        items << i
+      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
+
+      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
+
+      hash[facet_field_name] = FacetField.new(facet_field_name, items, options)
+
+      if blacklight_config and !blacklight_config.facet_fields[facet_field_name]
+        # alias all the possible blacklight config names..
+        blacklight_config.facet_fields.select { |k,v| v.field == facet_field_name }.each do |key,_|
+          hash[key] = hash[facet_field_name]
+        end
+      end
+    end
+  end
+
+  ##
+  # Aggregate Solr's facet_query response into the virtual facet fields defined
+  # in the blacklight configuration
+  def facet_query_aggregations
+    return {} unless blacklight_config
+
+    blacklight_config.facet_fields.select { |k,v| v.query }.each_with_object({}) do |(field_name, facet_field), hash|
+        salient_facet_queries = facet_field.query.map { |k, x| x[:fq] }
+        items = []
+        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
+
+        hash[field_name] = Blacklight::SolrResponse::Facets::FacetField.new field_name, items
+    end
+  end
+
+  ##
+  # Convert Solr's facet_pivot response into 
+  # a hash of Blacklight::SolrResponse::Facet::FacetField objects
+  def facet_pivot_aggregations
+    facet_pivot.each_with_object({}) do |(field_name, values), hash|
+        items = []
+        values.map do |lst|
+          items << construct_pivot_field(lst)
+        end
+
+        if blacklight_config and !blacklight_config.facet_fields[field_name]
+          # alias all the possible blacklight config names..
+          blacklight_config.facet_fields.select { |k,v| v.pivot and v.pivot.join(",") == field_name }.each do |key, _|
+            hash[key] = Blacklight::SolrResponse::Facets::FacetField.new key, items
+          end
+        end
+    end
+  end
+  
+  ##
+  # Recursively parse the pivot facet response to build up the full pivot tree
+  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 Facets

data/lib/blacklight/solr_response/group_response.rb

@@ -25,7 +25,7 @@ class Blacklight::SolrResponse::GroupResponse
   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
+    (group["ngroups"] || (response.aggregations[key] || []).length).to_s.to_i
   end
     
   def start

data/lib/blacklight/solr_response/pagination_methods.rb

@@ -14,21 +14,4 @@ module Blacklight::SolrResponse::PaginationMethods
   def total_count #:nodoc:
     total
   end
-
-  def model_name
-    if !docs.empty? and docs.first.respond_to? :model_name
-      docs.first.model_name
-    end
-  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/generators/blacklight/install_generator.rb

@@ -6,6 +6,7 @@ module Blacklight
     argument     :model_name  , type: :string , default: "user"
     argument     :controller_name, type: :string , default: "catalog"
     argument     :document_name, type: :string , default: "solr_document"
+    argument     :search_builder_name, type: :string , default: "search_builder"
 
     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"
@@ -55,6 +56,10 @@ module Blacklight
       generate 'blacklight:document', document_name
     end
 
+    def generate_search_builder
+      generate 'blacklight:search_builder', search_builder_name
+    end
+
     def generate_blacklight_models
       generate 'blacklight:models'
     end
@@ -103,7 +108,7 @@ EOF
           run "bundle install"
         end
 
-        generate 'blacklight_marc:marc'
+        generate 'blacklight:marc:install'
       end
     end
   end

data/lib/generators/blacklight/search_builder_generator.rb

@@ -0,0 +1,20 @@
+require 'rails/generators'
+
+module Blacklight
+  class SearchBuilderGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    source_root File.expand_path('../templates', __FILE__)
+
+    argument     :model_name, :type => :string , :default => "search_builder"
+
+    desc """
+This generator makes the following changes to your application:
+ 1. Creates a blacklight search builder in your /app/models directory
+"""
+    def create_search_builder
+      template "search_builder.rb", "app/models/#{model_name}.rb"
+    end
+
+  end
+end

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

@@ -0,0 +1,3 @@
+class SearchBuilder < Blacklight::SearchBuilder
+  include Blacklight::Solr::SearchBuilderBehavior
+end

data/lib/railties/blacklight.rake

@@ -103,7 +103,7 @@ namespace :blacklight do
       print " - fetch: "
 
       begin
-        doc_id = response.docs.first[SolrDocument.unique_key]
+        doc_id = response.documents.first.id
         response, doc = controller.fetch doc_id
 
         if response.header['status'] == 0 and doc

data/spec/controllers/catalog_controller_spec.rb

@@ -39,18 +39,18 @@ describe CatalogController do
       it "should have docs and facets for query with results", :integration => true do
         get :index, q: user_query
         expect(assigns_response.docs).to_not be_empty
-        assert_facets_have_values(assigns_response.facets)
+        assert_facets_have_values(assigns_response.aggregations)
       end
       it "should have docs and facets for existing facet value", :integration => true do
         get :index, f: {"format" => 'Book'}
         expect(assigns_response.docs).to_not be_empty
-        assert_facets_have_values(assigns_response.facets)
+        assert_facets_have_values(assigns_response.aggregations)
       end
       it "should have docs and facets for non-default results per page", :integration => true do
         num_per_page = 7
         get :index, :per_page => num_per_page
         expect(assigns_response.docs).to have(num_per_page).items
-        assert_facets_have_values(assigns_response.facets)
+        assert_facets_have_values(assigns_response.aggregations)
       end
 
       it "should have docs and facets for second page", :integration => true do
@@ -58,14 +58,14 @@ describe CatalogController do
         get :index, :page => page
         expect(assigns_response.docs).to_not be_empty
         expect(assigns_response.params[:start].to_i).to eq (page-1) * @controller.blacklight_config[:default_solr_params][:rows]
-        assert_facets_have_values(assigns_response.facets)
+        assert_facets_have_values(assigns_response.aggregations)
       end
 
       it "should have no docs or facet values for query without results", :integration => true do
         get :index, q: 'sadfdsafasdfsadfsadfsadf' # query for no results
 
         expect(assigns_response.docs).to be_empty
-        assigns_response.facets.each do |facet|
+        assigns_response.aggregations.each do |key, facet|
           expect(facet.items).to be_empty
         end
       end
@@ -97,7 +97,7 @@ describe CatalogController do
         end
         it "should get facets when no query", :integration => true do
           get :index
-          assert_facets_have_values(assigns_response.facets)
+          assert_facets_have_values(assigns_response.aggregations)
         end
       end
 
@@ -737,10 +737,10 @@ end
 
 
 # there must be at least one facet, and each facet must have at least one value
-def assert_facets_have_values(facets)
-  expect(facets).to_not be_empty
+def assert_facets_have_values(aggregations)
+  expect(aggregations).to_not be_empty
   # should have at least one value for each facet
-  facets.each do |facet|
+  aggregations.each do |key, facet|
     expect(facet.items).to have_at_least(1).item
   end
 end

data/spec/helpers/blacklight_helper_spec.rb

@@ -207,203 +207,53 @@ describe BlacklightHelper do
     end
   end
 
-  describe "render_index_field_value" do
+  describe "#render_index_field_value" do
+    let(:presenter) { double }
     before do
-      @config = Blacklight::Configuration.new.configure do |config|
-        config.add_index_field 'qwer'
-        config.add_index_field 'asdf', :helper_method => :render_asdf_index_field
-        config.add_index_field 'link_to_search_true', :link_to_search => true
-        config.add_index_field 'link_to_search_named', :link_to_search => :some_field
-        config.add_index_field 'highlight', :highlight => true
-        config.add_index_field 'solr_doc_accessor', :accessor => true
-        config.add_index_field 'explicit_accessor', :accessor => :solr_doc_accessor
-        config.add_index_field 'explicit_accessor_with_arg', :accessor => :solr_doc_accessor_with_arg
-      end
-      allow(helper).to receive(:blacklight_config).and_return(@config)
-    end
-
-    it "should check for an explicit value" do
-      doc = double()
-      expect(doc).to_not receive(:get).with('asdf', :sep => nil)
-      value = helper.render_index_field_value :value => 'asdf', :document => doc, :field => 'asdf'
-      expect(value).to eq 'asdf'
+      allow(helper).to receive(:presenter).with(doc).and_return(presenter)
     end
 
-    it "should check for a helper method to call" do
-      doc = double()
-      allow(doc).to receive(:get).with('asdf', :sep => nil)
-      allow(helper).to receive(:render_asdf_index_field).and_return('custom asdf value')
-      value = helper.render_index_field_value :document => doc, :field => 'asdf'
-      expect(value).to eq 'custom asdf value'
-    end
-
-    it "should check for a link_to_search" do
-      doc = double()
-      allow(doc).to receive(:get).with('link_to_search_true', :sep => nil).and_return('x')
-      value = helper.render_index_field_value :document => doc, :field => 'link_to_search_true'
-      expect(value).to eq helper.link_to("x", helper.search_action_path(:f => { :link_to_search_true => ['x'] }))
-    end
-
-    it "should check for a link_to_search with a field name" do
-      doc = double()
-      allow(doc).to receive(:get).with('link_to_search_named', :sep => nil).and_return('x')
-      value = helper.render_index_field_value :document => doc, :field => 'link_to_search_named'
-      expect(value).to eq helper.link_to("x", helper.search_action_path(:f => { :some_field => ['x'] }))
-    end
-
-    it "should gracefully handle when no highlight field is available" do
-      doc = double()
-      expect(doc).to_not receive(:get)
-      allow(doc).to receive(:has_highlight_field?).and_return(false)
-      value = helper.render_index_field_value :document => doc, :field => 'highlight'
-      expect(value).to be_blank
-    end
-
-    it "should check for a highlighted field" do
-      doc = double()
-      expect(doc).to_not receive(:get)
-      allow(doc).to receive(:has_highlight_field?).and_return(true)
-      allow(doc).to receive(:highlight_field).with('highlight').and_return(['<em>highlight</em>'.html_safe])
-      value = helper.render_index_field_value :document => doc, :field => 'highlight'
-      expect(value).to eq '<em>highlight</em>'
-    end
-
-    it "should check the document field value" do
-      doc = double()
-      allow(doc).to receive(:get).with('qwer', :sep => nil).and_return('document qwer value')
-      value = helper.render_index_field_value :document => doc, :field => 'qwer'
-      expect(value).to eq 'document qwer value'
-    end
-
-    it "should work with index fields that aren't explicitly defined" do
-      doc = double()
-      allow(doc).to receive(:get).with('mnbv', :sep => nil).and_return('document mnbv value')
-      value = helper.render_index_field_value :document => doc, :field => 'mnbv'
-      expect(value).to eq 'document mnbv value'
-    end
+    let(:doc) { double }
+    let(:field) { "some_field" }
 
-    it "should call an accessor on the solr document" do
-      doc = double(:solr_doc_accessor => "123")
-      value = helper.render_index_field_value :document => doc, :field => 'solr_doc_accessor'
-      expect(value).to eq "123"
+    it "should pass the document and field through to the presenter" do
+      expect(presenter).to receive(:render_index_field_value).with(field, {})
+      helper.render_index_field_value(doc, field)
     end
 
-    it "should call an explicit accessor on the solr document" do
-      doc = double(:solr_doc_accessor => "123")
-      value = helper.render_index_field_value :document => doc, :field => 'explicit_accessor'
-      expect(value).to eq "123"
+    it "should allow the document and field to be passed as hash arguments" do
+      expect(presenter).to receive(:render_index_field_value).with(field, {})
+      helper.render_index_field_value(document: doc, field: field)
     end
 
-    it "should call an implicit accessor on the solr document" do
-      doc = double()
-      expect(doc).to receive(:solr_doc_accessor_with_arg).with('explicit_accessor_with_arg').and_return("123")
-      value = helper.render_index_field_value :document => doc, :field => 'explicit_accessor_with_arg'
-      expect(value).to eq "123"
+    it "should allow additional options to be passed to the presenter" do
+      expect(presenter).to receive(:render_index_field_value).with(field, x: 1)
+      helper.render_index_field_value(document: doc, field: field, x: 1)
     end
   end
-
-  describe "render_document_show_field_value" do
+  
+  describe "#render_document_show_field_value" do
+    let(:presenter) { double }
     before do
-      @config = Blacklight::Configuration.new.configure do |config|
-        config.add_show_field 'qwer'
-        config.add_show_field 'asdf', :helper_method => :render_asdf_document_show_field
-        config.add_show_field 'link_to_search_true', :link_to_search => true
-        config.add_show_field 'link_to_search_named', :link_to_search => :some_field
-        config.add_show_field 'highlight', :highlight => true
-        config.add_show_field 'solr_doc_accessor', :accessor => true
-        config.add_show_field 'explicit_accessor', :accessor => :solr_doc_accessor
-        config.add_show_field 'explicit_array_accessor', :accessor => [:solr_doc_accessor, :some_method]
-        config.add_show_field 'explicit_accessor_with_arg', :accessor => :solr_doc_accessor_with_arg
-      end
-
-      allow(helper).to receive(:blacklight_config).and_return(@config)
-    end
-
-    it "should check for an explicit value" do
-      doc = double()
-      expect(doc).to_not receive(:get).with('asdf', :sep => nil)
-      expect(helper).to_not receive(:render_asdf_document_show_field)
-      value = helper.render_document_show_field_value :value => 'asdf', :document => doc, :field => 'asdf'
-      expect(value).to eq 'asdf'
+      allow(helper).to receive(:presenter).with(doc).and_return(presenter)
     end
 
-    it "should check for a helper method to call" do
-      doc = double()
-      allow(doc).to receive(:get).with('asdf', :sep => nil)
-      allow(helper).to receive(:render_asdf_document_show_field).and_return('custom asdf value')
-      value = helper.render_document_show_field_value :document => doc, :field => 'asdf'
-      expect(value).to eq 'custom asdf value'
-    end
-
-    it "should check for a link_to_search" do
-      doc = double()
-      allow(doc).to receive(:get).with('link_to_search_true', :sep => nil).and_return('x')
-      value = helper.render_document_show_field_value :document => doc, :field => 'link_to_search_true'
-      expect(value).to eq helper.link_to("x", helper.search_action_path(:f => { :link_to_search_true => ['x'] }))
-    end
-
-    it "should check for a link_to_search with a field name" do
-      doc = double()
-      allow(doc).to receive(:get).with('link_to_search_named', :sep => nil).and_return('x')
-      value = helper.render_document_show_field_value :document => doc, :field => 'link_to_search_named'
-      expect(value).to eq helper.link_to("x", helper.search_action_path(:f => { :some_field => ['x'] }))
-    end
-
-    it "should gracefully handle when no highlight field is available" do
-      doc = double()
-      expect(doc).to_not receive(:get)
-      allow(doc).to receive(:has_highlight_field?).and_return(false)
-      value = helper.render_document_show_field_value :document => doc, :field => 'highlight'
-      expect(value).to be_blank
-    end
-
-    it "should check for a highlighted field" do
-      doc = double()
-      expect(doc).to_not receive(:get)
-      allow(doc).to receive(:has_highlight_field?).and_return(true)
-      allow(doc).to receive(:highlight_field).with('highlight').and_return(['<em>highlight</em>'.html_safe])
-      value = helper.render_document_show_field_value :document => doc, :field => 'highlight'
-      expect(value).to eq '<em>highlight</em>'
-    end
-
-
-    it "should check the document field value" do
-      doc = double()
-      allow(doc).to receive(:get).with('qwer', :sep => nil).and_return('document qwer value')
-      value = helper.render_document_show_field_value :document => doc, :field => 'qwer'
-      expect(value).to eq 'document qwer value'
-    end
-
-    it "should work with show fields that aren't explicitly defined" do
-      doc = double()
-      allow(doc).to receive(:get).with('mnbv', :sep => nil).and_return('document mnbv value')
-      value = helper.render_document_show_field_value :document => doc, :field => 'mnbv'
-      expect(value).to eq 'document mnbv value'
-    end
-
-    it "should call an accessor on the solr document" do
-      doc = double(:solr_doc_accessor => "123")
-      value = helper.render_document_show_field_value :document => doc, :field => 'solr_doc_accessor'
-      expect(value).to eq "123"
-    end
+    let(:doc) { double }
+    let(:field) { "some_field" }
 
-    it "should call an explicit accessor on the solr document" do
-      doc = double(:solr_doc_accessor => "123")
-      value = helper.render_document_show_field_value :document => doc, :field => 'explicit_accessor'
-      expect(value).to eq "123"
+    it "should pass the document and field through to the presenter" do
+      expect(presenter).to receive(:render_document_show_field_value).with(field, {})
+      helper.render_document_show_field_value(doc, field)
     end
 
-    it "should call an explicit array-style accessor on the solr document" do
-      doc = double(:solr_doc_accessor => double(:some_method => "123"))
-      value = helper.render_document_show_field_value :document => doc, :field => 'explicit_array_accessor'
-      expect(value).to eq "123"
+    it "should allow the document and field to be passed as hash arguments" do
+      expect(presenter).to receive(:render_document_show_field_value).with(field, {})
+      helper.render_document_show_field_value(document: doc, field: field)
     end
 
-    it "should call an accessor on the solr document with the field as an argument" do
-      doc = double()
-      expect(doc).to receive(:solr_doc_accessor_with_arg).with('explicit_accessor_with_arg').and_return("123")
-      value = helper.render_document_show_field_value :document => doc, :field => 'explicit_accessor_with_arg'
-      expect(value).to eq "123"
+    it "should allow additional options to be passed to the presenter" do
+      expect(presenter).to receive(:render_document_show_field_value).with(field, x: 1)
+      helper.render_document_show_field_value(document: doc, field: field, x: 1)
     end
   end