blacklight 7.0.0.rc1 → 7.0.0.rc2

data/spec/lib/blacklight_spec.rb

@@ -2,21 +2,21 @@
 
 RSpec.describe Blacklight do
   context 'root' do
-    let(:blroot) { File.expand_path(File.join(__FILE__, '..', '..', '..' )) }
+    let(:blroot) { File.expand_path(File.join(__FILE__, '..', '..', '..')) }
 
     it 'returns the full path to the BL plugin' do
-      expect(Blacklight.root).to eq blroot
+      expect(described_class.root).to eq blroot
     end
   end
 
   describe '.default_index' do
     context 'for a solr index' do
       before do
-        allow(Blacklight).to receive(:connection_config).and_return(adapter: 'solr')
+        allow(described_class).to receive(:connection_config).and_return(adapter: 'solr')
       end
 
       it 'is an instance of Blacklight::Solr::Repository' do
-        expect(Blacklight.default_index).to be_a Blacklight::Solr::Repository
+        expect(described_class.default_index).to be_a Blacklight::Solr::Repository
       end
     end
   end
@@ -24,51 +24,50 @@ RSpec.describe Blacklight do
   describe '.repository_class' do
     context 'when the adapter key is missing' do
       before do
-        allow(Blacklight).to receive(:connection_config).and_return({})
+        allow(described_class).to receive(:connection_config).and_return({})
       end
 
       it 'raises an error' do
-        expect { Blacklight.repository_class }.to raise_error RuntimeError, 'The value for :adapter was not found in the blacklight.yml config'
+        expect { described_class.repository_class }.to raise_error RuntimeError, 'The value for :adapter was not found in the blacklight.yml config'
       end
     end
 
     context 'for a solr index' do
       before do
-        allow(Blacklight).to receive(:connection_config).and_return(adapter: 'solr')
+        allow(described_class).to receive(:connection_config).and_return(adapter: 'solr')
       end
 
       it 'resolves to the SolrRepository implementation' do
-        expect(Blacklight.repository_class).to eq Blacklight::Solr::Repository
+        expect(described_class.repository_class).to eq Blacklight::Solr::Repository
       end
     end
 
     context 'for an elastic_search index' do
       before do
         stub_const("Blacklight::ElasticSearch::Repository", double)
-        allow(Blacklight).to receive(:connection_config).and_return(adapter: 'elastic_search')
+        allow(described_class).to receive(:connection_config).and_return(adapter: 'elastic_search')
       end
 
       it 'resolves to the SolrRepository implementation' do
-        expect(Blacklight.repository_class).to eq Blacklight::ElasticSearch::Repository
+        expect(described_class.repository_class).to eq Blacklight::ElasticSearch::Repository
       end
     end
 
     context 'for an explicitly provided class' do
       before do
         stub_const("CustomSearch::Repository", double)
-        allow(Blacklight).to receive(:connection_config).and_return(adapter: 'CustomSearch::Repository')
+        allow(described_class).to receive(:connection_config).and_return(adapter: 'CustomSearch::Repository')
       end
 
       it 'resolves to the custom implementation' do
-        expect(Blacklight.repository_class).to eq CustomSearch::Repository
+        expect(described_class.repository_class).to eq CustomSearch::Repository
       end
     end
   end
 
   describe '.default_configuration' do
     it 'is a Blacklight configuration' do
-      expect(Blacklight.default_configuration).to be_a Blacklight::Configuration
+      expect(described_class.default_configuration).to be_a Blacklight::Configuration
     end
   end
-  
 end

data/spec/lib/tasks/blacklight_task_spec.rb

@@ -2,19 +2,17 @@
 require 'rake'
 
 RSpec.describe "blacklight:delete_old_searches" do
-
   before do
-    @rake = Rake::Application.new      
+    @rake = Rake::Application.new
     Rake.application = @rake
     Rake.application.rake_require "../lib/railties/blacklight"
     Rake::Task.define_task(:environment)
     @task_name = "blacklight:delete_old_searches"
   end
-  
+
   it "calls Search.delete_old_searches" do
     days_old = 7
