blacklight_advanced_search 6.0.2 → 6.1.0

data/Rakefile

@@ -1,51 +1,41 @@
-require 'rake'
-require 'rake/testtask'
-require 'rdoc/task'
-
 require 'bundler/setup'
 Bundler::GemHelper.install_tasks
 
-ZIP_URL = "https://github.com/projectblacklight/blacklight-jetty/archive/v4.10.3.zip"
-APP_ROOT = File.dirname(__FILE__)
-
+require 'rdoc/task'
+require 'rubocop/rake_task'
 require 'rspec/core/rake_task'
 require 'engine_cart/rake_task'
 
 EngineCart.fingerprint_proc = EngineCart.rails_fingerprint_proc
 
-require 'jettywrapper'
-
 task :default => :ci
 
 desc "Run specs"
-RSpec::Core::RakeTask.new do |t|
-
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Load fixtures"
+task :fixtures => ['engine_cart:generate'] do
+  within_test_app do
+    ENV['RAILS_ENV'] ||= 'test'
+    system "rake blacklight:index:seed"
+    abort "Error running fixtures" unless $?.success?
+  end
 end
 
-  desc "Load fixtures"
-  task :fixtures => ['engine_cart:generate'] do
-    within_test_app do
-      ENV['RAILS_ENV'] ||= 'test'
-      system "rake blacklight:index:seed"
-      abort "Error running fixtures" unless $?.success?
+desc "Execute Continuous Integration build"
+task :ci => ['rubocop', 'engine_cart:generate'] do
+  require 'solr_wrapper'
+
+  SolrWrapper.wrap(port: '8983') do |solr|
+    solr.with_collection(name: 'blacklight-core', dir: File.join(File.expand_path(File.dirname(__FILE__)), "solr", "conf")) do
+      Rake::Task['fixtures'].invoke
+      Rake::Task['spec'].invoke
     end
   end
+end
 
-desc "Execute Continuous Integration build"
-task :ci => ['jetty:clean', 'engine_cart:generate'] do
-
-  require 'jettywrapper'
-  jetty_params = {
-    :jetty_home => File.expand_path(File.dirname(__FILE__) + '/jetty'),
-    :quiet => false,
-    :jetty_port => 8888,
-    :solr_home => File.expand_path(File.dirname(__FILE__) + '/jetty/solr'),
-    :startup_wait => 30
-  }
-
-  error = Jettywrapper.wrap(jetty_params) do
-    Rake::Task['fixtures'].invoke
-    Rake::Task['spec'].invoke
-  end
-  raise "test failures: #{error}" if error
+desc 'Run style checker'
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.requires << 'rubocop-rspec'
+  task.fail_on_error = true
 end

data/VERSION

@@ -1 +1 @@
-6.0.2
+6.1.0

data/app/controllers/advanced_controller.rb

@@ -5,23 +5,21 @@
 # Note that this NEEDS to sub-class CatalogController, so it gets any
 # custom searching behavior you've added, and uses when fetching facets
 # etc. It does that right now because BlacklightAdvancedSearch::AdvancedController
-# is hard-coded to subclass CatalogController. 
+# is hard-coded to subclass CatalogController.
 #
-# TODO: 
+# TODO:
 # This seperate controller may not need to exist at all -- it just exists
 # to provide the advanced search form (and fetching of facets to display
 # on that form). Instead, mix-in a new "advanced" action to CatalogController?
-# (Make a backwards compat route though). 
+# (Make a backwards compat route though).
 #
-# Alternately, if this does exist as a seperate controller, it should 
+# Alternately, if this does exist as a seperate controller, it should
 # _directly_ < CatalogController, and BlacklightAdvancedSearch::AdvancedController
 # should be a mix-in that does not assume parent controller. Then, if you have
 # multi-controllers, you just need to create new `AdvancedControllerForX < XController`
 # which still mixes in BlacklightAdvancedSearch::AdvancedController. There
 # are probably some other edges that need to be smoothed for that approach, but
-# that'd be the direction. 
+# that'd be the direction.
 class AdvancedController < BlacklightAdvancedSearch::AdvancedController
-
   copy_blacklight_config_from(CatalogController)
-
 end

data/app/controllers/blacklight_advanced_search/advanced_controller.rb

@@ -1,17 +1,14 @@
 # Need to sub-class CatalogController so we get all other plugins behavior
