bento_search 1.4.4 → 1.5.0

data/app/search_engines/bento_search/ebsco_host_engine.rb

@@ -358,12 +358,11 @@ class BentoSearch::EbscoHostEngine
     url =
       "#{configuration.base_url}/Search?prof=#{configuration.profile_id}&pwd=#{configuration.profile_password}"
 
-    query = ebsco_query_prepare  args[:query]
-
-
-    # wrap in (FI $query) if fielded search
-    if args[:search_field]
-      query = "(#{args[:search_field]} #{query})"
+    query = if args[:query].kind_of?(Hash)
+      # multi-field query
+      args[:query].collect {|field, query| fielded_query(query, field)}.join(" AND ")
+    else 
+      fielded_query(args[:query], args[:search_field])
     end
 
     # peer-reviewed only?
@@ -401,6 +400,17 @@ class BentoSearch::EbscoHostEngine
     return url
   end
 
+  def fielded_query(query, field = nil)
+    output = ebsco_query_prepare(query)
+
+    # wrap in (FI $query) if fielded search
+    if field.present?
+      output= "(#{field} #{query})"
+    end
+
+    return output
+  end
+
   # pass in a nokogiri representing an EBSCO <rec> result,
   # we'll turn it into a BentoSearch::ResultItem.
   def item_from_xml(xml_rec)
@@ -547,10 +557,20 @@ class BentoSearch::EbscoHostEngine
       "TI"    => {:semantic => :title},
       "SU"    => {:semantic => :subject},
       "IS"    => {:semantic => :issn},
-      "IB"    => {:semantic => :isbn}
+      "IB"    => {:semantic => :isbn},
+      "SO"    => {:semantic => :source_title},
+      # These may not be defined in all databases....
+      "VI"    => {:semantic => :volume},
+      "IP"    => {:semantic => :issue},
+      "SP"    => {:semantic => :start_page},
+      "AF"    => {:semantic => :author_affiliation}
     }
   end
 
+  def multi_field_search?
+    true
+  end
+
   def max_per_page
     # Actually only '50' if you ask for 'full' records, but I don't think
     # we need to do that ever, that's actually getting fulltext back!

data/app/search_engines/bento_search/google_books_engine.rb

@@ -205,6 +205,10 @@ module BentoSearch
       }
     end
 
+    def multi_field_search?
+      true
+    end
+
     protected
 
 
@@ -217,7 +221,10 @@ module BentoSearch
     # turns it into a URL for Google API. Factored out to make testing
     # possible.
     def args_to_search_url(arguments)
-      query = if arguments[:search_field]
+      query = if arguments[:query].kind_of? Hash
+        #multi-field
+        arguments[:query].collect {|field, query| fielded_query(query, field)}.join(" ")
+      elsif arguments[:search_field]
         fielded_query(arguments[:query], arguments[:search_field])
       else
         arguments[:query]

data/app/search_engines/bento_search/mock_engine.rb

@@ -9,6 +9,7 @@
 #                     specified per_page, or 10)
 # [:total_items]  total_items to report
 # [:sort_definitions] hash for #sort_definitions
+# [:search_field_definitions] hash for #search_field_definitions
 # [:link]             link to give to each item in results
 # [:error]            set to an error value hash and results returned
 #                     will all be failed? with that error hash. 
@@ -16,6 +17,7 @@
 #                     to be caught by BentoSearch::SearchEngine wrapper possibly. 
 # [:timing]           in seconds, fill out the results as if they took
 #                     this long. 
+# [:supports_multi_search] true or false
 class BentoSearch::MockEngine
     include BentoSearch::SearchEngine
     
@@ -58,11 +60,15 @@ class BentoSearch::MockEngine
     end
     
     def sort_definitions
-      configuration.sort_definitions || {}
+      configuration.sort_definitions.try(:to_hash).try(:stringify_keys) || {}
     end
     
     def search_field_definitions
-      configuration.search_field_definitions || {}
+      configuration.search_field_definitions.try(:to_hash).try(:stringify_keys) || {}
+    end
+
+    def multi_field_search?
+      configuration.multi_field_search || false
     end
     
 end

data/app/search_engines/bento_search/scopus_engine.rb

@@ -27,11 +27,14 @@ module BentoSearch
   # apparently by emailing directly to dave.santucci at elsevier dot com.  
   #    
   # Scopus API Docs:   