-    allow(Search).to receive(:delete_old_searches).with(days_old)  
+    allow(Search).to receive(:delete_old_searches).with(days_old)
     @rake[@task_name].invoke(days_old)
   end
-    
 end

data/spec/models/blacklight/configurable_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe "Blacklight::Configurable" do
-
+RSpec.describe "Blacklight::Configurable", api: true do
   describe "inheritence" do
     before(:all) do
       module TestCaseInheritence
@@ -9,7 +8,7 @@ RSpec.describe "Blacklight::Configurable" do
           include Blacklight::Configurable
 
           blacklight_config.configure do |config|
-            config.list = [1,2,3]
+            config.list = [1, 2, 3]
           end
         end
 
@@ -17,23 +16,23 @@ RSpec.describe "Blacklight::Configurable" do
         end
       end
     end
+
     it "inherits the configuration when subclassed" do
-      expect(TestCaseInheritence::Child.blacklight_config.list).to include(1,2,3)
+      expect(TestCaseInheritence::Child.blacklight_config.list).to include(1, 2, 3)
     end
 
     it "inherited version should be a deep copy, not original" do
-      expect(TestCaseInheritence::Child.blacklight_config).to_not  be(TestCaseInheritence::Parent.blacklight_config)
+      expect(TestCaseInheritence::Child.blacklight_config).not_to  be(TestCaseInheritence::Parent.blacklight_config)
 
       TestCaseInheritence::Child.blacklight_config.list << "child_only"
 
-
       expect(TestCaseInheritence::Child.blacklight_config.list).to include("child_only")
-      expect(TestCaseInheritence::Parent.blacklight_config.list).to_not include("child_only")
+      expect(TestCaseInheritence::Parent.blacklight_config.list).not_to include("child_only")
     end
   end
 
   describe "default configuration" do
-    before(:each) do
+    before do
       Blacklight::Configurable.default_configuration = nil
     end
 
@@ -51,7 +50,7 @@ RSpec.describe "Blacklight::Configurable" do
     it "allows the user to provide a default configuration" do
       a = Class.new
 
-      Blacklight::Configurable.default_configuration = Blacklight::Configuration.new :a => 1
+      Blacklight::Configurable.default_configuration = Blacklight::Configuration.new a: 1
 
       a.send(:include, Blacklight::Configurable)
       expect(a.blacklight_config.a).to eq 1
@@ -76,7 +75,7 @@ RSpec.describe "Blacklight::Configurable" do
       instance = klass.new
       instance.blacklight_config = Blacklight::Configuration.new
 
-      expect(instance.blacklight_config).to_not eq klass.blacklight_config
+      expect(instance.blacklight_config).not_to eq klass.blacklight_config
       expect(instance.blacklight_config.foo).to be_nil
     end
 
@@ -92,10 +91,10 @@ RSpec.describe "Blacklight::Configurable" do
 
       instance = klass.new
       instance.blacklight_config.bar << "123"
-      expect(instance.blacklight_config).to_not eq klass.blacklight_config
+      expect(instance.blacklight_config).not_to eq klass.blacklight_config
       expect(klass.blacklight_config.foo).to eq "bar"
       expect(instance.blacklight_config.foo).to eq  "bar"
-      expect(klass.blacklight_config.bar).to_not include("123")
+      expect(klass.blacklight_config.bar).not_to include("123")
       expect(instance.blacklight_config.bar).to include("asd", "123")
     end
 
@@ -111,6 +110,5 @@ RSpec.describe "Blacklight::Configurable" do
       expect(klass.blacklight_config.foo).to eq "bar"
       expect(klass2.blacklight_config.foo).to eq "asdf"
     end
-
   end
 end

data/spec/models/blacklight/configuration/context_spec.rb

@@ -1,33 +1,32 @@
 # frozen_string_literal: true
 
-RSpec.describe Blacklight::Configuration::Context do
-
+RSpec.describe Blacklight::Configuration::Context, api: true do
   subject { described_class.new(context) }
+
   let(:context) { double }
 
   describe "#evaluate_configuration_conditional" do
-    it "should pass through regular values" do
+    it "passes through regular values" do
       val = double
       expect(subject.evaluate_configuration_conditional(val)).to eq val
     end
 
