blacklight_advanced_search 5.3.1 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d25fc6826f0edccf6e69175e09bd622ab304e21a
-  data.tar.gz: d64e54527b54fe2bae942c363f953771ad763112
+  metadata.gz: f2ca7a7c57ac86d4f3c0dc385ef79561af1c1737
+  data.tar.gz: ed73c2995b52f221b639d0840ee2caef4f90fbb7
 SHA512:
-  metadata.gz: e8488838860c7746f5ab351ceed56ecb2fb0f5825f832a491342c1d563e137c98a01c78d12976c9358ff70653ff42dc7d85642bf6b82da6b88384f5b60c88238
-  data.tar.gz: cdb92d6f7b7f77f811211498118f0df17060d97177727427948a1e4e1ec3253b14a7bd736a68090645a71ebe6f30e75d9b641f6a8277cf326d43a93a423865c6
+  metadata.gz: d8dd353a79541d70fe0d026fb69d12c6957921c2805955533b2b0e181bd426a5ec0ce65f3e1feb06b7a1b9756a10ea364d1481f821127d0e91427ac187aad914
+  data.tar.gz: 17af4c42eb38f9649659c9667150c9a50a7bca920ce077fdaed12d90d7357be0ad3ca1aa0fd560dbd8c2ea695c340cef25d4ae9e2f342088dbb56afa484e4d7e

data/.travis.yml

@@ -6,6 +6,9 @@ rvm:
   - 2.1
   # - 1.9.3
   # - jruby-19mode
+before_install:
+  - rvm @global do gem uninstall bundler -a -x
+  - rvm @global do gem install bundler -v 1.10.6
 
 notifications:
   irc: "irc.freenode.org#blacklight"

data/README.md

@@ -64,11 +64,7 @@ If your application uses a single Solr qt request handler for all its search fie
 
 ### Expression parsing in ordinary search
 
-Turn this feature on by adding to your CatalogController definition:
-
-    self.search_params_logic << :add_advanced_parse_q_to_solr
-
-And/or, if you've switched over to configuration in SearchBuilder, then to your ./app/models/search_builder.rb:
+Turn this feature on by adding to your SearchBuilder definition:
 
     self.default_processor_chain << :add_advanced_parse_q_to_solr
 

data/VERSION

@@ -1 +1 @@
-5.3.1
+6.0.0

data/app/controllers/blacklight_advanced_search/advanced_controller.rb

@@ -9,11 +9,17 @@ class BlacklightAdvancedSearch::AdvancedController < CatalogController
   end
 
   protected
+
+  # Override to use the engine routes
+  def search_action_url options = {}
+    blacklight_advanced_search_engine.url_for(options.merge(action: 'index'))
+  end
+
   def get_advanced_search_facets
     # We want to find the facets available for the current search, but:
     # * IGNORING current query (add in facets_for_advanced_search_form filter)
     # * IGNORING current advanced search facets (remove add_advanced_search_to_solr filter)
-    response, _ = search_results(params, search_params_logic) do |search_builder|
+    response, _ = search_results(params) do |search_builder|
       search_builder.except(:add_advanced_search_to_solr).append(:facets_for_advanced_search_form)            
     end
 

data/app/views/advanced/_advanced_search_form.html.erb

@@ -5,9 +5,9 @@
     </div>
   <% end %>
 
-<%= form_tag catalog_index_path, :class => 'advanced form-horizontal', :method => :get do  %>
+<%= form_tag search_catalog_path, :class => 'advanced form-horizontal', :method => :get do  %>
 
-  <%= render_hash_as_hidden_fields(params_for_search(advanced_search_context, {})) %>
+  <%= render_hash_as_hidden_fields(search_state.params_for_search(advanced_search_context)) %>
 
   <div class="input-criteria">
 

data/app/views/advanced/_advanced_search_submit_btns.html.erb

