bento_search 1.5.0 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8824757e65434f6a003c9748cf68e51cddcc3795
-  data.tar.gz: 081397571dbcb6307fdf9f162f5493e1d75d1e77
+SHA256:
+  metadata.gz: ed755cb880b6d45bd02d53373d80c25161c6689ef59b7108106896c0a392fc4c
+  data.tar.gz: 4c9009a41299bc44b84274e93c5f0e7a9a5fda599e0de97f6e8972cd3519faf0
 SHA512:
-  metadata.gz: b5f11bd2566934fc22409ec97c9aa89d91e10a497948839ce6708e9a7c90bbf1ee1d951d5d2585641aa1dc0afb0fb082ac4cd258d64b25f8589bfda112233fd5
-  data.tar.gz: 32ac0a5ef5be6ec91d2b9bd034e7332d7ab52812743e56aeca97f59832c69fba45a20153102264730e6e18c9d9f97dfb26f4c0d51d1589eaf651fa9d2632823e
+  metadata.gz: 07e2ba15ccd24b1dc1d1cfac642dd01d60700de90dcd2b63ce164830a4619e30203c728077461123ab39ce7e8da6390d3f5009f6afaba637ebc275f5977fd23e
+  data.tar.gz: 755df58770fa0f91fa9cd0fa8ef507815f762889203f4c63edd9931bd4f15270027a033213fca650334749add1be5d9ef0dc15a64b6b9bf92d75838137db01bc

data/README.md

@@ -1,11 +1,11 @@
 # BentoSearch
 