-    it "should execute a helper method" do
-      allow(context).to receive_messages(:my_check => true)
+    it "executes a helper method" do
+      allow(context).to receive_messages(my_check: true)
       expect(subject.evaluate_configuration_conditional(:my_check)).to be true
     end
 
-    it "should call a helper to determine if it should render a field" do
+    it "calls a helper to determine if it should render a field" do
       a = double
       allow(context).to receive(:my_check_with_an_arg).with(a).and_return(true)
       expect(subject.evaluate_configuration_conditional(:my_check_with_an_arg, a)).to be true
     end
 
-    it "should evaluate a Proc to determine if it should render a field" do
-      one_arg_lambda = lambda { |context, a| true }
-      two_arg_lambda = lambda { |context, a, b| true }
+    it "evaluates a Proc to determine if it should render a field" do
+      one_arg_lambda = ->(_context, _a) { true }
+      two_arg_lambda = ->(_context, _a, _b) { true }
       expect(subject.evaluate_configuration_conditional(one_arg_lambda, 1)).to be true
       expect(subject.evaluate_configuration_conditional(two_arg_lambda, 1, 2)).to be true
     end
   end
-
 end

data/spec/models/blacklight/configuration_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe "Blacklight::Configuration" do
-
+RSpec.describe "Blacklight::Configuration", api: true do
   let(:config) do
     Blacklight::Configuration.new
   end
@@ -19,7 +18,7 @@ RSpec.describe "Blacklight::Configuration" do
     end
 
     it "accepts a block for configuration" do
-      config = Blacklight::Configuration.new(:a => 1) { |c| c.a = 2 }
+      config = Blacklight::Configuration.new(a: 1) { |c| c.a = 2 }
 
       expect(config.a).to eq 2
 
@@ -52,6 +51,7 @@ RSpec.describe "Blacklight::Configuration" do
 
   describe "#connection_config" do
     let(:custom_config) { double }
+
     it "has the global blacklight configuration" do
       expect(config.connection_config).to eq Blacklight.connection_config
     end
@@ -65,9 +65,9 @@ RSpec.describe "Blacklight::Configuration" do
     it "has a list of additional formats for index requests to respond to" do
       config.index.respond_to.xml = true
 
-      config.index.respond_to.csv = { :layout => false }
+      config.index.respond_to.csv = { layout: false }
 
-      config.index.respond_to.yaml = lambda { render plain: "" }
+      config.index.respond_to.yaml = -> { render plain: "" }
 
       expect(config.index.respond_to.keys).to eq [:xml, :csv, :yaml]
     end
@@ -79,15 +79,15 @@ RSpec.describe "Blacklight::Configuration" do
     end
 
     it "accepts config'd value" do
-      expect(Blacklight::Configuration.new(:spell_max => 10).spell_max).to eq 10
+      expect(Blacklight::Configuration.new(spell_max: 10).spell_max).to eq 10
     end
   end
 
   describe "for_display_type" do
-    let(:mock_field) { Blacklight::Configuration::IndexField.new }
     let(:image) { SolrDocument.new(format: 'Image') }
     let(:sound) { SolrDocument.new(format: 'Sound') }
-    it "adds fields just for a certain type" do
+
+    it "adds index fields just for a certain type" do
       config.for_display_type "Image" do |c|
         c.add_index_field :dimensions
       end
@@ -99,13 +99,37 @@ RSpec.describe "Blacklight::Configuration" do
       expect(config.index_fields_for(image)).to have_key 'title'
       expect(config.index_fields).not_to have_key 'dimensions'
     end