@@ -1,12 +1,12 @@
       <div class="sort-buttons pull-left">    
         <%= label_tag(:sort, t('blacklight_advanced_search.form.sort_label'), :class => "control-label") %>
       
-        <%= select_tag(:sort, options_for_select(sort_fields, h(params[:sort])), :class => "form-control sort-select") %>
+        <%= select_tag(:sort, options_for_select(sort_fields, h(current_sort_field && current_sort_field.key)), :class => "form-control sort-select") %>
         <%= hidden_field_tag(:search_field, blacklight_config.advanced_search[:url_key]) %>
       </div>
 
       <div class="submit-buttons pull-right">
-        <%= link_to t('blacklight_advanced_search.form.start_over'), advanced_search_path, :class =>"btn btn-default advanced-search-start-over" %>
+        <%= link_to t('blacklight_advanced_search.form.start_over'), blacklight_advanced_search_engine.advanced_search_path, :class =>"btn btn-default advanced-search-start-over" %>
 
         <%= submit_tag t('blacklight_advanced_search.form.search_btn'), :class=>'btn btn-primary advanced-search-submit', :id => "advanced-search-submit" %>
-      </div>
+      </div>

data/app/views/advanced/index.html.erb

@@ -4,7 +4,7 @@
 
     <h1 class="advanced page-header">
         <%= t('blacklight_advanced_search.form.title') %>
-        <%= link_to t('blacklight_advanced_search.form.start_over'), advanced_search_path, :class =>"btn btn-default pull-right advanced-search-start-over" %>
+        <%= link_to t('blacklight_advanced_search.form.start_over'), blacklight_advanced_search_engine.advanced_search_path, :class =>"btn btn-default pull-right advanced-search-start-over" %>
     </h1>
 
     <div class="row">
@@ -18,4 +18,4 @@
 
     </div>
 
-</div>
+</div>

data/blacklight_advanced_search.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency "blacklight", "~> 5.15"
+  s.add_dependency 'blacklight', '> 6.0.0.pre', '< 7'
   s.add_dependency "parslet"
 
   s.add_development_dependency "rails"

data/config/routes.rb

@@ -1,3 +1,3 @@
-Rails.application.routes.draw do
-  get 'advanced' => 'advanced#index', :as => 'advanced_search'
+BlacklightAdvancedSearch::Engine.routes.draw do
+  get 'advanced' => 'advanced#index', as: 'advanced_search'
 end

data/lib/blacklight_advanced_search.rb

@@ -6,40 +6,44 @@ module BlacklightAdvancedSearch
   autoload :QueryParser, 'blacklight_advanced_search/advanced_query_parser'
   autoload :ParsingNestingParser, 'blacklight_advanced_search/parsing_nesting_parser'
   autoload :FilterParser, 'blacklight_advanced_search/filter_parser'
-  autoload :ParseBasicQ, 'blacklight_advanced_search/parse_basic_q'
   autoload :RedirectLegacyParamsFilter, 'blacklight_advanced_search/redirect_legacy_params_filter'
 
   require 'blacklight_advanced_search/version'
   require 'blacklight_advanced_search/engine'
-
-  # Utility method used in our solr search logic.
-  # Like Rails Hash#deep_merge, merges 2 hashes recursively, including nested Arrays and Hashes.
-  # Unlike Rails Hash#deep_merge:
-  # - will NOT merge nil values over existing ones
-  # - will NOT merge (non-FalseClass) blank values
-  # - WILL deduplicate values from arrays after merging them
-  #
-  # @param [Hash|HashWithIndifferentAccess] source_hash
-  # @param [Hash|HashWithIndifferentAccess] new_hash
-  # @return [Hash] the deeply merged hash
-  # @see Rails #deep_merge http://apidock.com/rails/v4.2.1/Hash/deep_merge
-  # @example new_hash = BlacklightAdvancedSearch.deep_merge(h1, h2)
-  def self.deep_merge(source_hash, new_hash)
-    source_hash.deep_merge(new_hash, &method(:merge_conflict_resolution))
-  end
-
-  # this one side-effects the first param
-  # @see #deep_merge
-  # @deprecated use `new_hash = BlacklightAdvancedSearch.deep_merge(h1, h2)` instead
+  
+  # Utility method used in our solr search logic. 
+  # Merges new_hash into source_hash, but will recursively
+  # merge nested arrays and hashes too; also will NOT merge nil
+  # or blank values from new_hash into source_hash, nil or blank values
+  # in new_hash will not overwrite values in source_hash. 
   def self.deep_merge!(source_hash, new_hash)
