bento_search 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8824757e65434f6a003c9748cf68e51cddcc3795
-  data.tar.gz: 081397571dbcb6307fdf9f162f5493e1d75d1e77
+  metadata.gz: 6f070dacd096eb963619edf893eeae9d44303d28
+  data.tar.gz: 41b90c919f85df3a67f3ed15ca8764d57484d952
 SHA512:
-  metadata.gz: b5f11bd2566934fc22409ec97c9aa89d91e10a497948839ce6708e9a7c90bbf1ee1d951d5d2585641aa1dc0afb0fb082ac4cd258d64b25f8589bfda112233fd5
-  data.tar.gz: 32ac0a5ef5be6ec91d2b9bd034e7332d7ab52812743e56aeca97f59832c69fba45a20153102264730e6e18c9d9f97dfb26f4c0d51d1589eaf651fa9d2632823e
+  metadata.gz: 19a68228f6e2224f23308953e96354a7df221570acb214e8134c8eab511239412cc7bf5947aeba050c4a9fa9817383d957d00a72df3ca920fdc9d7244336f603
+  data.tar.gz: fc1f57fc1718bee5ca509facdd3299194c7e277ded15930c4098e3f9c4800f80c3ee363a413c27db5c8e488a3902e9f6ab04c34960bf654acab436cbbfeac7ca

data/README.md

@@ -5,7 +5,7 @@
 
 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 3.x, 4.x, or 5.0. ruby 1.9.3+
 
 ### 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
 
@@ -375,7 +375,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 +383,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 +410,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 +423,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/controllers/bento_search/search_controller.rb

@@ -2,23 +2,23 @@ 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 
+  # If you need routable results on an engine which ALSO needs to
   # be protected by auth, you can add your own Rails before_filter
   # to provide auth. Say, in an initializer in your app:
   #
@@ -27,26 +27,26 @@ module BentoSearch
   #          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/models/bento_search/result_item.rb

@@ -36,12 +36,12 @@ module BentoSearch
     # search service it came from. May be alphanumeric. May be nil
     # for engines that don't support it.
     serializable_attr_accessor :unique_id
-    
+
 
     # If set to true, item will refuse to generate an openurl,
     # returning nil from #to_openurl or #openurl_kev
     serializable_attr_accessor :openurl_disabled
-    
+
 
     # Array (possibly empty) of BentoSearch::Link objects
     # representing additional links. Often SearchEngine's themselves
@@ -52,7 +52,7 @@ module BentoSearch
 
     # * dc.title
     # * schema.org CreativeWork: 'name'
-    serializable_attr_accessor :title    
+    serializable_attr_accessor :title
     # backwards compat, we used to have separate titles and subtitles
     alias_method :complete_title, :title
 
@@ -112,7 +112,7 @@ module BentoSearch
     #
     # Note: We're re-thinking this, might allow uncontrolled
     # in here instead.
-    serializable_attr_accessor :format    
+    serializable_attr_accessor :format
 
     # Translated from internal format vocab at #format. Outputs
     # eg http://schema.org/Book
@@ -137,7 +137,7 @@ module BentoSearch
     # uncontrolled presumably english-language format string.
     # if supplied will be used in display in place of controlled
     # format.
-    serializable_attr_accessor :format_str    
+    serializable_attr_accessor :format_str
 
     # Language of materials. Producer can set language_code to an ISO 639-1 (two
     # letter) or 639-3 (three letter) language code. If you do this, you don't
@@ -153,10 +153,10 @@ module BentoSearch
     # #language_iso_639_2 (either may be null), or #language_str for uncontrolled
     # string. If engine just sets one of these, internals take care of filling
     # out the others. r
-    serializable_attr_accessor :language_code    
+    serializable_attr_accessor :language_code
     attr_writer :language_str
     def language_str
-      @language_str || language_code.try do |code|
+      (@language_str ||= nil) || language_code.try do |code|
         LanguageList::LanguageInfo.find(code).try do |lang_obj|
           lang_obj.name
         end
@@ -230,12 +230,12 @@ module BentoSearch
 
     # An ARRAY of string query-in-context snippets. Will usually
     # have highlighting <b> tags in it. Creator is responsible
-    # for making sure it's otherwise html-safe. 
+    # for making sure it's otherwise html-safe.
     #
     # Not all engines may stores Snippets array in addition to abstract,
     # some may only store one or the other. Some may store both but
     # with same content formatted differently (array of multiple vs