-# for our own "inside a search context" lookup of facets. 
+# for our own "inside a search context" lookup of facets.
 class BlacklightAdvancedSearch::AdvancedController < CatalogController
-
   def index
-    unless request.method==:post
-      @response = get_advanced_search_facets
-    end
+    @response = get_advanced_search_facets unless request.method == :post
   end
 
   protected
 
   # Override to use the engine routes
-  def search_action_url options = {}
+  def search_action_url(options = {})
     blacklight_advanced_search_engine.url_for(options.merge(action: 'index'))
   end
 
@@ -20,9 +17,9 @@ class BlacklightAdvancedSearch::AdvancedController < CatalogController
     # * 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) do |search_builder|
-      search_builder.except(:add_advanced_search_to_solr).append(:facets_for_advanced_search_form)            
+      search_builder.except(:add_advanced_search_to_solr).append(:facets_for_advanced_search_form)
     end
 
-    return response
+    response
   end
 end

data/app/helpers/advanced_helper.rb

@@ -1,12 +1,11 @@
 # Helper methods for the advanced search form
 module AdvancedHelper
-
   # Fill in default from existing search, if present
   # -- if you are using same search fields for basic
   # search and advanced, will even fill in properly if existing
   # search used basic search on same field present in advanced.
   def label_tag_default_for(key)
-    if (! params[key].blank?)
+    if !params[key].blank?
       return params[key]
     elsif params["search_field"] == key
       return params["q"]
@@ -26,7 +25,7 @@ module AdvancedHelper
       t('blacklight_advanced_search.any') => 'OR'
     }.sort
 
-    return select_tag(:op, options_for_select(options,params[:op]), :class => 'input-small')
+    select_tag(:op, options_for_select(options, params[:op]), :class => 'input-small')
   end
 
   # Current params without fields that will be over-written by adv. search,
@@ -34,12 +33,12 @@ module AdvancedHelper
   def advanced_search_context
     my_params = params.except :page, :commit, :f_inclusive, :q, :search_field, :op, :action, :index, :sort, :controller, :utf8
 
-    my_params.except! *search_fields_for_advanced_search.map { |key, field_def| field_def[:key] }
+    my_params.except! *search_fields_for_advanced_search.map { |_key, field_def| field_def[:key] }
   end
 
   def search_fields_for_advanced_search
     @search_fields_for_advanced_search ||= begin
-      blacklight_config.search_fields.select { |k,v| v.include_in_advanced_search or v.include_in_advanced_search.nil? }
+      blacklight_config.search_fields.select { |_k, v| v.include_in_advanced_search || v.include_in_advanced_search.nil? }
     end
   end
 
@@ -47,5 +46,4 @@ module AdvancedHelper
   def advanced_search_facet_partial_name(display_facet)
     facet_configuration_for_field(display_facet.name).try(:partial) || "catalog/facet_limit"
   end
-
 end

data/blacklight_advanced_search.gemspec

@@ -2,13 +2,14 @@
 require File.join(File.dirname(__FILE__), "lib/blacklight_advanced_search/version")
 
 Gem::Specification.new do |s|
-  s.name = "blacklight_advanced_search"
-  s.version = BlacklightAdvancedSearch::VERSION
+  s.name     = "blacklight_advanced_search"
+  s.version  = BlacklightAdvancedSearch::VERSION
   s.platform = Gem::Platform::RUBY
-  s.authors = ["Jonathan Rochkind", "Chris Beer"]
-  s.email = ["blacklight-development@googlegroups.com"]
-  s.homepage    = "http://projectblacklight.org/"
-  s.summary = "Blacklight Advanced Search plugin"
+  s.authors  = ["Jonathan Rochkind", "Chris Beer"]
+  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"
 
@@ -23,6 +24,8 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rails"
   s.add_development_dependency "rspec-rails", "~> 3.0"
   s.add_development_dependency "capybara"
-  s.add_development_dependency 'jettywrapper', ">= 1.4.2"
-  s.add_development_dependency 'engine_cart', "~> 0.8"
+  s.add_development_dependency 'solr_wrapper', "~> 0.14"
+  s.add_development_dependency 'engine_cart', "~> 0.10"
+  s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'rubocop-rspec'
 end

data/lib/blacklight_advanced_search.rb

@@ -10,40 +10,35 @@ module BlacklightAdvancedSearch
 
   require 'blacklight_advanced_search/version'
   require 'blacklight_advanced_search/engine'