-    source_hash.deep_merge!(new_hash, &method(:merge_conflict_resolution))
-  end
+    # We used to use built-in source_hash.merge() with a block arg
+    # to customize merge behavior, but that was breaking in some
+    # versions of BL/Rails where source_hash was a kind of HashWithIndifferentAccess,
+    # and hwia is unreliable in some versions of Rails. Oh well. 
+    # https://github.com/projectblacklight/blacklight/issues/827
+
+    new_hash.each_pair do |key, new_value|
+      old = source_hash.fetch(key, nil)
 
-  # the arguments are set by what the Rails Hash.deep_merge supplies the block
-  def self.merge_conflict_resolution(_key, old, new_value)
-    return old if new_value.nil?
-    return old if new_value.respond_to?(:blank?) && new_value.blank? && !new_value.is_a?(FalseClass)
-    return old | new_value if old.is_a?(Array) && new_value.is_a?(Array)
-    new_value
-  end
+      source_hash[key] =     
+        if new_value.respond_to?(:blank) && new.blank?
+          old        
+        elsif (old.kind_of?(Hash) and new_value.kind_of?(Hash))          
+          deep_merge!(old, new_value)
+          old
+        elsif (old.kind_of?(Array) and new_value.kind_of?(Array))
+          old.concat(new_value).uniq
+        elsif new_value.nil?
+          # Allowing nil values to over-write on merge messes things up.
+          # don't set a nil value if you really want to force blank, set
+          # empty string. 
+          old
+        else
+          new_value
+        end
+    end
+    source_hash
+  end  
+  
 end

data/lib/blacklight_advanced_search/advanced_search_builder.rb

@@ -9,8 +9,8 @@ module BlacklightAdvancedSearch
       (blacklight_params[:search_field] == self.blacklight_config.advanced_search[:url_key]) || blacklight_params[:f_inclusive]
     end
 
-    # this method should get added into the search_params_logic
-    # list, in a position AFTER normal query handling (:add_query_to_solr),
+    # this method should get added into the processor chain
+    # in a position AFTER normal query handling (:add_query_to_solr),
     # so it'll overwrite that if and only if it's an advanced search.
     # adds a 'q' and 'fq's based on advanced search form input. 
     def add_advanced_search_to_solr(solr_parameters)
@@ -35,14 +35,14 @@ module BlacklightAdvancedSearch
 
     # Different versions of Parslet raise different exception classes,
     # need to figure out which one exists to rescue
-    PARSLET_FAILED_EXCEPTIONS = if defined? Parslet::UnconsumedInput
+    @@parslet_failed_exceptions = if defined? Parslet::UnconsumedInput
       [Parslet::UnconsumedInput]
     else
       [Parslet::ParseFailed]
     end
     
     
-    # This method can be included in search_params_logic to have us
+    # This method can be included in the SearchBuilder to have us
     # parse an ordinary entered :q for AND/OR/NOT and produce appropriate
     # Solr query.
     #
@@ -50,31 +50,30 @@ module BlacklightAdvancedSearch
     # parse and send it straight to solr same as if advanced_parse_q
     # were not being used. 
     def add_advanced_parse_q_to_solr(solr_parameters)