+
+    it "adds show fields just for a certain type" do
+      config.for_display_type "Image" do |c|
+        c.add_show_field :dimensions
+      end
+      config.add_show_field :title
+
+      expect(config.show_fields_for(image)).to have_key 'dimensions'
+      expect(config.show_fields_for(image)).to have_key 'title'
+      expect(config.show_fields_for(sound)).not_to have_key 'dimensions'
+      expect(config.show_fields_for(image)).to have_key 'title'
+      expect(config.show_fields).not_to have_key 'dimensions'
+    end
+
+    it 'calls the block on subsequent invocations' do
+      config.for_display_type "Image" do |c|
+        c.add_show_field :dimensions
+      end
+      config.for_display_type "Image" do |c|
+        c.add_show_field :photographer
+      end
+
+      expect(config.show_fields_for(image)).to have_key 'dimensions'
+      expect(config.show_fields_for(image)).to have_key 'photographer'
+    end
   end
 
   describe "inheritable_copy" do
     let(:klass) { Class.new }
     let(:config_copy) { config.inheritable_copy(klass) }
 
-
     it "provides a deep copy of the configuration" do
       config_copy.a = 1
 
@@ -113,7 +137,7 @@ RSpec.describe "Blacklight::Configuration" do
       config_copy.add_facet_field "dummy_field", @mock_facet
 
       expect(config.a).to be_nil
-      expect(config.facet_fields).to_not include(@mock_facet)
+      expect(config.facet_fields).not_to include(@mock_facet)
     end
 
     context "when model classes are customised" do
@@ -142,15 +166,15 @@ RSpec.describe "Blacklight::Configuration" do
 
     it "provides cloned copies of mutable data structures" do
       config.a = { value: 1 }
-      config.b = [1,2,3]
+      config.b = [1, 2, 3]
 
       config_copy.a[:value] = 2
       config_copy.b << 5
 
       expect(config.a[:value]).to eq 1
       expect(config_copy.a[:value]).to eq 2
-      expect(config.b).to match_array [1,2,3]
-      expect(config_copy.b).to match_array [1,2,3,5]
+      expect(config.b).to match_array [1, 2, 3]
+      expect(config_copy.b).to match_array [1, 2, 3, 5]
     end
   end
 
@@ -159,42 +183,36 @@ RSpec.describe "Blacklight::Configuration" do
       Blacklight::Configuration.define_field_access :my_custom_field
 
       config = Blacklight::Configuration.new do |config|
-        config.add_my_custom_field 'qwerty', :label => "asdf"
+        config.add_my_custom_field 'qwerty', label: "asdf"
       end
 
-
-
       expect(config.my_custom_fields.keys).to include('qwerty')
     end
 
     it "lets you define a field accessor that uses an existing field-type" do
-
-      Blacklight::Configuration.define_field_access :my_custom_facet_field, :class => Blacklight::Configuration::FacetField
+      Blacklight::Configuration.define_field_access :my_custom_facet_field, class: Blacklight::Configuration::FacetField
 
       config = Blacklight::Configuration.new do |config|
-        config.add_my_custom_facet_field 'qwerty', :label => "asdf"
+        config.add_my_custom_facet_field 'qwerty', label: "asdf"
       end
 
-
-
       expect(config.my_custom_facet_fields['qwerty']).to be_a_kind_of(Blacklight::Configuration::FacetField)
     end
-
   end
 
   describe "add_facet_field" do
     it "accepts field name and hash form arg" do
-      config.add_facet_field('format',  :label => "Format", :limit => true)
+      config.add_facet_field('format', label: "Format", limit: true)
 
-      expect(config.facet_fields["format"]).to_not be_nil
+      expect(config.facet_fields["format"]).not_to be_nil
       expect(config.facet_fields["format"]["label"]).to eq "Format"
       expect(config.facet_fields["format"]["limit"]).to be true
     end
 
     it "accepts FacetField obj arg" do
-      config.add_facet_field("format", Blacklight::Configuration::FacetField.new( :label => "Format"))
+      config.add_facet_field("format", Blacklight::Configuration::FacetField.new(label: "Format"))
 
-      expect(config.facet_fields["format"]).to_not be_nil
+      expect(config.facet_fields["format"]).not_to be_nil
       expect(config.facet_fields["format"]["label"]).to eq "Format"
     end
 
@@ -204,7 +222,7 @@ RSpec.describe "Blacklight::Configuration" do
         facet.limit = true
       end
 
-      expect(config.facet_fields["format"]).to_not be_nil
+      expect(config.facet_fields["format"]).not_to be_nil
       expect(config.facet_fields["format"].limit).to be true
     end
 
