blacklight_advanced_search 6.4.1 → 8.0.0.alpha2

data/README.md

@@ -1,4 +1,4 @@
-This is an advanced search plugin for Blacklight ( http://www.projectblacklight.org ).  
+This is an advanced search plugin for Blacklight ( http://www.projectblacklight.org ).
 
 [![Gem Version](https://badge.fury.io/rb/blacklight_advanced_search.svg)](http://badge.fury.io/rb/blacklight_advanced_search)  [![Build Status](https://travis-ci.org/projectblacklight/blacklight_advanced_search.svg)](https://travis-ci.org/projectblacklight/blacklight_advanced_search)
 
@@ -14,15 +14,15 @@ work with which versions of `blacklight`. Some notes:
      facet selections, from the advanced form. If you'd like to keep old-style possibly
      bookmarked URLs working, by redirecting to new format, add this to your
      `CatalogController`:
-      
+
             before_filter BlacklightAdvancedSearch::RedirectLegacyParamsFilter, :only => :index
 
-* version 2.2 of `blacklight_advanced_search` should work with `blacklight` 4.x. 
+* version 2.2 of `blacklight_advanced_search` should work with `blacklight` 4.x.
 * versions `1.2.*` of Advanced Search plugin can work with blacklight 3.2.2 through latest 3.2.x
-* 1.2.0 was an aborted version, don't use it, if you did, re-do your configuration according to current instructions and delete any local ./app/controllers/advanced_controller.rb file. 
+* 1.2.0 was an aborted version, don't use it, if you did, re-do your configuration according to current instructions and delete any local ./app/controllers/advanced_controller.rb file.
 * advanced search 1.1.x versions will work with Blacklights 3.0.x through 3.1.x
-* advanced search plugin latest 0.X.X version will work with Blacklight 2.9/Rails2. 
-* Older tagged versions of Advanced Search may work with even older BL. 
+* advanced search plugin latest 0.X.X version will work with Blacklight 2.9/Rails2.
+* Older tagged versions of Advanced Search may work with even older BL.
 
 ## Installation
 
@@ -37,24 +37,24 @@ then run 'bundle install'.  Then run:
     rails generate blacklight_advanced_search
 
 * The 'generate' command will install 'require' statements for the plugin's assets into your application's application.js/application.css asset pipeline files
-* And it can optionally install a localized search form with a link to advanced search. If you've already localized your search form you'll want to do this manually instead. 
+* And it can optionally install a localized search form with a link to advanced search. If you've already localized your search form you'll want to do this manually instead.
 
-You may want turn to enable AND/OR/NOT parsing even in ordinary search, this is not on by default.  See "Expression parsing in ordinary search" below. 
+You may want turn to enable AND/OR/NOT parsing even in ordinary search, this is not on by default.  See "Expression parsing in ordinary search" below.
 
 ## Accessing
- 
+
 The advanced search form will be available in your app at /advanced, and in your app using
-routing helper `advanced_search_path`. 
+routing helper `advanced_search_path`.
 
     advanced_search_path
-  
+
 You can also send the advanced search form url parameters representing a search, to have the form add on additional 'advanced' criteria to the search.  For example:
 
     advanced_search_path( params )
-   
-By default there won't be any links in your application to the search form. If you've heavily customized your app, you can put them wherever you want as above. 
 
-However, especially if your app isn't much customized, the optional installer can write a localized Blacklight search form into your application with a 'more options' link to advanced. You may need to adjust your styles to make room for the new link, depending on what you've done with your app. 
+By default there won't be any links in your application to the search form. If you've heavily customized your app, you can put them wherever you want as above.
+
+However, especially if your app isn't much customized, the optional installer can write a localized Blacklight search form into your application with a 'more options' link to advanced. You may need to adjust your styles to make room for the new link, depending on what you've done with your app.
 
 
 ## Configuration
@@ -68,7 +68,7 @@ Turn this feature on by adding to your SearchBuilder definition:
 
     self.default_processor_chain << :add_advanced_parse_q_to_solr
 
-This will intercept queries entered in ordinary Blacklight search interface, and parse them for AND/OR/NOT (and parens), producing appropriate Solr query. This allows single-field boolean expressions to be entered in ordinary search, providing a consistent experience with advanced search. 
+This will intercept queries entered in ordinary Blacklight search interface, and parse them for AND/OR/NOT (and parens), producing appropriate Solr query. This allows single-field boolean expressions to be entered in ordinary search, providing a consistent experience with advanced search.
 
 Individual blacklight 'search fields' can have advanced parsing turned off:
 
@@ -78,39 +78,39 @@ Individual blacklight 'search fields' can have advanced parsing turned off:
     end
 
 
-When this feature is turned on, queries that don't have any special operators (eg: AND, OR, NOT, parens) will still be passed to Solr much the same as they were before. But queries with special operators will have appropriate Solr queries generated for them, usually including nested "_query_" elements, to have the same meaning they would in advanced search. If a user enters something that is a syntax error for parsed search (for instance an unclosed phrase quote or paren), the logic will rescue from the parse erorr by running the exact user entered query direct to solr without advanced parsing. 
+When this feature is turned on, queries that don't have any special operators (eg: AND, OR, NOT, parens) will still be passed to Solr much the same as they were before. But queries with special operators will have appropriate Solr queries generated for them, usually including nested "_query_" elements, to have the same meaning they would in advanced search. If a user enters something that is a syntax error for parsed search (for instance an unclosed phrase quote or paren), the logic will rescue from the parse erorr by running the exact user entered query direct to solr without advanced parsing.
 
 Due to limitations of the logic, sometimes these generated Solr queries may not really be as simple as they could be, they may include a *single* nested _query_, which really doens't need to be a nested query at all, although it will still work fine.
 
-If there'a a parse error trying to parse as boolean expression, it'll give up and pass the query on through same as it would without ParseBasicQ. 
+If there'a a parse error trying to parse as boolean expression, it'll give up and pass the query on through same as it would without ParseBasicQ.
 
 ### Search fields
 
-Your main blacklight search fields are generally defined in CatalogController blacklight_config using `add_search_field`. They are all by default used in advanced search. 
+Your main blacklight search fields are generally defined in CatalogController blacklight_config using `add_search_field`. They are all by default used in advanced search.
 
 If there are particular search fields in your main blacklight config you want excluded from the advanced search form, you can set ":include_in_advanced_search => false"
 
     config.add_search_field("isbn") do |field|
       field.include_in_advanced_search = false
-      field.solr_parameters = { :qf => "isbn_t" } 
-    end      
+      field.solr_parameters = { :qf => "isbn_t" }
+    end
 
 If you want search fields ONLY available in advanced search, you can suppress them from ordinary search:
 
     config.add_search_field("publisher") do |field|
       field.include_in_simple_select = false
-      field.solr_parameters = { :qf => "publisher_t" }        
+      field.solr_parameters = { :qf => "publisher_t" }
     end
 
 All advanced search fields must share the same Solr request handler (":qt"). As such, search fields that use a custom ":qt" parameter may not be re-used by the advanced search plugin. However, you may use a separate Solr request handler than the Blacklight default. If you would like the advanced search to use a different Solr request handler than your app's default, set:
- 
-    config.advanced_search = { 
+
+    config.advanced_search = {
       :qt => 'advanced'
     }
- 
-If you use a separate Solr request handler for advanced search, you must supply a completely separate list of search fields for the advanced search form, just define them with `:include_in_advanced_search => true` and `:include_in_simple_search => false` as above. 
 
-Additionally, to make your advanced search solr requests more concise, you are strongly encouraged to take advantage of the :local_solr_parameters option in your search field definition to use a solr parameter substitution with $variables. 
+If you use a separate Solr request handler for advanced search, you must supply a completely separate list of search fields for the advanced search form, just define them with `:include_in_advanced_search => true` and `:include_in_simple_search => false` as above.
+
+Additionally, to make your advanced search solr requests more concise, you are strongly encouraged to take advantage of the :local_solr_parameters option in your search field definition to use a solr parameter substitution with $variables.
 
     configure_blacklight do |config|
       config.add_search_field('author') do |field|
@@ -145,10 +145,9 @@ Within your solrconfig.xml you may then provide the appropriate custom configura
       </lst>
     </requestHandler>
 
-
 ### Facets on advanced search form
 
-By default, the advanced search form will show as limits whatever facets are configured as default in your Solr request handler.  To have the advanced search form request specific facets and/or specific facet parameters, you can set config[:form_solr_parameters]. 
+By default, the advanced search form will show as limits whatever facets are configured as default in your Solr request handler.  To have the advanced search form request specific facets and/or specific facet parameters, you can set config[:form_solr_parameters].
 
     config.advanced_search = {
       :form_solr_parameters => {
@@ -158,22 +157,11 @@ By default, the advanced search form will show as limits whatever facets are con
       }
     }
 
-Multiply selected advanced search form facets are combined with `or` (ie `any` or `union`). 
+Multiply selected advanced search form facets are combined with `or` (ie `any` or `union`).
 
 The default advanced search form facet display is very much like Blacklight's
 sidebar facets (and uses some code straight from BL to render), but with checkboxes
-next to each value. 
-
-(IN PROGRESS) An alternate view using a multi-element HTML `select` is available, and can also
-be combined with [chosen.js](http://harvesthq.github.io/chosen/) for a fancy type-ahead style of UI.
-This can be especially useful if you want to offer many facet values at once on
-the form (beware, they are all still loaded in HTML, so this is probably good for
-at most hundreds, not thousands.)
-
-    config.advanced_search = {
-      # ...
-      :form_facet_partial => "advanced_search_facets_as_select"
-    }
+next to each value.
 
 ### Advanced Search Config Options
 
@@ -181,48 +169,46 @@ Complete list of keys that can be supplied inside your configure_blacklight `adv
 
 * :qt
   * Solr request handler to use for any search that includes advanced search criteria. Defaults to what the application has set as blacklight_config.default_solr_params[:qt]
-* :url_key
-  * Key to use in application URLs to indicate advanced search is included in a query, defaults to "advanced". URLs will have "&search_field=[url key]".
-* :form_solr_paramters
-  * A hash of solr parameters which will be included in Solr request sent before display of advanced search form. Can be used to set facet parameters for advanced search form display.  
+* :form_solr_parameters
+  * A hash of solr parameters which will be included in Solr request sent before display of advanced search form. Can be used to set facet parameters for advanced search form display.
 * :query_parser
-  * advanced searches are translated to solr nested queries, where the inner queries are of a dismax-type. 
-  By default, they are actually specifically 'dismax', but you can set :query_parser to 'edismax' instead. 
+  * advanced searches are translated to solr nested queries, where the inner queries are of a dismax-type.
+  By default, they are actually specifically 'dismax', but you can set :query_parser to 'edismax' instead.
   This may make additional features available like * wildcards in advanced searches; but it may also
   cause some user query elements to be interpreted as operators for edismax when they
-  were intended as literals. Somewhat experimental. See Github issues #11 and #14. 
+  were intended as literals. Somewhat experimental. See Github issues #11 and #14.
 
 ## Customizing the advanced search form
 
 Most of the labels on the advanced search form are [provided via Rails i18n](./config/locales), and can
-be customized in a local app i18n file. 
+be customized in a local app i18n file.
 
-Additionally, you can override the templates from this gem used to display the form. 
+Additionally, you can override the templates from this gem used to display the form.
 We've tried to break it up into partials at the right granularity for over-riding
 in likely ways.  For one example, see the wiki page on [Adding a range limit to the advanced search form](https://github.com/projectblacklight/blacklight_advanced_search/wiki/Adding-a-range-limit-to-the-advanced-search-form).
 
 
 ## Translation to Solr Query, technical details
 
-The code for mapping a user-entered query to a Solr query is called "nesting_parsing", and maps to a 'lucene' query parser query, with nested 'dismax' query parser queries. 
+The code for mapping a user-entered query to a Solr query is called "nesting_parsing", and maps to a 'lucene' query parser query, with nested 'dismax' query parser queries.
 
-Some technical details can be found in the nesting_parsing README: [https://github.com/projectblacklight/blacklight_advanced_search/tree/master/lib/parsing_nesting]
+Some technical details can be found in the nesting_parsing README: [https://github.com/projectblacklight/blacklight_advanced_search/tree/main/lib/parsing_nesting]
 
 You may also find the rspecs for parsing a user-entered query and converting it to Solr illumnating:
 
-1. Converting user-entered query to Solr: [https://github.com/projectblacklight/blacklight_advanced_search/blob/master/spec/parsing_nesting/to_solr_spec.rb]
-2. Parsing user-entered query to internal syntax tree: [https://github.com/projectblacklight/blacklight_advanced_search/blob/master/spec/parsing_nesting/build_tree_spec.rb]
- 
+1. Converting user-entered query to Solr: [https://github.com/projectblacklight/blacklight_advanced_search/blob/main/spec/parsing_nesting/to_solr_spec.rb]
+2. Parsing user-entered query to internal syntax tree: [https://github.com/projectblacklight/blacklight_advanced_search/blob/main/spec/parsing_nesting/build_tree_spec.rb]
+
 ## Running tests
 
 
 (Limited) test coverage is provided with rspec, run all tests (and start the jetty instance) by running:
-   rake ci 
+   rake ci
+
+from the blacklight_advanced_search directory. Note: you may need to `bundle install` first.
 
-from the blacklight_advanced_search directory. Note: you may need to `bundle install` first. 
 
-  
 ## To Do
 
-* Alphabetical sorting of facet values returned by solr in count order (perhaps with limit). 
-* Parse for fielded search too like << title:"some title" >>.  'field:' that doesn't match an actual known field should be passed through same as now, while recognized fields should generate nested queries tied to those blacklight search types. 
+* Alphabetical sorting of facet values returned by solr in count order (perhaps with limit).
+* Parse for fielded search too like << title:"some title" >>.  'field:' that doesn't match an actual known field should be passed through same as now, while recognized fields should generate nested queries tied to those blacklight search types.

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/setup'
 Bundler::GemHelper.install_tasks
 
@@ -6,8 +8,6 @@ require 'rubocop/rake_task'
 require 'rspec/core/rake_task'
 require 'engine_cart/rake_task'
 
-EngineCart.fingerprint_proc = EngineCart.rails_fingerprint_proc
-
 task :default => :ci
 
 desc "Run specs"

data/VERSION

@@ -1 +1 @@
-6.4.1
+8.0.0.alpha2

data/blacklight_advanced_search.gemspec

@@ -9,24 +9,23 @@ Gem::Specification.new do |s|
   s.email    = ["blacklight-development@googlegroups.com"]
   s.homepage = "http://projectblacklight.org/"
   s.summary  = "Blacklight Advanced Search plugin"
-  s.license  = "Apache 2.0"
-
-  s.rubyforge_project = "blacklight"
+  s.license  = "Apache-2.0"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency 'blacklight', '~> 6.0', '>= 6.0.1'
+  s.add_dependency 'blacklight', '>= 7.15', '< 9'
   s.add_dependency "parslet"
 
   s.add_development_dependency "rails"
-  s.add_development_dependency "rspec-rails", "~> 3.0"
+  s.add_development_dependency "rspec-rails", "~> 5.0"
   s.add_development_dependency "capybara"
-  s.add_development_dependency 'solr_wrapper', "~> 0.14"
-  s.add_development_dependency 'engine_cart', "~> 0.10"
+  s.add_development_dependency 'solr_wrapper'
+  s.add_development_dependency 'engine_cart', "~> 2.0"
   s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'rubocop-rails'
   s.add_development_dependency 'rubocop-rspec'
   s.add_development_dependency 'rsolr'
 end

data/config/routes.rb

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

data/lib/blacklight_advanced_search/advanced_query_parser.rb

@@ -1,3 +1,5 @@
+require 'parsing_nesting/tree'
+
 module BlacklightAdvancedSearch
   # Can extract query elements from rails #params query params, and then parse
   # them and convert them into a solr query with #to_solr
@@ -5,66 +7,50 @@ module BlacklightAdvancedSearch
   # #keyword_queries and #filters, which just return extracted elements of query
   # params, may also be useful in display etc.
   class QueryParser
-    include ParsingNestingParser # only one strategy currently supported. if BlacklightAdvancedSearch.config[:solr_type] == "parsing_nesting"
-    include FilterParser
-    attr_reader :config, :params
+    attr_reader :config, :search_state
 
-    def initialize(params, config)
-      @params = Blacklight::SearchState.new(params, config).to_h
+    def initialize(search_state, config)
+      @search_state = search_state
       @config = config
     end
 
     def to_solr
       @to_solr ||= begin
         {
-          :q => process_query(params, config),
-          :fq => generate_solr_fq
+          q: process_query(config)
         }
       end
     end
 
     # Returns "AND" or "OR", how #keyword_queries will be combined
     def keyword_op
-      @params["op"] || "AND"
+      op = search_state.params[:op]&.to_sym || :must
+
+      if op == :should
+        'OR'
+      else
+        'AND'
+      end
     end
 
-    # extracts advanced-type keyword query elements from query params,
-    # returns as a kash of field => query.
-    # see also keyword_op
     def keyword_queries
-      unless @keyword_queries
-        @keyword_queries = {}
-
-        return @keyword_queries unless @params[:search_field] == ::AdvancedController.blacklight_config.advanced_search[:url_key]
-
-        config.search_fields.each do |key, _field_def|
-          unless @params[key.to_sym].blank?
-            @keyword_queries[key] = @params[key.to_sym]
-          end
-        end
-      end
-      @keyword_queries
+      search_state.clause_params.values.select { |clause| clause[:query].present? }
     end
 
-    # extracts advanced-type filters from query params,
-    # returned as a hash of field => [array of values]
-    def filters
-      unless @filters
-        @filters = {}
-        return @filters unless @params[:f_inclusive] && @params[:f_inclusive].respond_to?(:each_pair)
-        @params[:f_inclusive].each_pair do |field, value_array|
-          @filters[field] ||= value_array.dup
-        end
+    def process_query(config)
+      queries = keyword_queries.map do |clause|
+        field = clause[:field]
+        query = clause[:query]
+
+        ParsingNesting::Tree.parse(query, config.advanced_search[:query_parser]).to_query(local_param_hash(field, config))
       end
-      @filters
+      queries.join(" #{keyword_op} ")
     end
 
-    def filters_include_value?(field, value)
-      filters[field.to_s].try { |array| array.include? value }
-    end
+    def local_param_hash(key, config)
+      field_def = config.search_fields[key] || {}
 
-    def empty?
-      filters.empty? && keyword_queries.empty?
+      (field_def[:solr_adv_parameters] || field_def[:solr_parameters] || {}).merge(field_def[:solr_local_parameters] || {})
     end
   end
 end

data/lib/blacklight_advanced_search/advanced_search_builder.rb

@@ -2,36 +2,37 @@ require 'parslet'
 require 'parsing_nesting/tree'
 module BlacklightAdvancedSearch
   module AdvancedSearchBuilder
-    include Blacklight::SearchFields
+    extend ActiveSupport::Concern
+
+    included do
+      self.default_processor_chain += [
+        :facets_for_advanced_search_form
+      ]
+    end
 
     def is_advanced_search?
-      (self.blacklight_config.advanced_search && blacklight_params[:search_field] == self.blacklight_config.advanced_search[:url_key]) || blacklight_params[:f_inclusive]
+      search_state.clause_params.any?
     end
 
-    # 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)
+    # Override the upstream adv. search implementation to use our own
+    def add_adv_search_clauses(solr_parameters)
+      return unless is_advanced_search?
       # If we've got the hint that we're doing an 'advanced' search, then
       # map that to solr #q, over-riding whatever some other logic may have set, yeah.
-      # the hint right now is :search_field request param is set to a magic
-      # key. OR of :f_inclusive is set for advanced params, we need processing too.
-      if is_advanced_search?
-        # Set this as a controller instance variable, not sure if some views/helpers depend on it. Better to leave it as a local variable
-        # if not, more investigation later.
-        advanced_query = BlacklightAdvancedSearch::QueryParser.new(blacklight_params, self.blacklight_config)
-        BlacklightAdvancedSearch.deep_merge!(solr_parameters, advanced_query.to_solr)
-        unless advanced_query.keyword_queries.empty?
-          # force :qt if set, fine if it's nil, we'll use whatever CatalogController
-          # ordinarily uses.
-          solr_parameters[:qt] = self.blacklight_config.advanced_search[:qt]
-          solr_parameters[:defType] = "lucene"
-        end
-
+      advanced_query = BlacklightAdvancedSearch::QueryParser.new(search_state, blacklight_config)
+      BlacklightAdvancedSearch.deep_merge!(solr_parameters, advanced_query.to_solr)
+      unless advanced_query.keyword_queries.empty?
+        # force :qt if set, fine if it's nil, we'll use whatever CatalogController
+        # ordinarily uses.
+        solr_parameters[:qt] = self.blacklight_config.advanced_search[:qt]
+        solr_parameters[:defType] = "lucene"
       end
     end
 
+    # this method is left for backwards compatibility.
+    def add_advanced_search_to_solr(solr_parameters)
+    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
@@ -50,8 +51,8 @@ module BlacklightAdvancedSearch
     def add_advanced_parse_q_to_solr(solr_parameters)
       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
+      field_def = blacklight_config.search_fields[blacklight_params[:search_field]] ||
+        blacklight_config.default_search_field
 
       # If the individual field has advanced_parse_q suppressed, punt
       return if field_def[:advanced_parse] == false
@@ -75,12 +76,14 @@ module BlacklightAdvancedSearch
     end
 
     # A Solr param filter that is NOT included by default in the chain,
-    # but is appended by AdvancedController#index, to do a search
+    # but is appended for advanced searches, to do a search
     # for facets _ignoring_ the current query, we want the facets
     # as if the current query weren't there.
     #
     # Also adds any solr params set in blacklight_config.advanced_search[:form_solr_parameters]
     def facets_for_advanced_search_form(solr_p)
+      return unless search_state.controller&.action_name == "advanced_search"
+
       # ensure empty query is all records, to fetch available facets on entire corpus
       solr_p["q"]            = '{!lucene}*:*'
       # explicitly use lucene defType since we are passing a lucene query above (and appears to be required for solr 7)

data/lib/blacklight_advanced_search/controller.rb

@@ -1,23 +1,22 @@
-require 'blacklight_advanced_search/parsing_nesting_parser'
-
 # This module gets included into CatalogController, or another SearchHelper
-# includer, to add advanced search behavior
+# includer, to override
 module BlacklightAdvancedSearch::Controller
-  extend ActiveSupport::Concern
+  if Blacklight::VERSION < '7.27'
+    # before Blacklight 7.27, the provided search service didn't receive this controller
+    def advanced_search
+      (@response, _deprecated_document_list) = blacklight_advanced_search_form_search_service.search_results
+    end
 
-  included do
-    # Display advanced search constraints properly
-    helper BlacklightAdvancedSearch::RenderConstraintsOverride
-    helper BlacklightAdvancedSearch::CatalogHelperOverride
-    helper_method :is_advanced_search?, :advanced_query
-  end
+    private
 
-  def is_advanced_search?(req_params = params)
-    (req_params[:search_field] == blacklight_config.advanced_search[:url_key]) ||
-    req_params[:f_inclusive]
-  end
+    def blacklight_advanced_search_form_search_service
+      form_search_state = search_state_class.new(blacklight_advanced_search_form_params, blacklight_config, self)
+
+      search_service_class.new(config: blacklight_config, search_state: form_search_state, user_params: form_search_state.to_h, **search_service_context)
+    end
 
-  def advanced_query
-    BlacklightAdvancedSearch::QueryParser.new(params, blacklight_config) if is_advanced_search?
+    def blacklight_advanced_search_form_params
+      {}
+    end
   end
 end

data/lib/blacklight_advanced_search/engine.rb

@@ -2,6 +2,5 @@ require 'blacklight'
 
 module BlacklightAdvancedSearch
   class Engine < Rails::Engine
-    require 'jquery-rails'
   end
 end

data/lib/blacklight_advanced_search/redirect_legacy_params_filter.rb

@@ -1,18 +1,35 @@
 # Returns a lambda that you can use with a before_filter in your
 # CatalogController to catch and redirect query params using the old
-# style, used prior to blacklight_advanced_search 5.0.
+# style
 #
 # This can be used to keep any old bookmarked URLs still working.
 #
-#     before_filter BlacklightAdvancedSearch::RedirectLegacyParamsFilter, :only => :index
+#     before_action BlacklightAdvancedSearch::RedirectLegacyParamsFilter, :only => :index
 #
 module BlacklightAdvancedSearch
   class RedirectLegacyParamsFilter
     def self.before(controller)
       params = controller.send(:params)
+      legacy_converted = false
 
+      # This was used prior to blacklight_advanceod_search 8
+      i = 0
+      controller.blacklight_config.search_fields.each do |_key, field|
+        next unless params[field.key].present?
+        legacy_converted = true
+
+        params[:clause] ||= {}
+        params[:clause][i] = {
+          field: field.key,
+          query: params[field.key]
+        }
+        i += 1
+
+        params.delete(field.key)
+      end
+
+      # This was used prior to blacklight_advanced_search 5.0.
       if params[:f_inclusive] && params[:f_inclusive].respond_to?(:each_pair)
-        legacy_converted = false
 
         params[:f_inclusive].each_pair do |field, value|
           next unless value.is_a? Hash
@@ -20,11 +37,11 @@ module BlacklightAdvancedSearch
           legacy_converted = true
           params[:f_inclusive][field] = value.keys
         end
+      end
 
-        if legacy_converted
-          controller.send(:redirect_to, params, :status => :moved_permanently)
-        end
+      if legacy_converted
+        controller.send(:redirect_to, params.to_unsafe_h, :status => :moved_permanently)
       end
     end
   end
-  end
+end

data/lib/blacklight_advanced_search.rb

@@ -1,11 +1,7 @@
 module BlacklightAdvancedSearch
   autoload :AdvancedSearchBuilder, 'blacklight_advanced_search/advanced_search_builder'
   autoload :Controller, 'blacklight_advanced_search/controller'
-  autoload :RenderConstraintsOverride, 'blacklight_advanced_search/render_constraints_override'
-  autoload :CatalogHelperOverride, 'blacklight_advanced_search/catalog_helper_override'
   autoload :QueryParser, 'blacklight_advanced_search/advanced_query_parser'
-  autoload :ParsingNestingParser, 'blacklight_advanced_search/parsing_nesting_parser'
-  autoload :FilterParser, 'blacklight_advanced_search/filter_parser'
   autoload :RedirectLegacyParamsFilter, 'blacklight_advanced_search/redirect_legacy_params_filter'
 
   require 'blacklight_advanced_search/version'