-      blacklight_params = scope.params
-
-      return if blacklight_params[:q].blank? || !blacklight_params[:q].respond_to?(:to_str)
-
-      field_def = search_field_def_for_key(blacklight_params[:search_field]) ||
-        default_search_field
-
-      # If the individual field has advanced_parse_q suppressed, punt
-      return if field_def[:advanced_parse] == false
-
-      solr_direct_params = field_def[:solr_parameters] || {}
-      solr_local_params = field_def[:solr_local_parameters] || {}
-
-      # See if we can parse it, if we can't, we're going to give up
-      # and just allow basic search, perhaps with a warning.
-      begin
-        adv_search_params = ParsingNesting::Tree.parse(blacklight_params[:q], blacklight_config.advanced_search[:query_parser]).to_single_query_params(solr_local_params)
+      unless scope.params[:q].blank?
+        field_def = search_field_def_for_key( scope.params[:search_field]) ||
+          default_search_field
+          
+                
+        # If the individual field has advanced_parse_q suppressed, punt
+        return if field_def[:advanced_parse] == false  
+          
+        solr_direct_params = field_def[:solr_parameters] || {}
+        solr_local_params = field_def[:solr_local_parameters] || {}
+        
+        # See if we can parse it, if we can't, we're going to give up
+        # and just allow basic search, perhaps with a warning.
+        begin
+          adv_search_params = ParsingNesting::Tree.parse(scope.params[:q], blacklight_config.advanced_search[:query_parser]).to_single_query_params( solr_local_params )
 
-        BlacklightAdvancedSearch.deep_merge!(solr_parameters, solr_direct_params)
-        BlacklightAdvancedSearch.deep_merge!(solr_parameters, adv_search_params)
-      rescue *PARSLET_FAILED_EXCEPTIONS => e
-        # do nothing, don't merge our input in, keep basic search
-        # optional TODO, display error message in flash here, but hard to
-        # display a good one.
-        return
+          BlacklightAdvancedSearch.deep_merge!(solr_parameters, solr_direct_params)
+          BlacklightAdvancedSearch.deep_merge!(solr_parameters, adv_search_params)        
+        rescue *@@parslet_failed_exceptions => e
+          # do nothing, don't merge our input in, keep basic search
+          # optional TODO, display error message in flash here, but hard to 
+          # display a good one. 
+          return
+        end
       end
     end
 

data/lib/blacklight_advanced_search/controller.rb

@@ -1,7 +1,7 @@
 require 'blacklight_advanced_search/parsing_nesting_parser'
 
 # This module gets included into CatalogController, or another SearchHelper
-# includer, to add behavior into search_params_logic.
+# includer, to add advanced search behavior
 module BlacklightAdvancedSearch::Controller
   extend ActiveSupport::Concern
 
@@ -13,21 +13,6 @@ module BlacklightAdvancedSearch::Controller
     blacklight_config.advanced_search[:query_parser] ||= 'dismax'
     blacklight_config.advanced_search[:form_solr_parameters] ||= {}
 
-    if respond_to? :search_params_logic
-      # Parse app URL params used for adv searches
-      self.search_params_logic += [:add_advanced_search_to_solr]
-    end
-
-    # Silence deprecations that occur when this code is executed before blacklight
-    # has generated a SearchBuilder.
-    Deprecation.silence Blacklight::Configuration do
-      unless blacklight_config.search_builder_class.include? BlacklightAdvancedSearch::AdvancedSearchBuilder
-        blacklight_config.search_builder_class.send(:include,
-                BlacklightAdvancedSearch::AdvancedSearchBuilder
-            )
-      end
-    end
-
     # Display advanced search constraints properly
     helper BlacklightAdvancedSearch::RenderConstraintsOverride
     helper BlacklightAdvancedSearch::CatalogHelperOverride

data/lib/generators/blacklight_advanced_search/install_generator.rb