-  
-  # 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)
-    # 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)
+  # 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
+  def self.deep_merge!(source_hash, new_hash)
+    source_hash.deep_merge!(new_hash, &method(:merge_conflict_resolution))
+  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  
-  
+  # 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
 end

data/lib/blacklight_advanced_search/advanced_query_parser.rb

@@ -9,16 +9,16 @@ module BlacklightAdvancedSearch
     include FilterParser
     attr_reader :config, :params
 
-    def initialize(params,config)
-      @params = HashWithIndifferentAccess.new(params)
+    def initialize(params, config)
+      @params = Blacklight::SearchState.new(params, config).to_h
       @config = config
     end
 
     def to_solr
       @to_solr ||= begin
         {
-          :q => process_query(params,config),
-          :fq => generate_solr_fq()
+          :q => process_query(params, config),
+          :fq => generate_solr_fq
         }
       end
     end
@@ -32,40 +32,39 @@ module BlacklightAdvancedSearch
     # returns as a kash of field => query.
     # see also keyword_op
     def keyword_queries
-      unless(@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 |
-          if ! @params[ key.to_sym ].blank?
-            @keyword_queries[ key ] = @params[ key.to_sym ]
+        config.search_fields.each do |key, _field_def|
+          unless @params[key.to_sym].blank?
+            @keyword_queries[key] = @params[key.to_sym]
           end
         end
       end
-      return @keyword_queries
+      @keyword_queries
     end
 
     # extracts advanced-type filters from query params,
     # returned as a hash of field => [array of values]
     def filters
-      unless (@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
       end
-      return @filters
+      @filters
     end
 
     def filters_include_value?(field, value)
-      filters[field.to_s].try {|array| array.include? value}
+      filters[field.to_s].try { |array| array.include? value }
     end
 
     def empty?
       filters.empty? && keyword_queries.empty?
     end
-
   end
 end

data/lib/blacklight_advanced_search/advanced_search_builder.rb

@@ -2,7 +2,6 @@ require 'parslet'
 require 'parsing_nesting/tree'
 module BlacklightAdvancedSearch
   module AdvancedSearchBuilder
-
     include Blacklight::SearchFields
 
     def is_advanced_search?
@@ -12,66 +11,64 @@ module BlacklightAdvancedSearch
     # 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. 
+    # adds a 'q' and 'fq's based on advanced search form input.
     def add_advanced_search_to_solr(solr_parameters)
       # 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.     
+      # 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 )
-        if advanced_query.keyword_queries.length > 0
+        # 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.         
+          # ordinarily uses.
           solr_parameters[:qt] = self.blacklight_config.advanced_search[:qt]
-          solr_parameters[:defType] = "lucene"        
+          solr_parameters[:defType] = "lucene"
         end
-        
+
       end
     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]
+    PARSLET_FAILED_EXCEPTIONS = if defined? Parslet::UnconsumedInput
+                                  [Parslet::UnconsumedInput].freeze
+                                else
+                                  [Parslet::ParseFailed].freeze
     end
-    
-    
+
     # 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.
     #
     # 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. 
+    # were not being used.
     def add_advanced_parse_q_to_solr(solr_parameters)
       unless scope.params[:q].blank?
-        field_def = search_field_def_for_key( scope.params[:search_field]) ||
+        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  
-          
+        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 )
+          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
+          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. 
+          # optional TODO, display error message in flash here, but hard to
+          # display a good one.
           return
         end
       end
@@ -80,21 +77,20 @@ module BlacklightAdvancedSearch
     # A Solr param filter that is NOT included by default in the chain,
     # but is appended by AdvancedController#index, to do a search
     # for facets _ignoring_ the current query, we want the facets
-    # as if the current query weren't there. 
+    # 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)
       # ensure empty query is all records, to fetch available facets on entire corpus
       solr_p["q"]            = '{!lucene}*:*'
 
-      # We only care about facets, we don't need any rows. 
+      # We only care about facets, we don't need any rows.
       solr_p["rows"]         = "0"
 
       # Anything set in config as a literal
       if blacklight_config.advanced_search[:form_solr_parameters]
-        solr_p.merge!( blacklight_config.advanced_search[:form_solr_parameters] ) 
+        solr_p.merge!(blacklight_config.advanced_search[:form_solr_parameters])
       end
-
     end
   end
 end