-  # * http://www.developers.elsevier.com/devcms/content-api-search-request
-  # * http://www.developers.elsevier.com/devcms/content/search-fields-overview
+  # * http://api.elsevier.com/documentation/SCOPUSSearchAPI.wadl
+  # * http://api.elsevier.com/documentation/search/SCOPUSSearchViews.htm
+  #
+  # Query syntax and search fields:
+  # * http://api.elsevier.com/documentation/search/SCOPUSSearchTips.htm
   #
   # Some more docs on response elements and query elements:
-  # * http://api.elsevier.com/content/search/#d0n14606
+  # * http://api.elsevier.com/content/search/#d0n14606  
   # 
   # Other API's in the suite not being used by this code at present: 
   # * http://www.developers.elsevier.com/devcms/content-api-retrieval-request
@@ -204,7 +207,14 @@ module BentoSearch
         # controlled and author-assigned keywords
         "KEY"         => {:semantic => :subject},
         "ISBN"        => {:semantic => :isbn},
-        "ISSN"        => {:semantic => :issn},              
+        "ISSN"        => {:semantic => :issn},
+        "VOLUME"      => {:semantic => :volume},
+        "ISSUE"       => {:semantic => :issue},
+        "PAGEFIRST"   => {:semantic => :start_page},
+        # Should we use SRCTITLE instead? I think exact match might be better?
+        "EXACTSRCTITLE" => {:semantic => :source_title},
+        "DOI"         => {:semantic => :doi},
+        "PUBYEAR"     => {:semantic => :year}
       }
     end
     
@@ -222,6 +232,9 @@ module BentoSearch
       }
     end
 
+    def multi_field_search?
+      true
+    end
             
     protected
     
@@ -282,10 +295,12 @@ module BentoSearch
     
      
     def scopus_url(args)
-      query = escape_query args[:query]
-      
-      if args[:search_field]
-        query = "#{args[:search_field]}(#{query})"
+      query = if args[:query].kind_of? Hash
+        args[:query].collect {|field, query| fielded_query(query,field)}.join(" AND ")
+      elsif args[:search_field]
+        fielded_query(args[:query], args[:search_field])
+      else
+        escape_query args[:query]
       end
       
       query = "#{configuration.base_url.chomp("/")}/content/search/index:#{configuration.cluster}?query=#{CGI.escape(query)}"
@@ -304,6 +319,10 @@ module BentoSearch
       
       return query
     end
+
+    def fielded_query(query, field)
+      "#{field}(#{escape_query query})"
+    end
     
   end
 end

data/app/search_engines/bento_search/summon_engine.rb

@@ -471,7 +471,7 @@ class BentoSearch::SummonEngine
         "ISBN"                => {:semantic => :isbn},
         "ISSN"                => {:semantic => :issn},
         "OCLC"                => {:semantic => :oclcnum},
-        "PublicationSeriesTitle" => {:semantic => :publication_title }
+        "PublicationSeriesTitle" => {:semantic => :source_title }
       }
   end
 

data/app/search_engines/bento_search/worldcat_sru_dc_engine.rb

@@ -263,12 +263,25 @@ class BentoSearch::WorldcatSruDcEngine
   #
   # returns CQL that is NOT uri escaped yet. 
   def construct_cql_query(args)
+    if args[:query].kind_of?(Hash)
+      # multi-field
+      args[:query].collect {|field, query| fielded_cql_query(query, field)}.join(" AND ")
+    else
+      fielded_cql_query(args[:query], args[:search_field] || "srw.kw")
+    end
+  end
+
+  # construct valid CQL for the API's "query" param, from search
+  # args. Tricky because we need to split terms/phrases ourselves
+  #
+  # returns CQL that is NOT uri escaped yet. 
+  def fielded_cql_query(query, field = nil)
     # default is srw.kw, Keyword anywhere. 
-    field = args[:search_field] || "srw.kw" 
+    field ||= "srw.kw" 
     
     # We need to split terms and phrases, so we can formulate
     # CQL with seperate clauses for each, bah. 