@@ -7,15 +7,27 @@ module BlacklightAdvancedSearch
     def inject_asset_requires
       generate "blacklight_advanced_search:assets"
     end
-    
-    
+
+    def inject_search_builder
+      inject_into_file 'app/models/search_builder.rb', after: /include Blacklight::Solr::SearchBuilderBehavior.*$/ do
+        "\n  include BlacklightAdvancedSearch::AdvancedSearchBuilder" \
+        "\n  self.default_processor_chain += [:add_advanced_parse_q_to_solr, :add_advanced_search_to_solr]"
+      end
+    end
+
+    def inject_routes
+      inject_into_file 'config/routes.rb', after: /mount Blacklight::Engine.*$/ do
+        "\n  mount BlacklightAdvancedSearch::Engine => '/'\n"
+      end
+    end
+
     def install_localized_search_form
       if options[:force] or yes?("Install local search form with advanced link? (y/N)", :green)
         # We're going to copy the search from from actual currently loaded
         # Blacklight into local app as custom local override -- but add our link at the end too. 
         source_file = File.read(File.join(Blacklight.root, "app/views/catalog/_search_form.html.erb"))
 
-        new_file_contents = source_file + "\n\n<%= link_to 'More options', advanced_search_path(params.except(:controller, :action)), :class=>'advanced_search'%>"
+        new_file_contents = source_file + "\n\n<%= link_to 'More options', blacklight_advanced_search_engine.advanced_search_path(params.except(:controller, :action)), class: 'advanced_search'%>"
 
         create_file("app/views/catalog/_search_form.html.erb", new_file_contents)      
       end

data/spec/lib/advanced_search_builder_spec.rb

@@ -49,23 +49,6 @@ describe BlacklightAdvancedSearch::AdvancedSearchBuilder do
           obj.add_advanced_parse_q_to_solr(solr_params)
           expect(solr_params[:q]).to eq(unparseable_q)
         end
-
-        describe 'when parslet fails' do
-          let(:failing_q) { ")(" }
-          let(:params) { double("params", params: { :q => failing_q }) }
-          it 'does not return the query that could not be parsed' do
-            obj.add_advanced_parse_q_to_solr(solr_params)
-            expect(solr_params[:q]).to be_nil
-          end
-        end
-
-        describe 'when `q` is a hash' do
-          let(:params) { double("params", params: { q: { id: ['a'] } }) }
-          it 'does not return the query that could not be parsed' do
-            obj.add_advanced_parse_q_to_solr(solr_params)
-            expect(solr_params[:q]).to be_nil
-          end
-        end
       end
 
       context "when advanced_parse is false" do

data/spec/lib/deep_merge_spec.rb

@@ -1,123 +1,45 @@
 require 'spec_helper'
 
-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' }
+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"}
     }
-  end
-  let(:hash_Y) do
-    {
-      'a' => 'NEW A',
-      'c' => 'NEW C',
-      'array1' => [3, 4],
-      'hash1'  => { 'array' => [2], 'b' => 'NEW B' }
-    }
-  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 '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
+    BlacklightAdvancedSearch.deep_merge!(@ahash, {
+      "a" => "NEW A",
+      "array1" => [3, 4],
+      "hash1"  => {
+        "array" => [2],
+        "b" => "NEW B"
+      },
+      "c" => "NEW C"
+    })
   end
 
-  describe Hash do
-    it_behaves_like 'Mergable Parameters' do
-      let(:hash_x) { hash_X }
-      let(:hash_y) { hash_Y }
-    end
-  end
 
-  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
+  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
 
-  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 "adds new content" do
+    expect(@ahash["c"]).to eq("NEW C")
+  end
 
-    it_behaves_like 'Mergable Parameters' do
-      let(:hash_x) { hash_X.with_indifferent_access }
-      let(:hash_y) { hash_Y }
-    end
+  it "merges an array" do
+    expect(@ahash["array1"]).to eq([1,2,3,4])
   end
 