-[![Build Status](https://secure.travis-ci.org/jrochkind/bento_search.png)](http://travis-ci.org/jrochkind/bento_search)
+[![CI Build Status](https://github.com/jrochkind/bento_search/actions/workflows/ruby.yml/badge.svg)](https://github.com/jrochkind/bento_search/actions/workflows/ruby.yml)
 [![Gem Version](https://badge.fury.io/rb/bento_search.png)](http://badge.fury.io/rb/bento_search)
 
 bento_search provides an abstraction/normalization layer for querying and
 displaying results from external search engines, in Ruby on Rails. Works with
-Rails 3.x or 4.x.   ruby 1.9.3+
+Rails 5.2 - 6.1, ruby 2.5 through 3.0.
 
 ### Goals: To help you
 
@@ -35,6 +35,7 @@ Adapters currently included in bento_search
 * [WorldCat Search](https://www.worldcat.org/) (requires OCLC membership to get api key)
 * [Google Site Search](https://www.google.com/work/search/products/gss.html) (requires sign-up for more than 100 searches/day)
 * [JournalTOCs](http://www.journaltocs.hw.ac.uk/) (limited support for fetching current articles by ISSN, free but requires registration)
+* [Directory of Open Access Journals (DOAJ)](https://doaj.org/) article search. (free, no registration required)
 
 
 
@@ -46,12 +47,11 @@ search' functionality, but it does not and will never support merging results
 from multiple engines into one result set. It is meant to support displaying the
 first few results from multiple engines on one page, "bento box" style (as
 named by Tito Sierra@NCSU), as well as more expanded single-search-on-a-page
-uses.
+uses -- or back-end functionality supporting features that are not straight discovery.
 
 * bento_search provides abstract functionality for pagination, sorting,
-and single-field-specified queries. Faceting, generalized limiting, and 'advanced'
-multi-field searches are not yet supported, but possibly will be built
-out in the future.
+and single-field-specified queries. Faceting and generalized limiting are
+not yet supported, but possibly will be built out in the future.
 
 Not all search engine adapters support all features.  Some engines offer
 engine-specific features, such as limiting. Search engine adapters can
@@ -86,7 +86,7 @@ may be required for certain engines.
 `results` are a [BentoSearch::Results](./app/models/bento_search/results.rb) object, which acts like an array of
 [BentoSearch::ResultItem](./app/models/bento_search/result_item.rb) objects, along with some meta-information about the
 search itself (pagination keys, etc).  BentoSearch::Results and Item fields
-are standardized accross engines. BentoSearch::Items provide semantic
+are standardized across engines. BentoSearch::Items provide semantic
 values (title, author, etc.), as available from the particular engine.
 
 To see which engines come bundled with BentoSearch, and any special
@@ -238,7 +238,7 @@ declared for the engine, that will be preferred.
 This can be used to expose a multi-field search to users, and the `bento_field_hash_for`
 helper method might be helpful in creating your UI. But this is also useful for looking
 up known-item citations -- either by author/title, or issn/volume/issue/page, or doi, or
-anything else -- as back-end support for various possible functions. 
+anything else -- as back-end support for various possible functions.
 
 ### Concurrent searching
 
@@ -250,12 +250,12 @@ to execute concurrently in seperate threads, so the total wait time is the slowe
 engine, not the sum of the engines.
 
 You can write your own logic using ruby threads to do this, but
-BentoSearch provides a multi-searching helper using [Celluloid](https://github.com/celluloid/celluloid)
+BentoSearch provides a multi-searching helper using [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby)
 to help you do this easily. Say, in a controller:
 
 ~~~~ruby
     # constructor takes id's registered with BentoSearch.register_engine
-    searcher = BentoSearch::MultiSearcher.new(:gbs, :scopus, :summon)
+    searcher = BentoSearch::ConcurentSearcher.new(:gbs, :scopus, :summon)
 
     # Call 'search' with any parameters you would give to an_engine.search
     searcher.search("my query", :semantic_search_field => :author, :sort => "title")
@@ -273,13 +273,18 @@ search execute in a seperate thread, so you can continue doing other work
 in the main thread (like search a local store of some kind outside of
 bento_search)
 
-You will need to add the 'celluloid' gem to your app to use this feature,
-BentoSearch doesn't automatically include the celluloid dependency. Note
-that Celluloid uses multi-threading in such a way that you might need
-to turn Rails config.cache_classes=true even in development.
+If you are using a Rails previous to 5.x, you will have to add the
+`concurrent-ruby` gem to your `Gemfile` (It's already a dependency of
+Rails5).
+
+If you are using Rails5, ConcurrentSearcher uses new Rails API that
+should make development-mode class reloading work fine even with
+the ConcurrentSearcher's concurrency.
+
+For more info, see [BentoSearch::ConcurrentSearcher](./app/models/bento_search/concurrent_searcher.rb).
+
 
 
-For more info, see [BentoSearch::MultiSearcher](./app/models/bento_search/multi_searcher.rb).
 
 ### Delayed results loading via AJAX (actually more like AJAHtml)
 
@@ -375,7 +380,7 @@ There are additional details that might matter to you, for more info see the
 ### Round-Trip Serialization to JSON
 
 You can serialize BentoSearch::Results to a simple straightforward JSON structure, and de-serialize
-them back into BentoSearch::Results. 
+them back into BentoSearch::Results.
 
 ~~~ruby
 json_str          = results.dump_to_json
@@ -383,19 +388,19 @@ copy_of_results   = BentoSearch::Results.load_json(json_str)
 ~~~
 
 Search context (query, start, per_page) are not serialized, and will be lost
-on de-serialization. 
+on de-serialization.
 
 Unlike the Atom serialization, **the JSON serialization is of internal data
-state, without decoration.** Configuration context is not serialized.  
+state, without decoration.** Configuration context is not serialized.
 
-However, the engine_id is included in serialization if present, 
+However, the engine_id is included in serialization if present,
 and configuration from the specified engine
 will be re-assigned on de-serialization.  This means if the configuration
 changed between serialization and de-serialization, you get the new stuff
-assigned on de-serialization. 
+assigned on de-serialization.
 
 The use case guiding JSON serialization is storage somewhere, and
-round-trip de-serialization in the current app context. 
+round-trip de-serialization in the current app context.
 
 If you want to take de-serialized results that did not have an engine_id,
 or set configuration on them to a different engine (registered or not) you can:
@@ -410,7 +415,7 @@ or set configuration on them to a different engine (registered or not) you can:
 
 If you want a serialization to be consumed by something other than an
 app using the bento_search gem, as an API, we recommend the [Atom serialization](https://github.com/jrochkind/bento_search/wiki/Machine-Readable-Serialization-With-Atom)
-instead. 
+instead.
 
 ## Planned Features
 
@@ -423,8 +428,6 @@ Probably:
 * Support for display facets for engines that support such, as well as
   search with limits from controlled vocabulary (ie, selected facet, but
   also may be supported by some engines that do not support facetting).
-* Support for multi-field, multi-entry-box 'advanced search' UI's, in
-  a normalized cross-engine way.
 
 Other needs or suggestions?
 

data/Rakefile

@@ -23,17 +23,36 @@ end
 APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
 load 'rails/tasks/engine.rake'
 
-
-
-Bundler::GemHelper.install_tasks
-
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+
+if Gem::Version.new(Rails.version) > Gem::Version.new('4.2.99999')
+  desc "Run tests"
+  task :test do
+    Rake::Task["app:test"].invoke
+  end
+  # use built-in Rails test command
+  # task :test do
+  #   require "rails/test_unit/minitest_plugin"
+  #   #$: << File.expand_path('test', ENGINE_ROOT)
+  #   Minitest.rake_run([])
+
+  #   # require 'rails/engine/commands_tasks'
+  #   # Rails::Engine::CommandsTasks.new("").run_command!('test')
+  # end
+else
+  # old rails4 style
+  require 'rake/testtask'
+
+  Rake::TestTask.new(:test) do |t|
+    t.libs << 'lib'
+    t.libs << 'test'
+    t.pattern = 'test/**/*_test.rb'
+    t.verbose = false
+    t.warning = false
+  end
 end
 
 

data/app/assets/javascripts/bento_search/ajax_load.js

@@ -1,56 +1,88 @@
 var BentoSearch = BentoSearch || {}
 
-// Pass in a DOM node that has a data-ajax-url attribute. 
+// Pass in a DOM node that has a data-ajax-url attribute.
 // Will AJAX load bento search results inside that node.
-// optional second arg success callback function. 
-BentoSearch.ajax_load = function(node, success_callback) {
+//
+// optional success_callback function.
+//
+// success_callback: will have the container div as 'this', and new content
+// as first argument (in JQuery wrapper). Called before DOM update happens, so
+// first arg div is not yet placed in the DOM. Callback can
+// return `false` to prevent automatic placement in the DOM, if you want
+// to handle it yourself.
+//
+// You can set default success_callback function for all calls with:
+//
+//     BentoSearch.ajax_load.default_success_callback = function(div) { ...
+//
+// optional beforeSend function.
+//
+// beforeSend: to be used by jQuery.ajax as the settings.beforeSend function.
+// this allows the outgoing request to modified, e.g. to add auth params
+// in the query param or in a header.
+// See https://api.jquery.com/jquery.ajax/#jQuery-ajax-settings
+//
+// You can set default beforeSend function for all calls with:
+//
+//     BentoSearch.ajax_load.default_beforeSend = function(xhr, settings) { ...
+BentoSearch.ajax_load = function(node, success_callback, beforeSend) {
+  // default success_callback
+  if (success_callback === undefined) {
+    success_callback = BentoSearch.ajax_load.default_success_callback;
+  }
+  // default beforeSend
+  if (beforeSend === undefined) {
+    beforeSend = BentoSearch.ajax_load.default_beforeSend;
+  }
+
   var div = $(node);
-  
+
   if (div.length == 0) {
     //we've got nothing
     return
   }
-  
+
 
   // We find the "waiting"/spinner section already rendered,
   // and show it. We experimented with generating the spinner/waiting
   // purely in JS, instead of rendering a hidden one server-side. But
-  // it was too weird and unreliable to do that, sorry.   
+  // it was too weird and unreliable to do that, sorry.
   div.find(".bento_search_ajax_loading").show();
-  
-  
+
+
   // Now load the actual external content from html5 data-bento-ajax-url
   $.ajax({
-      url: div.data("bentoAjaxUrl"), 
+      url: div.data("bentoAjaxUrl"),
       success: function(response, status, xhr) {
-        var do_replace = true;         
+        var do_replace = true;
         if (success_callback) {
           // We need to make the response into a DOM so the callback
           // can deal with it better. Wrapped in a div, so it makes
-          // jquery happy even if there isn't a single parent element. 
+          // jquery happy even if there isn't a single parent element.
           response = $("<div>" + response + "</div>");
-          
-          do_replace = success_callback.apply(div, [response]);                    
+
+          do_replace = success_callback.apply(div, [response]);
         }
-        if (do_replace != false) { 
+        if (do_replace != false) {
           div.replaceWith(response);
-        }          
+        }
       },
+      beforeSend: beforeSend,
       error: function(xhr, status, errorThrown) {
         var msg = "Sorry but there was an error: ";
         div.html(msg + xhr.status + " " + xhr.statusText + ", " + status);
       }
   });
- 
-  
+
+
 }
 
 jQuery(document).ready(function($) {
     //Intentionally wait for window.load, not just onready, to
-    //prevent interfering with rest of page load. 
-    $(window).bind("load", function() {   
+    //prevent interfering with rest of page load.
+    $(window).bind("load", function() {
         $("*[data-bento-search-load=ajax_auto]").each(function(i, div) {
-            BentoSearch.ajax_load(div);                              
+            BentoSearch.ajax_load(div);
       });
-    });    
-});
+    });
+});

data/app/controllers/bento_search/search_controller.rb

@@ -2,51 +2,51 @@ module BentoSearch
   # This is a controller that provides stand-alone search results
   # for registered engines. Right now, this is only for automatic
   # AJAX delayed loading. In the future it may be used for atom results,
-  # or other such. 
+  # or other such.
   #
   # You need to make sure to include routing for this controller in your
   # app to use it, for instance with `BentoSearch::Routes.new(self).draw`
   # in your ./config/routes.rb
   #
   # # Authorization Issues
-  # 
+  #
   # You may have some engines which should not be publically searchable,
   # they should only be searchable by certain auth'd users. This controller
   # could accidentally provide a non-protected endpoint to get results if
-  # nothing were done to prevent it. 
+  # nothing were done to prevent it.
   #
   # Only engines which have a :allow_routable_results => true key
-  # in their config will be served by this controller. 
+  # in their config will be served by this controller.
   #
-  # If you need routable results on an engine which ALSO needs to 
-  # be protected by auth, you can add your own Rails before_filter
+  # If you need routable results on an engine which ALSO needs to
+  # be protected by auth, you can add your own Rails before_action
   # to provide auth. Say, in an initializer in your app:
   #
-  #     SearchController.before_filter do |controller|
+  #     SearchController.before_action do |controller|
   #       unless controller.current_user
   #          raise BentoSearch::SearchController::AccessDenied
   #       end
   #     end
-  #    
-  # 
+  #
+  #
   # We may provide fancier/nicer API for this in the future, if there's
-  # demand. 
+  # demand.
   class SearchController < BentoSearchController
     class AccessDenied < BentoSearch::Error ; end
 
-    
+
     rescue_from AccessDenied, :with => :deny_access
     rescue_from NoSuchEngine, :with => :render_404
-      
+
     # returns partial HTML results, suitable for
-    # AJAX to insert into DOM. 
+    # AJAX to insert into DOM.
     # arguments for engine.search are taken from URI request params, whitelisted
-    def search           
+    def search
       engine  =  BentoSearch.get_engine(params[:engine_id])
-      # put it in an iVar mainly for testing purposes. 
+      # put it in an iVar mainly for testing purposes.
       @engine = engine
 
-      
+
       unless engine.configuration.allow_routable_results == true
         raise AccessDenied.new("engine needs to be registered with :allow_routable_results => true")
       end
@@ -54,28 +54,29 @@ module BentoSearch
       @results         = engine.search safe_search_args(engine, params)
       # template name of a partial with 'yield' to use to wrap the results
       @partial_wrapper = @results.display_configuration.lookup!("ajax.wrapper_template")
-      
+
       # partial HTML results
-      render "bento_search/search/search", :layout => false 
+      render "bento_search/search/search", :layout => false
 
     end
-    
 
-    
-    protected 
-    
+
+
+    protected
+
     def safe_search_args(engine, params)
-      params.to_hash.symbolize_keys.slice( *engine.public_settable_search_args )       
+      all_hash = params.respond_to?(:to_unsafe_hash) ? params.to_unsafe_hash : params.to_hash
+      all_hash.symbolize_keys.slice( *engine.public_settable_search_args )
     end
-    
+
     def deny_access(exception)
-      render :text => exception.message, :status => 403
+      render :plain => exception.message, :status => 403
     end
-    
-    def render_404(exception)      
-      render :text => exception.message, :status => 404
+
+    def render_404(exception)
+      render :plain => exception.message, :status => 404
     end
-    
-    
+
+
   end
 end

data/app/helpers/bento_search_helper.rb

@@ -3,112 +3,110 @@
 require 'nokogiri'
 
 # Rails helper module provided by BentoSearch meant to be included
-# in host app's helpers. 
+# in host app's helpers.
 module BentoSearchHelper
-  
+
   # Renders bento search results on page, or an AJAX loader, etc, as appropriate.
   # Pass in:
   #   * BentoSearch::SearchResults => will render
   #   * an instantiated BentoSearch::SearchEngine => Will do search and render
-  #   * an id that a search engine was registered under with 
-  #     BentoSearch.register_engine => will do search and render. 
+  #   * an id that a search engine was registered under with
+  #     BentoSearch.register_engine => will do search and render.
   #
   #  Second arg options hash includes options for bento_search helper,
   #  as well as other options pased on to BentoSearch::Engine.search(options)
   #
+  # Partial used for display can be configured on engine with
+  #   * for_display.error_partial => gets `results` local
+  #   * for_display.no_results_partial => gets `results` local
+  #   * for_display.item_partial => `:collection => results, :as => :item, :locals => {:results => results}`
+  #   * for_display.ajax_loading_partial => local `engine`
+  #
+  # If not specified for a particular engine, the partials listed in BentoSearch.defaults will be used.
+  #
   # == Options
   #
   #  load: :ajax_auto, :immediate.  :ajax_auto will put a spinner up there,
   #        and load actual results via AJAX request. :immediate preloads
-  #        results. 
+  #        results.
   #
   # == Examples
   #
   #     bento_results( results_obj )
   #     bento_results( engine_obj, :query => "cancer")
   #     bento_results("google_books", :query => "cancer", :load => :ajax_auto)
-  #  
+  #
   def bento_search(search_arg, options = {})
-    
+
     results = search_arg if search_arg.kind_of? BentoSearch::Results
-    
-    load_mode = options.delete(:load) 
-    
+
+    load_mode = options.delete(:load)
+
     engine = nil
     unless results
-      # need to load an engine and do a search, or ajax, etc. 
+      # need to load an engine and do a search, or ajax, etc.
       engine = (if search_arg.kind_of? BentoSearch::SearchEngine
         search_arg
       else
         raise ArgumentError.new("Need Results, engine, or registered engine_id as first argument to #bento_search") unless search_arg
         BentoSearch.get_engine(search_arg.to_s)
       end)
-      
+
     end
 
     if (!results && [:ajax_auto, :ajax_triggered].include?(load_mode))
       raise ArgumentError.new("`:load => :ajax` requires a registered engine with an id") unless engine.configuration.id
       content_tag(:div,
         :class => "bento_search_ajax_wait",
-        :"data-bento-search-load" => load_mode.to_s, 
+        :"data-bento-search-load" => load_mode.to_s,
         :"data-bento-ajax-url"    => to_bento_search_url( {:engine_id => engine.configuration.id}.merge(options) )) do
-      
-      # An initially hidden div with loading msg/spinner that will be shown
-      # by js on ajax load
-      content_tag("noscript") do
-        I18n.t("bento_search.ajax_noscript")
-      end +
-      content_tag(:div, 
-        :class => "bento_search_ajax_loading", 
-        :style => "display:none") do      
-          image_tag("bento_search/large_loader.gif", 
-            :alt => I18n.translate("bento_search.ajax_loading")            
-          ) 
+
+          partial = (engine.configuration.for_display.ajax_loading_partial if engine.configuration.for_display) || BentoSearch.defaults.ajax_loading_partial
+          render :partial => partial, locals: { engine: engine }
         end
-      end
     else
       results = engine.search(options) unless results
 
       if results.failed?
-        partial = (results.display_configuration.error_partial if results.display_configuration) || "bento_search/search_error"         
+        partial = (results.display_configuration.error_partial if results.display_configuration) || BentoSearch.defaults.error_partial
         render :partial => partial, :locals => {:results => results}
-      elsif results.length > 0   
-        partial = (results.display_configuration.item_partial if results.display_configuration) || "bento_search/std_item"        
+      elsif results.length > 0
+        partial = (results.display_configuration.item_partial if results.display_configuration) || BentoSearch.defaults.item_partial
         render :partial => partial, :collection => results, :as => :item, :locals => {:results => results}
       else
         content_tag(:div, :class=> "bento_search_no_results") do
-          partial = (results.display_configuration.no_results_partial if results.display_configuration) || "bento_search/no_results"                   
+          partial = (results.display_configuration.no_results_partial if results.display_configuration) || BentoSearch.defaults.no_results_partial
           render :partial => partial, :locals => {:results => results}
         end
       end
-    end                          
+    end
   end
-  
+
   # Wrap a ResultItem in a decorator! For now hard-coded to
   # BentoSearch::StandardDecorator
-  def bento_decorate(result_item)    
+  def bento_decorate(result_item)
     # in a helper method, 'self' is a view_context already I think?
-    decorated = BentoSearch::DecoratorBase.decorate(result_item, self)    
-    yield(decorated) if block_given?    
-    return decorated    
+    decorated = BentoSearch::DecoratorBase.decorate(result_item, self)
+    yield(decorated) if block_given?
+    return decorated
   end
-    
-  
+
+
   ##
   # More methods used by bento standard views, namespaced with bento_, sorry
   # no great way to take logic out of views into helper methods without
-  # namespacey hack. 
+  # namespacey hack.
   #
   # You can use these methods in your own custom views, you also should be
   # able to over-ride them (including calling super) in local helpers to
-  # change behavior in standard views. 
+  # change behavior in standard views.
   #
   ##
-  
+
   # Like rails truncate helper, and taking the same options, but html_safe.
-  # 
-  # If input string is NOT marked html_safe?, simply passes to rails truncate helper. 
-  # If a string IS marked html_safe?, uses nokogiri to parse it, and truncate 
+  #
+  # If input string is NOT marked html_safe?, simply passes to rails truncate helper.
+  # If a string IS marked html_safe?, uses nokogiri to parse it, and truncate
   # actual displayed text to max_length, while keeping html structure valid.
   #
   # Default omission marker is unicode elipsis
@@ -118,23 +116,23 @@ module BentoSearchHelper
   def bento_truncate(str, options = {})
     return str if str.nil? || str.empty?
 
-    options.reverse_merge!(:omission => "…", :length => 280, :separator => ' ')       
-    
+    options.reverse_merge!(:omission => "…", :length => 280, :separator => ' ')
+
     # works for non-html of course, but for html a quick check
     # to avoid expensive nokogiri parse if the whole string, even
-    # with tags, is still less than max length. 
+    # with tags, is still less than max length.
     return str if str.length < options[:length]
-    
-    if str.html_safe? 
+
+    if str.html_safe?
       noko = Nokogiri::HTML::DocumentFragment.parse(str)
       BentoSearch::Util.nokogiri_truncate(noko, options[:length], options[:omission], options[:separator]).inner_html.html_safe
     else
       return truncate(str, options)
     end
   end
-    
 
-  
+
+
   # Deprecated, made more sense to put this in a partial. Just
   # call partial directly:
   #  <%= render :partial => "bento_search/item_title", :object => item, :as => 'item'  %>
@@ -142,41 +140,41 @@ module BentoSearchHelper
     render :partial => "bento_search/item_title", :object => item, :as => 'item'
   end
   deprecate :bento_item_title
-  
+
   # pass in 0-based rails current collection counter and a BentoSearch::Results,
-  # calculates a user-displayable result set index label. 
+  # calculates a user-displayable result set index label.
   #
   # Only non-trivial thing is both inputs are allowed to be nil; if either
-  # is nil, nil is returned.  
+  # is nil, nil is returned.
   def bento_item_counter(counter, results)
     return nil if counter.nil? || results.nil? || results.start.nil?
-    
+
     return counter + results.start + 1
   end
-    
-     
+
+
   # returns a hash of label => key suitable for passing to rails
-  # options_for_select. (Yes, it works backwards from how you'd expect). 
+  # options_for_select. (Yes, it works backwards from how you'd expect).
   # Label is looked up using I18n, at bento_search.sort_keys.*
   #
   # If no i18n is found, titleized version of key itself is used as somewhat
-  # reasonable default. 
+  # reasonable default.
   def bento_sort_hash_for(engine)
-    Hash[ 
+    Hash[
       engine.sort_definitions.keys.collect do |key|
         [I18n.translate(key.to_s, :scope => "bento_search.sort_keys", :default => key.to_s.titleize), key.to_s]
-      end        
-    ]    
+      end
+    ]
   end
-  
+
   # Returns a hash of label => key suitable for passing to rails
   # options_for_select. ONLY includes fields with :semantics set at
-  # present. Key will be _semantic_ key name. 
+  # present. Key will be _semantic_ key name.
   # For engine-specific fields, you're on you're own, sorry!
   #
   # If first arg is an engine instance, will
   # be search fields supported by that engine. If first arg is nil,
-  # will be any field in our i18n lists for search fields. 
+  # will be any field in our i18n lists for search fields.
   #
   # Can pass in options :only or :except to customize list. Values
   # in :only and :except will match on internal field names OR
@@ -190,25 +188,25 @@ module BentoSearchHelper
       hash = I18n.t("bento_search.search_fields").invert
     else
       hash = Hash[ engine.search_field_definitions.collect do |k, defn|
-        if defn[:semantic] && (label = I18n.t(defn[:semantic], :scope => "bento_search.search_fields", :default => defn[:semantic].to_s.titlecase )) 
+        if defn[:semantic] && (label = I18n.t(defn[:semantic], :scope => "bento_search.search_fields", :default => defn[:semantic].to_s.titlecase ))
           [label,  defn[:semantic].to_s]
         end
       end.compact]
     end
-  
-    # :only/:except    
-    if options[:only]      
+
+    # :only/:except
+    if options[:only]
       keys = [options[:only]].flatten.collect(&:to_s)
-      hash.delete_if {|key, value|  ! keys.include?(value) }  
+      hash.delete_if {|key, value|  ! keys.include?(value) }
     end
-    
+
     if options[:except]
       keys = [options[:except]].flatten.collect(&:to_s)
       hash.delete_if {|key, value|  keys.include?(value) }
     end
-    
+
     return hash
   end
-  
-  
+
+
 end