@@ -214,23 +232,23 @@ RSpec.describe "Blacklight::Configuration" do
         facet.label = "Format"
       end
 
-      expect(config.facet_fields['format']).to_not be_nil
+      expect(config.facet_fields['format']).not_to be_nil
     end
 
     it "accepts a configuration hash" do
-      config.add_facet_field :field => 'format', :label => 'Format'
-      expect(config.facet_fields['format']).to_not be_nil
+      config.add_facet_field field: 'format', label: 'Format'
+      expect(config.facet_fields['format']).not_to be_nil
     end
 
     it "accepts array form" do
-      config.add_facet_field([{ :field => 'format', :label => 'Format'}, { :field => 'publication_date', :label => 'Publication Date' }])
+      config.add_facet_field([{ field: 'format', label: 'Format' }, { field: 'publication_date', label: 'Publication Date' }])
 
       expect(config.facet_fields).to have(2).fields
     end
 
     it "accepts array form with a block" do
       expect do |b|
-        config.add_facet_field([{ :field => 'format', :label => 'Format'}, { :field => 'publication_date', :label => 'Publication Date' }], &b)
+        config.add_facet_field([{ field: 'format', label: 'Format' }, { field: 'publication_date', label: 'Publication Date' }], &b)
       end.to yield_control.twice
     end
 
@@ -241,7 +259,7 @@ RSpec.describe "Blacklight::Configuration" do
     end
 
     it "allows you to not show the facet in the facet bar" do
-      config.add_facet_field("publication_date", :show=>false)
+      config.add_facet_field("publication_date", show: false)
 
       expect(config.facet_fields["publication_date"]['show']).to be false
     end
@@ -251,25 +269,25 @@ RSpec.describe "Blacklight::Configuration" do
     end
 
     it "looks up and match field names" do
-      allow(config).to receive_messages(luke_fields: {
+      allow(config).to receive(:reflected_fields).and_return(
         "some_field_facet" => {},
         "another_field_facet" => {},
-        "a_facet_field" => {},
-        })
+        "a_facet_field" => {}
+      )
       expect { |b| config.add_facet_field match: /_facet$/, &b }.to yield_control.twice
 
-      expect(config.facet_fields.keys).to eq ["some_field_facet", "another_field_facet"]
+      expect(config.facet_fields.keys).to eq %w[some_field_facet another_field_facet]
     end
 
     it "takes wild-carded field names and dereference them to solr fields" do
-      allow(config).to receive_messages(luke_fields: {
+      allow(config).to receive(:reflected_fields).and_return(
         "some_field_facet" => {},
         "another_field_facet" => {},
-        "a_facet_field" => {},
-        })
+        "a_facet_field" => {}
+      )
       expect { |b| config.add_facet_field "*_facet", &b }.to yield_control.twice
 
-      expect(config.facet_fields.keys).to eq ["some_field_facet", "another_field_facet"]
+      expect(config.facet_fields.keys).to eq %w[some_field_facet another_field_facet]
     end
 
     describe "if/unless conditions with legacy show parameter" do
@@ -291,22 +309,22 @@ RSpec.describe "Blacklight::Configuration" do
 
   describe "add_index_field" do
     it "takes hash form" do
-      config.add_index_field("title_tsim", :label => "Title")
+      config.add_index_field("title_tsim", label: "Title")
 
-      expect(config.index_fields["title_tsim"]).to_not be_nil
+      expect(config.index_fields["title_tsim"]).not_to be_nil
       expect(config.index_fields["title_tsim"].label).to eq "Title"
     end
     it "takes IndexField param" do
-      config.add_index_field("title_tsim", Blacklight::Configuration::IndexField.new(:field => "title_display", :label => "Title"))
+      config.add_index_field("title_tsim", Blacklight::Configuration::IndexField.new(field: "title_display", label: "Title"))
 
-      expect(config.index_fields["title_tsim"]).to_not be_nil
+      expect(config.index_fields["title_tsim"]).not_to be_nil
       expect(config.index_fields["title_tsim"].label).to eq "Title"
     end
     it "takes block form" do
       config.add_index_field("title_tsim") do |field|
         field.label = "Title"
       end