-  # 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
+  it "merges a hash, recursive like" do
+    expect(@ahash["hash1"]).to eq({
+      "a" => "a",
+      "array" => [1,2],
+      "b" => "NEW B"
+    })
   end
     
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: blacklight_advanced_search
 version: !ruby/object:Gem::Version
-  version: 5.3.1
+  version: 6.0.0
 platform: ruby
 authors:
 - Jonathan Rochkind
@@ -9,22 +9,28 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-08 00:00:00.000000000 Z
+date: 2016-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: blacklight
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 6.0.0.pre
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.15'
+        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 6.0.0.pre
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.15'
+        version: '7'
 - !ruby/object:Gem::Dependency
   name: parslet
   requirement: !ruby/object:Gem::Requirement
@@ -150,7 +156,6 @@ files:
 - lib/blacklight_advanced_search/controller.rb
 - lib/blacklight_advanced_search/engine.rb
 - lib/blacklight_advanced_search/filter_parser.rb
-- lib/blacklight_advanced_search/parse_basic_q.rb
 - lib/blacklight_advanced_search/parsing_nesting_parser.rb
 - lib/blacklight_advanced_search/redirect_legacy_params_filter.rb
 - lib/blacklight_advanced_search/render_constraints_override.rb
@@ -170,7 +175,6 @@ files:
 - spec/lib/filter_parser_spec.rb
 - spec/parsing_nesting/build_tree_spec.rb
 - spec/parsing_nesting/consuming_spec.rb
-- spec/parsing_nesting/parse_basic_q_spec.rb
 - spec/parsing_nesting/to_solr_spec.rb
 - spec/rcov.opts
 - spec/spec.opts
@@ -196,7 +200,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: blacklight
-rubygems_version: 2.6.11
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Blacklight Advanced Search plugin
@@ -209,7 +213,6 @@ test_files:
 - spec/lib/filter_parser_spec.rb
 - spec/parsing_nesting/build_tree_spec.rb
 - spec/parsing_nesting/consuming_spec.rb
-- spec/parsing_nesting/parse_basic_q_spec.rb
 - spec/parsing_nesting/to_solr_spec.rb
 - spec/rcov.opts
 - spec/spec.opts

data/lib/blacklight_advanced_search/parse_basic_q.rb

@@ -1,73 +0,0 @@
-require 'parslet'
-require 'parsing_nesting/tree'
-
-# A solr search logic mix-in to CatalogController. 
-# If mixed-in, adds Advanced Search parsing behavior
-# to queries entered on basic/standard/simple search
-# form too, for boolean expressions. 
-#
-#  simply:
-#    include BlacklightAdvancedSearch::ParseBasicQ
-# in your CatalogController
-module BlacklightAdvancedSearch::ParseBasicQ
-  extend ActiveSupport::Concern
-  extend Deprecation
-
-  self.deprecation_horizon = 'blacklight_advanced_search 6.0'
-
-  include Blacklight::SearchFields
-  
-  included do
-    self.search_params_logic += [:add_advanced_parse_q_to_solr]
-  end
-
-  # Different versions of Parslet raise different exception classes,
-  # need to figure out which one exists to rescue
-  PARSLET_FAILED_EXCEPTIONS = if defined? Parslet::UnconsumedInput
-    [Parslet::UnconsumedInput]
-  else
-    [Parslet::ParseFailed]
-  end
-  
-  
-  # This method can be included in search_params_logic to have us
-  # parse an ordinary entered :q for AND/OR/NOT and produce appropriate
-  # Solr query. Note that it is NOT included in search_params_logic
-  # by default when this module is included, because it is optional behavior.
-  # BlacklightAdvancedSearch init code will add it to CatalogController
-  # if it's configured to do so. You can of course add it yourself
-  # manually too. 
-  #
-  # Note: For syntactically invalid input, we'll just skip the adv
-  # parse and send it straight to solr same as if advanced_parse_q
-  # were not being used. 
-  def add_advanced_parse_q_to_solr(solr_parameters, req_params = params)
-    unless req_params[:q].blank?
-      field_def = search_field_def_for_key( req_params[:search_field]) ||
-        default_search_field
-        
-              
-      # If the individual field has advanced_parse_q suppressed, punt
-      return if field_def[:advanced_parse] == false  
-        
-      solr_direct_params = field_def[:solr_parameters] || {}
-      solr_local_params = field_def[:solr_local_parameters] || {}
-      
-      # See if we can parse it, if we can't, we're going to give up
-      # and just allow basic search, perhaps with a warning.
-      begin
-        adv_search_params = ParsingNesting::Tree.parse(req_params[:q], blacklight_config.advanced_search[:query_parser]).to_single_query_params( solr_local_params )
-
-        BlacklightAdvancedSearch.deep_merge!(solr_parameters, solr_direct_params)
-        BlacklightAdvancedSearch.deep_merge!(solr_parameters, adv_search_params)        
-      rescue *PARSLET_FAILED_EXCEPTIONS => e
-        # do nothing, don't merge our input in, keep basic search
-        # optional TODO, display error message in flash here, but hard to 
-        # display a good one. 
-        return
-      end
-    end
-  end
-  deprecation_deprecate add_advanced_parse_q_to_solr: "use AdvancedSearchBuilder.add_advanced_parse_q_to_solr"
-
-end

