blacklight_advanced_search 6.0.2 → 6.1.0

data/spec/features/blacklight_advanced_search_form_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe "Blacklight Advanced Search Form" do
   before(:all) do
     AdvancedController.copy_blacklight_config_from(CatalogController)

data/spec/helpers/advanced_helper_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe AdvancedHelper do
   describe '#advanced_search_facet_partial_name' do
     let(:field) { double(name: "field_name") }

data/spec/integration/blacklight_stub_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe 'Blacklight Test Application' do
   it "should have a Blacklight module" do
     expect(Blacklight).to be_a_kind_of(Module)

data/spec/lib/advanced_search_builder_spec.rb

@@ -1,12 +1,8 @@
-require 'spec_helper'
-
 describe BlacklightAdvancedSearch::AdvancedSearchBuilder do
-
   describe "#add_advanced_parse_q_to_solr" do
-
     let(:blacklight_config) do
       Blacklight::Configuration.new do |config|
-        config.advanced_search = { }
+        config.advanced_search = {}
         config.add_search_field "all_fields"
         config.add_search_field "special_field" do |field|
           field.advanced_parse = false
@@ -19,7 +15,7 @@ describe BlacklightAdvancedSearch::AdvancedSearchBuilder do
         cattr_accessor :blacklight_config
         include Blacklight::SearchHelper
         include BlacklightAdvancedSearch::AdvancedSearchBuilder
-        def initialize blacklight_config
+        def initialize(blacklight_config)
           self.blacklight_config = blacklight_config
         end
       end
@@ -30,20 +26,20 @@ describe BlacklightAdvancedSearch::AdvancedSearchBuilder do
       let(:solr_params) { {} }
 
       describe "a simple example" do
-        let(:params) { double("params", params: {:q => "one two AND three OR four"} ) }
+        let(:params) { double("params", params: { :q => "one two AND three OR four" }) }
         before { allow(obj).to receive(:scope).and_return(params) }
         it "catches the query" do
-          obj.add_advanced_parse_q_to_solr(solr_params) 
+          obj.add_advanced_parse_q_to_solr(solr_params)
           expect(solr_params[:defType]).to eq("lucene")
           # We're not testing succesful parsing here, just that it's doing
-          # something that looks like we expect with subqueries. 
+          # something that looks like we expect with subqueries.
           expect(solr_params[:q]).to start_with("_query_:")
         end
       end
 
       describe "an unparseable example" do
         let(:unparseable_q) { "foo bar\'s AND" }
-        let(:params) { double("params", params: {:q => unparseable_q} ) }
+        let(:params) { double("params", params: { :q => unparseable_q }) }
         before { allow(obj).to receive(:scope).and_return(params) }
         it "passes through" do
           obj.add_advanced_parse_q_to_solr(solr_params)
@@ -52,16 +48,13 @@ describe BlacklightAdvancedSearch::AdvancedSearchBuilder do
       end
 
       context "when advanced_parse is false" do
-        let(:params) { double("params", params: { :search_field => "special_field", :q => "one two AND three OR four" } ) }
+        let(:params) { double("params", params: { :search_field => "special_field", :q => "one two AND three OR four" }) }
         before { allow(obj).to receive(:scope).and_return(params) }
         it "ignores fields" do
           obj.add_advanced_parse_q_to_solr(solr_params)
           expect(solr_params).not_to have_key(:q)
         end
       end
-
     end
-
   end
-
 end

data/spec/lib/blacklight_advanced_search/render_constraints_override_spec.rb

@@ -0,0 +1,39 @@
+describe BlacklightAdvancedSearch::RenderConstraintsOverride, type: :helper do
+  let(:blacklight_config) do
+    Blacklight::Configuration.new do |config|
+      config.add_facet_field 'type'
+    end
+  end
+
+  let(:advanced_query) do
+    BlacklightAdvancedSearch::QueryParser.new(params, blacklight_config)
+  end
+
+  describe "#render_constraints_filters" do
+    before do
+      allow(helper).to receive(:blacklight_config).and_return(blacklight_config)
+      allow(helper).to receive(:advanced_query).and_return(advanced_query)
+      allow(helper).to receive(:search_action_path) do |*args|
+        search_catalog_path(*args)
+      end
+    end
+
+    subject(:rendered) { helper.render_constraints_filters({}) }
+
+    context 'with an array of facet params' do
+      let(:params) { ActionController::Parameters.new f_inclusive: { 'type' => ['a'] } }
+
+      it "renders nothing" do
+        expect(rendered).to have_text 'Remove constraint Type: a'
+      end
+    end
+
+    context 'with scalar facet limit params' do
+      let(:params) { ActionController::Parameters.new f_inclusive: { 'type' => 'a' } }
+
+      it "renders the scalar value" do
+        expect(rendered).to have_text 'Remove constraint Type: a'
+      end
+    end
+  end
+end