-    tokens = args[:query].split(%r{\s|("[^"]+")}).delete_if {|a| a.blank?}
+    tokens = query.split(%r{\s|("[^"]+")}).delete_if {|a| a.blank?}
     
 
     
@@ -311,7 +324,9 @@ class BentoSearch::WorldcatSruDcEngine
       "srw.au"      => {:semantic => :author},
       "srw.su"      => {:semantic => :subject},
       "srw.bn"      => {:semantic => :isbn},
-      # Oddly no ISSN index, all we get is 'number'
+      "srw.in"      => {:semantic => :issn},
+      "srw.dn"      => {:semantic => :lccn},
+      # generic 'number', probably not useful
       "srw.sn"      => {:semantic => :number},
       "srw.no"      => {:semantic => :oclcnum}
     }
@@ -332,5 +347,9 @@ class BentoSearch::WorldcatSruDcEngine
       :auth => false
     }
   end
+
+  def multi_field_search?
+    true
+  end
   
 end

data/config/locales/en.yml

@@ -46,6 +46,9 @@ en:
       isbn:         "ISBN"
       oclcnum:      "OCLCnum"
       lccn:         "LCCN"
+      doi:          "DOI"
       publisher:    "Publisher"
-      publication_title: "Publication"
-
+      source_title: "Publication"
+      volume:       "Volume"
+      issue:        "Issue"
+      start_page:   "Start Page"

data/lib/bento_search/version.rb

@@ -1,3 +1,3 @@
 module BentoSearch
-  VERSION = "1.4.4"
+  VERSION = "1.5.0"
 end

data/test/dummy/config/environments/development.rb

@@ -22,10 +22,6 @@ Dummy::Application.configure do
   # Only use best-standards-support built into browsers
   config.action_dispatch.best_standards_support = :builtin
 
-  # Log the query plan for queries taking more than this (works
-  # with SQLite, MySQL, and PostgreSQL)
-  config.active_record.auto_explain_threshold_in_seconds = 0.5
-
   # Do not compress assets
   config.assets.compress = false
 

data/test/dummy/config/environments/production.rb

@@ -60,8 +60,4 @@ Dummy::Application.configure do
 
   # Send deprecation notices to registered listeners
   config.active_support.deprecation = :notify
-
-  # Log the query plan for queries taking more than this (works
-  # with SQLite, MySQL, and PostgreSQL)
-  # config.active_record.auto_explain_threshold_in_seconds = 0.5
 end

data/test/search_engines/doaj_articles_engine_test.rb

@@ -0,0 +1,200 @@
+require 'test_helper'
+require 'uri'
+require 'cgi'
+
+class DoajArticlesEngineTest < ActiveSupport::TestCase
+  extend TestWithCassette
+
+  def setup    
+    @engine = BentoSearch::DoajArticlesEngine.new
+    # tell it not to send our bad API key
+  end
+
+  test_with_cassette("basic search", :doaj_articles) do
+    results = @engine.search("Breast cancer patients with lobular cancer more commonly have a father than a mother diagnosed with cancer")
+
+    assert_kind_of BentoSearch::Results, results    
+    assert ! results.failed?
+
+    assert_not_nil results.total_items
+    assert_equal 0, results.start
+    assert_equal 10, results.per_page
+    
+    assert_not_empty results
+    
+    first = results.first
+
+    assert_present first.unique_id
+    assert_equal "Article", first.format
+
+    assert_present first.title
+
+    assert_not_empty    first.authors
+    assert_not_empty    first.authors.first.display
+
+
+    assert_present first.source_title
+    assert_present first.issn
+    assert_present first.volume
+    assert_present first.issue
+
+    assert_present first.start_page
+
+    assert_present first.year
+    assert_present first.publication_date
+
+    assert_present first.abstract
+    assert first.abstract.html_safe?
+
+    assert_present first.link
+    assert first.link_is_fulltext?
+  end
+
+  test_with_cassette("pagination", :doaj_articles) do
+    results = @engine.search("cancer", :per_page => 20, :page => 3)
+    
+    assert ! results.failed?
+    
+    assert_equal 20, results.length
+    
+    assert_equal 20, results.size
+    assert_equal 40, results.start
+    assert_equal 20, results.per_page
+  end
+
+  test_with_cassette("catches errors", :doaj_articles) do
+    @engine.base_url = "https://doaj.org/api/v1/search/articles_bad_url/"
+
+    results = @engine.search("something")
+
+    assert results.failed?
+    assert_kind_of Hash, results.error
+    assert_present results.error[:message]
+    assert_present results.error[:status]    
+  end
+
+  test_with_cassette("live #get(identifier) round trip", :doaj_articles) do
+    results = @engine.search("cancer")
+
+    assert (! results.failed?)
+
+    item = @engine.get( results.first.unique_id )
+
+    assert_not_nil  item
+    assert_kind_of  BentoSearch::ResultItem, item
+  end
+
+  test_with_cassette("live get(identifier) raises on no results", :doaj_articles) do
+    assert_raises(BentoSearch::NotFound) { item = @engine.get( "no_such_id" ) }
+  end
+
+  test_with_cassette("multifield author-title", :doaj_articles) do
+    results = @engine.search(:query => {
+      :author => "Huxtable",
+      :title => '"Global Unions as the Missing Link in Labour Movement Studies"'
+    })
+
+    assert ! results.failed?
+
+    assert_present results
+  end
+
+  test_with_cassette("complex multi-field", :doaj_articles) do
+    results = @engine.search(:query => {
+      nil     => "Anti-war",
+      :author => "Caffentzis",
+      :title  => '"Respect Your Enemies" first rule of peace',
+      :source_title => '"Revista Theomai"'
+    })
+
+    assert ! results.failed?
+
+    assert_equal 1, results.total_items
+    assert_equal 1, results.count
+
+    result = results.first
+
+    assert_equal "Revista Theomai", result.source_title
+    assert_equal "Respect Your Enemies - The First Rule of Peace: An Essay Addressed to the U. S. Anti-war Movement", result.title
+  end
+
+  test "escapes spaces how DOAJ likes it" do
+    url = @engine.args_to_search_url(:query => "One Two")
+    parsed = URI.parse(url)
+    last_path = parsed.path.split('/').last
+
+    # %20 not + for space.
+    # %2B for "+""
+    assert_equal "%2BOne%20%2BTwo", last_path
+  end
+
+  test "escapes special chars" do
+    url = @engine.args_to_search_url(:query => "Me: And/Or You")
+
+    parsed = URI.parse(url)
+
+    last_path = parsed.path.split('/').last
+    last_path = CGI.unescape(last_path)
+
+    assert_equal "+Me\\: +And\\\/Or +You", last_path
+  end
+
+  test "generates fielded searches" do
+    url = @engine.args_to_search_url(:query => "Smith", :search_field => "bibjson.author.name")
+
+    parsed = URI.parse(url)
+
+    last_path = parsed.path.split('/').last
+    last_path = CGI.unescape(last_path)
+
+    assert_equal "+bibjson.author.name:(+Smith)", last_path
+  end
+
+  test "generates multi-field search" do
+    url = @engine.args_to_search_url(:query => {
+      nil     => "Anti-war",
+      :author => "Caffentzis",
+      :title  => '"Respect Your Enemies" first rule of peace'
+    })
+
+    parsed = URI.parse(url)
+
+    last_path = parsed.path.split('/').last
+    last_path = CGI.unescape(last_path)
+
+    assert_equal '+Anti\-war +author:(+Caffentzis) +title:(+"Respect Your Enemies" +first +rule +of +peace)', last_path
+  end
+
+  test "does not escape double quotes" do
+    # we want to allow them for phrase searching
+    url = @engine.args_to_search_url(:query => '"This is a phrase"')
+
+    parsed = URI.parse(url)
+
+    last_path = parsed.path.split('/').last
+    last_path = CGI.unescape(last_path)
+
+    assert_equal '+"This is a phrase"', last_path
+  end
+
+  test "multi-token fielded search" do
+    url = @engine.args_to_search_url(:query => 'apple orange "strawberry banana"', :search_field => "bibjson.title")
+
+    parsed = URI.parse(url)
+
+    last_path = parsed.path.split('/').last
+    last_path = CGI.unescape(last_path)
+
+    assert_equal '+bibjson.title:(+apple +orange +"strawberry banana")', last_path
+  end
+
+  test "adds sort to query url" do
+    url = @engine.args_to_search_url(:query => "cancer", :sort => 'date_desc')
+
+    parsed = URI.parse(url)
+    query  = CGI.parse(parsed.query)
+
+    assert_equal ["article.created_date:desc"], query["sort"]
+  end
+
+  end