data/spec/parsing_nesting/parse_basic_q_spec.rb

@@ -1,86 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe "NestingParser" do
-
-  # Our ParseBasicQ mixin assumes a SolrHelper context. 
-  # SolrHelper is a controller layer mixin, which depends
-  # on being mixed into a class which has #params (from Rails)
-  # and #blacklight_config
-  #
-  # This technique of testing is copied from Blacklight solr_helper_spec.rb
-  #
-  # It gets kind of a mess of dependencies, sorry. 
-  class ParseBasicQTestClass
-    cattr_accessor :blacklight_config
-
-    include Blacklight::SearchHelper
-    
-    include BlacklightAdvancedSearch::ParseBasicQ
-
-
-    def initialize blacklight_config
-      self.blacklight_config = blacklight_config
-    end
-
-    def params
-      {}
-    end
-
-    def logger
-      Rails.logger
-    end
-  end
-
-  describe "basic functionality" do
-    before do
-      @blacklight_config = Blacklight::Configuration.new do |config|
-        config.advanced_search = {
-
-        }
-
-        config.add_search_field "all_fields" do |field|
-          
-        end
-
-        config.add_search_field "special_field" do |field|
-          field.advanced_parse = false
-        end
-      end
-      @obj = ParseBasicQTestClass.new @blacklight_config 
-    end
-
-    it "catches a simple example" do
-      expect(Deprecation).to receive(:warn)
-      solr_params = {}
-      @obj.add_advanced_parse_q_to_solr(solr_params, :q => "one two AND three OR four") 
-
-      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. 
-      expect(solr_params[:q]).to start_with("_query_:")
-    end
-
-    it "passes through an unparseable example" do
-      expect(Deprecation).to receive(:warn)
-      solr_params = {}
-      unparseable_q = "foo bar\'s AND"
-      @obj.add_advanced_parse_q_to_solr(solr_params, :q => unparseable_q)
-
-      expect(solr_params[:q]).to eq(unparseable_q)
-    end
-
-    it "ignores field with advanced_parse=false" do
-      expect(Deprecation).to receive(:warn)
-      solr_params = {}
-      original_q = "one two AND three OR four"
-      @obj.add_advanced_parse_q_to_solr(solr_params, 
-        :search_field => "special_field",
-        :q => original_q
-      )
-
-      expect(solr_params).not_to have_key(:q)
-    end
-
-  end
-  
-end