data/spec/lib/deep_merge_spec.rb

@@ -1,45 +1,120 @@
-require 'spec_helper'
-
-describe "BlacklightAdvancedSearch#deep_merge!" do
-  before do
-    @ahash = {"a" => "a", "b" => "b", 
-            "array1" => [1,2], "array2" => [3,4],
-            "hash1"  => {"a" => "a", "array" => [1], "b" => "b"},
-            "hash2"  => {"a2" => "a2", "array2" => [12], "b2" => "b2"}
+describe 'BlacklightAdvancedSearch#deep_merge' do
+  let(:hash_X) do
+    {
+      'a' => 'a',
+      'b' => 'b',
+      'array1' => [1, 2],
+      'array2' => [3, 4],
+      'hash1'  => { 'a' => 'a', 'array' => [1], 'b' => 'b' },
+      'hash2'  => { 'a2' => 'a2', 'array2' => [12], 'b2' => 'b2' }
+    }
+  end
+  let(:hash_Y) do
+    {
+      'a' => 'NEW A',
+      'c' => 'NEW C',
+      'array1' => [3, 4],
+      'hash1'  => { 'array' => [2], 'b' => 'NEW B' }
     }
-
-    BlacklightAdvancedSearch.deep_merge!(@ahash, {
-      "a" => "NEW A",
-      "array1" => [3, 4],
-      "hash1"  => {
-        "array" => [2],
-        "b" => "NEW B"
-      },
-      "c" => "NEW C"
-    })
   end
+  let(:ahash) do
+    BlacklightAdvancedSearch.deep_merge(hash_x, hash_y)
+  end
+
+  RSpec.shared_examples 'Mergable Parameters' do # this name referenced below
+    it 'does not modify the param hashes' do
+      dup_x = hash_x.dup
+      dup_y = hash_y.dup
+      expect(ahash).not_to eq hash_x # this was the old behavior
+      expect(dup_x).to eq hash_x
+      expect(dup_y).to eq hash_y
+    end
+
+    it 'leaves un-collided content alone' do
+      expect(ahash['b']).to eq('b')
+      expect(ahash['array2']).to eq([3, 4])
+      expect(ahash['hash2']).to eq('a2' => 'a2', 'array2' => [12], 'b2' => 'b2')
+    end
+
+    it 'adds new content' do
+      expect(ahash['c']).to eq('NEW C')
+    end
+
+    it 'merges a hash, recursive like' do
+      expect(ahash['hash1']).to eq('a' => 'a', 'array' => [1, 2], 'b' => 'NEW B')
+    end
+
+    it 'merges boolean values (false)' do
+      expect(BlacklightAdvancedSearch.deep_merge({ a: false }, a: true)).to eq(a: true)
+      expect(BlacklightAdvancedSearch.deep_merge({ a: true }, a: false)).to eq(a: false)
+    end
 
+    it 'does not merge nil values over existing keys' do
+      expect(BlacklightAdvancedSearch.deep_merge({ a: 1 }, a: nil)).to eq(a: 1)
+    end
 
-  it "leaves un-collided content alone" do
-    expect(@ahash["b"]).to eq("b")
-    expect(@ahash["array2"]).to eq([3,4])
-    expect(@ahash["hash2"]).to eq({"a2" => "a2", "array2" => [12], "b2" => "b2"})
+    it 'does merge nil values when the key is not yet present' do
+      expect(BlacklightAdvancedSearch.deep_merge({}, a: nil)).to eq(a: nil)
+    end
+
+    it 'does not merge empty strings over existing keys' do
+      expect(BlacklightAdvancedSearch.deep_merge({ a: 1 }, a: '')).to eq(a: 1)
+      expect(BlacklightAdvancedSearch.deep_merge({ a: nil }, a: '')).to eq(a: nil)
+    end
+
+    it 'does not merge empty strings when the key is not yet present' do
+      expect(BlacklightAdvancedSearch.deep_merge({}, a: '')).to eq(a: '')
+    end
+
+    context 'Arrays' do
+      it 'merges an array' do
+        expect(ahash['array1']).to eq([1, 2, 3, 4])
+      end
+
+      it 'collapse to uniq values when merging' do
+        expect(BlacklightAdvancedSearch.deep_merge({ a: [1, 1, 2, 1] }, a: [3, 2])).to eq(a: [1, 2, 3])
+      end
+
+      it 'does not collapse to uniq values if not merging' do
+        expect(BlacklightAdvancedSearch.deep_merge({ a: [1, 1, 2, 1] }, a: [])).to eq(a: [1, 1, 2, 1])
+      end
+    end
+  end
+
+  describe Hash do
+    it_behaves_like 'Mergable Parameters' do
+      let(:hash_x) { hash_X }
+      let(:hash_y) { hash_Y }
+    end
   end
 
-  it "adds new content" do
-    expect(@ahash["c"]).to eq("NEW C")
+  describe HashWithIndifferentAccess do
+    it_behaves_like 'Mergable Parameters' do
+      let(:hash_x) { hash_X.with_indifferent_access }
+      let(:hash_y) { hash_Y.with_indifferent_access }
+    end
   end
 
-  it "merges an array" do
-    expect(@ahash["array1"]).to eq([1,2,3,4])
+  describe 'Mixed Hash and HWIA' do
+    it_behaves_like 'Mergable Parameters' do
+      let(:hash_x) { hash_X }
+      let(:hash_y) { hash_Y.with_indifferent_access }
+    end
+
+    it_behaves_like 'Mergable Parameters' do
+      let(:hash_x) { hash_X.with_indifferent_access }
+      let(:hash_y) { hash_Y }
+    end
   end
 
-  it "merges a hash, recursive like" do
-    expect(@ahash["hash1"]).to eq({
-      "a" => "a",
-      "array" => [1,2],
-      "b" => "NEW B"
-    })
+  # from http://apidock.com/rails/v4.2.1/Hash/deep_merge
+  describe 'reference example' do
+    it 'gives the same result as Rails Hash .deep_merge' do
+      h1 = { a: true, b: { c: [1, 2, 3] } }
+      h2 = { a: false, b: { x: [3, 4, 5] } }
+      merged = { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+      expect(h1.deep_merge(h2)).to eq(merged)
+      expect(BlacklightAdvancedSearch.deep_merge(h1, h2)).to eq(merged)
+    end
   end
-    
-end
+end

data/spec/lib/filter_parser_spec.rb

@@ -1,28 +1,22 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
 def setFilters(f)
   @filters = f
 end
 
+## These should be reworked, but attr_reader actually breaks it.
+# rubocop:disable Style/TrivialAccessors
 def filters
   @filters
 end
 
-
 describe "BlacklightAdvancedSearch::FilterParser" do
   include BlacklightAdvancedSearch::FilterParser
-  
+
   describe "filter processing" do
     it "should generate an appropriate fq param" do
-      setFilters(:format => ["Book", "Thesis"], :location=>["Online", "Library"])
-
+      setFilters(:format => %w(Book Thesis), :location => %w(Online Library))
       fq_params = generate_solr_fq
-
-      expect(fq_params.find {|a| a =~ /format\:\((\"Book\"|\"Thesis\") +OR +(\"Thesis\"|\"Book\")/}).not_to be_nil
-
-      expect(fq_params.find {|a| a =~ /location\:\((\"Library\"|\"Online\") +OR +(\"Library\"|\"Online\")/}).not_to be_nil
-      
-
-    end    
+      expect(fq_params.find { |a| a =~ /format\:\((\"Book\"|\"Thesis\") +OR +(\"Thesis\"|\"Book\")/ }).not_to be_nil
+      expect(fq_params.find { |a| a =~ /location\:\((\"Library\"|\"Online\") +OR +(\"Library\"|\"Online\")/ }).not_to be_nil
+    end
   end
-end
+end

data/spec/parsing_nesting/build_tree_spec.rb

@@ -1,58 +1,57 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
 require 'parsing_nesting/grammar'
 require 'parsing_nesting/tree'
 
-
 module ParseTreeSpecHelper
   include ParsingNesting::Tree
-  
+
   def parse(s)
     ParsingNesting::Tree.parse(s)
   end
-  
-  # for things expected to be a one-element list, 
+
+  # for things expected to be a one-element list,
   # make sure they are and return the element
   def parse_one_element(s)
     l = parse(s)
-    expect(l).to be_kind_of( List )
+    expect(l).to be_kind_of(List)
     expect(l.list.length).to eq(1)
-    return l.list.first
+    l.list.first
   end
-  
+
   def should_be_and_list(graph)
-    expect(graph).to be_kind_of( AndList )
+    expect(graph).to be_kind_of(AndList)
     yield graph.list if block_given?
   end
-  
+
   def should_be_list(graph)
-    expect(graph).to be_kind_of( List)
+    expect(graph).to be_kind_of(List)
     yield graph.list if block_given?
   end
-  
+
   def should_be_or_list(graph)
-    expect(graph).to be_kind_of( OrList )
+    expect(graph).to be_kind_of(OrList)
     yield graph.list if block_given?
   end
-  
+
   def should_be_term(graph, value)
-    expect(graph).to be_kind_of( Term )
+    expect(graph).to be_kind_of(Term)
     expect(graph.value).to eq(value)
   end
-  
+
   def should_be_phrase(graph, value)
-    expect(graph).to be_kind_of( Phrase )
+    expect(graph).to be_kind_of(Phrase)
     expect(graph.value).to eq(value)
   end
-  
+
   def should_be_mandatory(graph)
     expect(graph).to be_kind_of(MandatoryClause)
     yield graph.operand if block_given?
   end
+
   def should_be_excluded(graph)
     expect(graph).to be_kind_of(ExcludedClause)
     yield graph.operand if block_given?
   end
+
   def should_be_not_expression(graph)
     expect(graph).to be_kind_of(NotExpression)
     yield graph.operand if block_given?
@@ -60,38 +59,37 @@ module ParseTreeSpecHelper
 end
 
 describe "NestingParser" do
- describe "Building an Object parse tree" do
+  describe "Building an Object parse tree" do
     include ParseTreeSpecHelper
-        
-    
+
     it "should build for term list" do
-      should_be_list parse("one two three")  do |list|
+      should_be_list parse("one two three") do |list|
         expect(list.length).to eq(3)
         should_be_term list[0], "one"
         should_be_term list[1], "two"
-        should_be_term list[2], "three"        
-      end            
+        should_be_term list[2], "three"
+      end
     end
-    
+
     it "should build AND list" do
       should_be_and_list parse_one_element("one AND two AND three") do |list|
         expect(list.length).to eq(3)
-        
+
         should_be_term list[0], "one"
         should_be_term list[1], "two"
-        should_be_term list[2], "three"        
+        should_be_term list[2], "three"
       end
     end
-    
+
     it "should build OR list" do
-      should_be_or_list parse_one_element("one OR two OR three") do |list|        
+      should_be_or_list parse_one_element("one OR two OR three") do |list|
         expect(list.length).to eq(3)
         should_be_term list[0], "one"
         should_be_term list[1], "two"
-        should_be_term list[2], "three"                  
-      end                  
+        should_be_term list[2], "three"
+      end
     end
-    
+
     it "allows AND list of lists" do
       should_be_and_list parse_one_element('(one two) AND (blue yellow)') do |and_list|
         expect(and_list.length).to eq(2)
@@ -100,125 +98,123 @@ describe "NestingParser" do
           should_be_term(list[1], "two")
         end
         should_be_list and_list[1]
-      end      
+      end
     end
-    
+
     it "should build for mandatory and excluded" do
       should_be_list parse("+one -two") do |list|
         expect(list.length).to eq(2)
-        
+
         should_be_mandatory list[0] do |operand|
           should_be_term(operand, "one")
         end
-        
+
         should_be_excluded list[1] do |operand|
           should_be_term(operand, "two")
         end
-      end            
+      end
     end
-    
+
     it "should build phrases" do
       should_be_list parse('"quick brown" +"jumps over" -"lazy dog"') do |list|
         expect(list.length).to eq(3)
-        
+
         should_be_phrase(list[0], "quick brown")
-      
+
         should_be_mandatory(list[1]) do |operand|
           should_be_phrase(operand, "jumps over")
-        end  
+        end
       end
     end
-    
+
     it "should leave phrase literals literal, including weird chars" do
-      phrase_content = "foo+bar -i: '(baz" 
-      should_be_phrase parse_one_element("\"#{phrase_content}\""), phrase_content      
+      phrase_content = "foo+bar -i: '(baz"
+      should_be_phrase parse_one_element("\"#{phrase_content}\""), phrase_content
     end
-    
+
     it "should build for NOT on term" do
       should_be_list parse("one two three NOT four") do |list|
         should_be_not_expression list[3] do |operand|
           should_be_term(operand, "four")
         end
-      end            
+      end
     end
-    
+
     it "should build for NOT on phrase" do
       should_be_list parse('one two three NOT "quick brown"') do |list|
         should_be_not_expression list[3] do |operand|
           should_be_phrase(operand, "quick brown")
         end
-      end      
+      end
     end
-    
+
     it "should build NOT on expression" do
       should_be_list parse('one two NOT (blue OR yellow)') do |list|
         should_be_not_expression list[2] do |operand|
           should_be_or_list(operand)
         end
-      end            
+      end
     end
-    
+
     it "should build NOT preceded by binary op" do
       should_be_or_list parse_one_element('one OR NOT two') do |list|
         should_be_not_expression list[1] do |operand|
           should_be_term(operand, "two")
         end
-      end              
+      end
     end
-      
-    
+
     it "should bind OR more tightly than AND" do
-      should_be_and_list parse_one_element("grey AND big OR small AND tail") do |list|        
+      should_be_and_list parse_one_element("grey AND big OR small AND tail") do |list|
         expect(list.length).to eq(3)
-        
+
         should_be_term list[0], "grey"
-        
+
         should_be_or_list list[1] do |or_list|
-            expect(or_list.length).to eq(2)
-            should_be_term or_list[0], "big"
-            should_be_term or_list[1], "small"         
+          expect(or_list.length).to eq(2)
+          should_be_term or_list[0], "big"
+          should_be_term or_list[1], "small"
         end
-        
+
         should_be_term list[2], "tail"
-      end      
+      end
     end
-    
-    it "should parse AND'd lists" do      
-      should_be_and_list parse_one_element("(foo bar one AND two) AND (three four ten OR twelve)") do |list|                
-        expect(list.length).to eq(2)        
-        
+
+    it "should parse AND'd lists" do
+      should_be_and_list parse_one_element("(foo bar one AND two) AND (three four ten OR twelve)") do |list|
+        expect(list.length).to eq(2)
+
         should_be_list(list[0]) do |first_half|
           expect(first_half[0].value).to eq('foo')
           expect(first_half[1].value).to eq("bar")
-          should_be_and_list(first_half[2])          
+          should_be_and_list(first_half[2])
         end
-        
+
         should_be_list(list[1]) do |second_half|
           expect(second_half[0].value).to eq("three")
           expect(second_half[1].value).to eq("four")
-          should_be_or_list second_half[2]          
+          should_be_or_list second_half[2]
         end
       end
     end
-    
+
     it "should build for a crazy complicated one" do
       should_be_list parse("mark +twain AND huck OR fun OR ((jim AND river) AND (red -dogs))") do |list|
         should_be_term list[0], "mark"
         should_be_and_list list[1] do |and_list|
-          
           should_be_mandatory and_list[0] do |operand|
             should_be_term operand, "twain"
           end
-                                        
+
           should_be_or_list and_list[1] do |or_list|
             should_be_term or_list[0], "huck"
             should_be_term or_list[1], "fun"
-            
+
             should_be_and_list or_list[2] do |and_list|
               expect(and_list.length).to eq(2)
-              
+
               should_be_and_list and_list[0]
-              
+
               should_be_list and_list[1] do |terms|
                 should_be_term terms[0], "red"
                 should_be_excluded terms[1] do |operand|
@@ -226,13 +222,9 @@ describe "NestingParser" do
                 end
               end
             end
-            
           end
         end
       end
     end
-    
   end
 end
-
-