-    # one combined string), some engines they may be different. 
+    # one combined string), some engines they may be different.
     attr_accessor :snippets
     serializable_attr :snippets
 
@@ -263,7 +263,7 @@ module BentoSearch
     # for it? Nice thing about the configuration has instead is it's
     # easily serializable, it's just data.
     #
-    # Although we intentionally do NOT include these in JSON serialization, ha. 
+    # Although we intentionally do NOT include these in JSON serialization, ha.
     attr_accessor :display_configuration
     attr_accessor :engine_id
 

data/app/models/bento_search/results/serialization.rb

@@ -4,21 +4,21 @@ require 'json'
 require 'date'
 
 # Call #dump_to_json on a BentoSearch value object (such as BentoSearch::Result or ::Author)
-# to get it in Json 
+# to get it in Json
 #
 # Values marked with serializable_attr in BentoSearch::Result are
-# included in seralization. 
+# included in seralization.
 #
 # At present metadata and configuration are NOT serialized: #decorator, #display_configuration,
 # and #engine_id are not included in the serialization, so when loaded from serialization,
-# ResultItems will not have such things set. 
-# 
+# ResultItems will not have such things set.
+#
 # * Works by getting and setting instance variables directly, ignores getters/setters
 #
 # * This means decorated values are NOT included in serialization, the raw
 #   values are what is serialized. This is intended, we serialize internal
 #   state, not decoration which can be recreated. You should make sure the decorators you
-#   want are applied after de-serialization. 
+#   want are applied after de-serialization.
 #
 # * preserves html_safety status in serialization, by adding extra `_attr_htmlsafe: true` key/value
 #
@@ -31,22 +31,23 @@ module BentoSearch::Results::Serialization
     self._serializable_attr_options = {}
   end
 
+
   class_methods do
     # Just a macro to mark a property name serializable -- the name is
     # of an instance method that will be included in our serializations
-    # and de-serializations. 
+    # and de-serializations.
     #
     # Options:
     #   * collection_of: String fully qualified name of a class that is
     #       is also BentoSearch::Results::Serialization, the attribute
-    #       is an array of these. 
+    #       is an array of these.
     #   * serializer: String fully qualified class name of a serializer
     #        class that has a `dump` and a `load` for individual values,
     #        we just use it for Date now, see BentoSearch::Results::Serialization::Date
     def serializable_attr(symbol, options = nil)
       symbol = symbol.to_s
       self._serializable_attrs << symbol
-      if options 
+      if options
         self._serializable_attr_options[symbol] = options
       end
     end
@@ -67,14 +68,14 @@ module BentoSearch::Results::Serialization
 
 
         if _serializable_attr_options[key] && _serializable_attr_options[key][:collection_of]
-          klass = qualified_const_get(_serializable_attr_options[key][:collection_of])
+          klass = correct_const_get(_serializable_attr_options[key][:collection_of])
           value = value.collect do |item|
             klass.from_internal_state_hash(item)
           end
         end
 
         if _serializable_attr_options[key] && _serializable_attr_options[key][:serializer]
-          klass = qualified_const_get(_serializable_attr_options[key][:serializer])
+          klass = correct_const_get(_serializable_attr_options[key][:serializer])
           value = klass.load(value)
         end
 
@@ -92,18 +93,26 @@ module BentoSearch::Results::Serialization
       self.from_internal_state_hash( JSON.parse! json_str )
     end
 
+    def correct_const_get(str)
+      if Gem::Version.new(Rails.version) > Gem::Version.new('4.2.99')
+        const_get(str)
+      else
+        qualified_const_get(str)
+      end
+    end
+
   end
 
   def internal_state_hash
     hash = {}
     self._serializable_attrs.each do |accessor|
       accessor = accessor.to_s
-      value = self.instance_variable_get("@#{accessor}")
+      value = self.instance_variable_defined?("@#{accessor}") && self.instance_variable_get("@#{accessor}")
 
       next if value.blank?
 
       if _serializable_attr_options[accessor] && _serializable_attr_options[accessor][:serializer]
-        klass = self.class.qualified_const_get(_serializable_attr_options[accessor][:serializer])
+        klass = self.class.correct_const_get(_serializable_attr_options[accessor][:serializer])
         value = klass.dump(value)
       elsif value.respond_to?(:to_ary)
         value = value.to_ary.collect do |item|
@@ -133,4 +142,4 @@ module BentoSearch::Results::Serialization
     end
   end
 
-end
+end