-      expect(config.index_fields["title_tsim"]).to_not be_nil
+      expect(config.index_fields["title_tsim"]).not_to be_nil
       expect(config.index_fields["title_tsim"].label).to eq "Title"
     end
 
@@ -321,14 +339,14 @@ RSpec.describe "Blacklight::Configuration" do
     end
 
     it "takes wild-carded field names and dereference them to solr fields" do
-      allow(config).to receive_messages(luke_fields: {
+      allow(config).to receive(:reflected_fields).and_return(
         "some_field_display" => {},
         "another_field_display" => {},
-        "a_facet_field" => {},
-        })
+        "a_facet_field" => {}
+      )
       config.add_index_field "*_display"
 
-      expect(config.index_fields.keys).to eq ["some_field_display", "another_field_display"]
+      expect(config.index_fields.keys).to eq %w[some_field_display another_field_display]
     end
 
     it "queries solr and get live values for match fields", integration: true do
@@ -339,30 +357,30 @@ RSpec.describe "Blacklight::Configuration" do
 
   describe "add_show_field" do
     it "takes hash form" do
-      config.add_show_field("title_tsim", :label => "Title")
+      config.add_show_field("title_tsim", label: "Title")
 
-      expect(config.show_fields["title_tsim"]).to_not be_nil
+      expect(config.show_fields["title_tsim"]).not_to be_nil
       expect(config.show_fields["title_tsim"].label).to eq "Title"
     end
     it "takes ShowField argument" do
-      config.add_show_field("title_tsim", Blacklight::Configuration::ShowField.new(:field => "title_display", :label => "Title"))
+      config.add_show_field("title_tsim", Blacklight::Configuration::ShowField.new(field: "title_display", label: "Title"))
 
-      expect(config.show_fields["title_tsim"]).to_not be_nil
-      expect(config.show_fields["title_tsim"].label).to eq  "Title"
+      expect(config.show_fields["title_tsim"]).not_to be_nil
+      expect(config.show_fields["title_tsim"].label).to eq "Title"
     end
     it "takes block form" do
       config.add_show_field("title_tsim") do |f|
         f.label = "Title"
       end
 
-      expect(config.show_fields["title_tsim"]).to_not be_nil
-      expect(config.show_fields["title_tsim"].label).to eq  "Title"
+      expect(config.show_fields["title_tsim"]).not_to be_nil
+      expect(config.show_fields["title_tsim"].label).to eq "Title"
     end
 
     it "creates default label humanized from field" do
       config.add_show_field("my_custom_field")
 
-      expect(config.show_fields["my_custom_field"].label).to eq  "My Custom Field"
+      expect(config.show_fields["my_custom_field"].label).to eq "My Custom Field"
     end
 
     it "raises on nil solr field name" do
@@ -370,72 +388,67 @@ RSpec.describe "Blacklight::Configuration" do
     end
 
     it "takes wild-carded field names and dereference them to solr fields" do
-      allow(config).to receive_messages(luke_fields: {
+      allow(config).to receive(:reflected_fields).and_return(
         "some_field_display" => {},
         "another_field_display" => {},
-        "a_facet_field" => {},
-        })
+        "a_facet_field" => {}
+      )
       config.add_show_field "*_display"
 
-      expect(config.show_fields.keys).to eq ["some_field_display", "another_field_display"]
+      expect(config.show_fields.keys).to eq %w[some_field_display another_field_display]
     end
-
   end
 
-
   describe "add_search_field" do
     it "accepts hash form" do
       c = Blacklight::Configuration.new
-      c.add_search_field(:key => "my_search_key")
-      expect(c.search_fields["my_search_key"]).to_not be_nil
+      c.add_search_field(key: "my_search_key")
+      expect(c.search_fields["my_search_key"]).not_to be_nil
     end
 
     it "accepts two-arg hash form" do
       c = Blacklight::Configuration.new
 
       c.add_search_field("my_search_type",
-          :key => "my_search_type",
-          :solr_parameters => { :qf => "my_field_qf^10" },
-          :solr_local_parameters => { :pf=>"$my_field_pf"})
+                         key: "my_search_type",
+                         solr_parameters: { qf: "my_field_qf^10" },
+                         solr_local_parameters: { pf: "$my_field_pf" })
 
       field = c.search_fields["my_search_type"]
 
-      expect(field).to_not be_nil
-
-
-      expect(field.solr_parameters).to_not be_nil
-      expect(field.solr_local_parameters).to_not be_nil
-
+      expect(field).not_to be_nil
 
+      expect(field.solr_parameters).not_to be_nil
+      expect(field.solr_local_parameters).not_to be_nil
     end
 
     it "accepts block form" do
       c = Blacklight::Configuration.new
 
       c.add_search_field("some_field") do |field|
-        field.solr_parameters = {:qf => "solr_field^10"}
-        field.solr_local_parameters = {:pf => "$some_field_pf"}
+        field.solr_parameters = { qf: "solr_field^10" }
+        field.solr_local_parameters = { pf: "$some_field_pf" }
       end
 
       f = c.search_fields["some_field"]
 
-      expect(f).to_not be_nil
-      expect(f.solr_parameters).to_not be_nil
-      expect(f.solr_local_parameters).to_not be_nil
+      expect(f).not_to be_nil
+      expect(f.solr_parameters).not_to be_nil
+      expect(f.solr_local_parameters).not_to be_nil
     end
 
     it "accepts SearchField object" do
       c = Blacklight::Configuration.new
 
-      f = Blacklight::Configuration::SearchField.new( :foo => "bar")
+      f = Blacklight::Configuration::SearchField.new(foo: "bar")
 
       c.add_search_field("foo", f)
 
-      expect(c.search_fields["foo"]).to_not be_nil
+      expect(c.search_fields["foo"]).not_to be_nil
     end
 
     it "raises on nil key" do
-      expect {config.add_search_field(nil, :foo => "bar")}.to raise_error ArgumentError
+      expect { config.add_search_field(nil, foo: "bar") }.to raise_error ArgumentError
     end
 
     it "creates default label from titleized field key" do
@@ -464,13 +477,13 @@ RSpec.describe "Blacklight::Configuration" do
   describe "add_sort_field" do
     it "takes a hash" do
       c = Blacklight::Configuration.new
-      c.add_sort_field(:key => "my_sort_key", :sort => "score desc")
-      expect(c.sort_fields["my_sort_key"]).to_not be_nil
+      c.add_sort_field(key: "my_sort_key", sort: "score desc")
+      expect(c.sort_fields["my_sort_key"]).not_to be_nil
     end
 
     it "takes a two-arg form with a hash" do
-      config.add_sort_field("score desc, pub_date_si desc, title_si asc", :label => "relevance")
-      expect(config.sort_fields.values.find{|f| f.label == "relevance"}).to_not be_nil
+      config.add_sort_field("score desc, pub_date_si desc, title_si asc", label: "relevance")
+      expect(config.sort_fields.values.find { |f| f.label == "relevance" }).not_to be_nil
     end
 
     it "takes a SortField object" do
@@ -478,7 +491,7 @@ RSpec.describe "Blacklight::Configuration" do
         Blacklight::Configuration::SortField.new(label: "relevance",
                                                  sort: "score desc, pub_date_sort desc, title_sort asc")
       )
-      expect(config.sort_fields.values.find{|f| f.label == "relevance"}).to_not be_nil
+      expect(config.sort_fields.values.find { |f| f.label == "relevance" }).not_to be_nil
     end
 
     it "takes block form" do
@@ -487,15 +500,14 @@ RSpec.describe "Blacklight::Configuration" do
         field.sort = "score desc, pub_date_si desc, title_si asc"
       end
 
-      expect(config.sort_fields.values.find{|f| f.label == "relevance"}).to_not be_nil
-
+      expect(config.sort_fields.values.find { |f| f.label == "relevance" }).not_to be_nil
     end
   end
 
   describe "#default_search_field" do
     it "uses the field with a :default key" do
       config.add_search_field('search_field_1')
-      config.add_search_field('search_field_2', :default => true)
+      config.add_search_field('search_field_2', default: true)
 
       expect(config.default_search_field.key).to eq 'search_field_2'
     end