bcms_google_mini_search 1.1.1 → 1.2.0

data/README.markdown

@@ -9,9 +9,12 @@ It consists of the following two portlets.
 
 Features:
 1. Allows for formatted results of GSA search results.
-2. Will display Key Matches (as of 1.1)
-3. Will display Synonyms/Related Queries (as of 1.1)
-4. Allows conditional overriding of collections (i.e. by default it will search one collection, but a 'site=OTHER_COLLECTION' param can be passed to override that)
+2. Will display Key Matches
+3. Will display Synonyms/Related Queries
+4. Allows conditional overriding of collections (i.e. by default it will search one default collection, but a 'site=OTHER_COLLECTION' param can be passed to override that)
+5. Sort by Date/Relevance - Users can now toggle the results display between date and relevance.
+6. Cached Links - Each result now correctly generate a link to the cached version of the document as stored by the GSA.
+7. [GSA Only] Narrow Your Search - Shows users a set of other suggested queries to allow them to 'Narrow Your Search', based on the current query and what results are stored in GSA. Only available for GSA instances, as Google Mini does not support Dynamic Result Clustering.
 
 Note: This module assume the BrowserCMS web site owner has access to their own GSA/Google Mini server, either hosted by
 themselves or a third party service.

data/app/models/search_result.rb

@@ -1,11 +1,18 @@
 class SearchResult
 
-  attr_accessor :number, :title, :url, :description, :size
+  # Creates a new GSA::Appliance from a GoogleMiniSearchPortlet.
+  #
+  def self.new_gsa(portlet)
+    options = {:portlet=>portlet}
+    normalize_query_options(options)
+    GSA::Appliance.new(options)
+  end
 
   #
   # Queries google mini by a specific URL to find all the results. Converts XML results to
   # a paging results of Search Results.
   #
+  # See SearchResult#query_url for acceptable _options_ params
   def self.find(query, options={})
     return QueryResult.new unless query
     xml_doc = fetch_xml_doc(query, options)
@@ -16,6 +23,14 @@ class SearchResult
     results
   end
 
+  def self.create_query(query, options={})
+    opts = options.clone
+    normalize_query_options(opts)
+    opts[:query] = query
+    opts[:engine] = GSA::Engine.new({:host => opts[:host]})
+    GSA::Query.new(opts)
+  end
+
   def self.parse_results_count(xml_doc)
     root = xml_doc.root
     count = root.elements["RES/M"]
@@ -26,16 +41,7 @@ class SearchResult
     root = xml_doc.root
     results = []
     xml_doc.elements.each('GSP/RES/R') do |ele|
-      result = SearchResult.new
-      result.number = ele.attributes["N"]
-      result.title = ele.elements["T"].text
-      result.url = ele.elements["U"].text
-      result.description = ele.elements["S"].text
-      
-      doc_size_ele = ele.elements["HAS/C"]
-      result.size = doc_size_ele ? doc_size_ele.attributes["SZ"] : ""
-
-      results << result
+      results << GSA::Result.new(ele)
     end
     results
   end
@@ -59,39 +65,76 @@ class SearchResult
     num_pages
   end
 
+  # Construct a query url for the GSA.
+  #
+  # @param [String] query
+  # @param [Hash] options
+  # @option :host
+  # @option :start
+  # @option :front_end
+  # @option :collection
+  # @option :sort
+  # @option :as_xml [Boolean] Determines if the results are returned as xml or html. Default to false.
+  def self.query_url(query, options)
+    options[:as_xml] = true if options[:as_xml].nil?
 
-  def self.build_mini_url(options, query)
-    portlet = find_search_engine_portlet(options)
     encoded_query = CGI::escape(query)
 
-    site = portlet.collection_name
-    if options[:site]
-      site = options[:site]
-    end
-    # encoded_query = query
-    url = "#{portlet.service_url}/search?q=#{encoded_query}&output=xml_no_dtd&client=#{portlet.front_end_name}&site=#{site}&filter=0"
+    # Turns off automatic results filter (filter=0), which when set to 1, allows mini to reduces the # of similar/duplicate results,
+    # but makes it hard to determine the total # of results.
+    url = "#{options[:host]}/search?q=#{encoded_query}&output=xml_no_dtd&client=#{options[:front_end]}&site=#{options[:collection]}&filter=0"
     if options[:start]
       url = url + "&start=#{options[:start]}"
     end
-    return url    
+
+    if options[:sort]
+      url += "&sort=#{CGI::escape(options[:sort])}"
+    end
+
+    unless options[:as_xml]
+      url += "&proxystylesheet=#{options[:front_end]}"
+    end
+
+    # Ensure both results (oe) and query/input values (ie) are interpreted as UTF-8.
+    # See http://code.google.com/apis/searchappliance/documentation/46/xml_reference.html#request_i18n
+    url += "&oe=UTF-8&ie=UTF-8"
+    return url
+  end
+
+  def self.create_url_for_query(options, query)
+    normalize_query_options(options)
+    return query_url(query, options)
+  end
+
+  def self.normalize_query_options(options)
+    portlet = find_search_engine_portlet(options)
+    options[:front_end] = portlet.front_end_name
+    options[:collection] = portlet.collection_name
+    options[:host] = portlet.service_url
+
+    options[:collection] = options.delete(:site) if options[:site]
   end
 
   def self.find_search_engine_portlet(options)
     portlet = GoogleMiniSearchEnginePortlet.new
     if options[:portlet]
-      portlet = options[:portlet]
+      portlet = options.delete(:portlet)
     end
     portlet
   end
 
+  # Given a URL, GET it and return the contents
+  # @param [String] url A URL formatted string
+  def self.fetch_document(url)
+    Rails.logger.debug {"GSA: Fetching '#{url}'"}
+    Net::HTTP.get(URI.parse(url))
+  end
+
   # Fetches the xml response from the google mini server.
   def self.fetch_xml_doc(query, options={})
-    # Turns off automatic results filter (filter=0), which when set to 1, allows mini to reduces the # of similar/duplicate results,
-    # but makes it hard to determine the total # of results.
-    url = build_mini_url(options, query)
-    response = Net::HTTP.get(URI.parse(url))
-    xml_doc = REXML::Document.new(response)
-    return xml_doc
+    url = create_url_for_query(options, query)
+    response = fetch_document(url)
+    REXML::Document.new(response)
   end
 
   def self.parse_key_matches(xml_doc)
@@ -122,6 +165,10 @@ class SearchResult
     attr_accessor :results_count, :num_pages, :current_page, :start, :query, :pages, :key_matches, :synonyms
     attr_writer :path
 
+    # For what these codes mean, see http://code.google.com/apis/searchappliance/documentation/46/xml_reference.html#request_sort
+    SORT_BY_DATE_PARAM = "date:D:S:d1"
+    SORT_BY_RELEVANCE_PARAM = "date:D:L:d1"
+
     def initialize(array=[])
       # Need to set defaults so an empty result set works.
       self.start = 0
@@ -146,11 +193,15 @@ class SearchResult
       previous_start >= 0 && num_pages > 1
     end
 
+    # Returns a range of pages that should appear in the pager control. This is design to mimic GSA's pager control,
+    # which will show up to 20 pages at a time, based on the 'range' of pages around the current page.
+    #
+    # i.e. on page 12:  < 2 3 4 5 6 7 8 9 10 11 _12_ 13 14 15 16 17 18 19 20 21 22 >
     def pages
-      if num_pages > 1
-        return (1..num_pages)
-      end
-      []
+      return [] if num_pages <= 1
+      first_page = current_page - 10 > 1 ? current_page - 10 : 1
+      last_page = current_page + 9 > num_pages ? num_pages : current_page + 9
+      (first_page..last_page)
     end
 
     def next_start
@@ -170,6 +221,28 @@ class SearchResult
       1
     end
 
+    # Determines the current Query is sorting by date.
+    #
+    # @param [Hash] params The query parameter from the search page. (same as Rails params)
+    def sorting_by_date?(params)
+      params[:sort] == SearchResult::QueryResult::SORT_BY_DATE_PARAM
+    end
+
+    def path_for(new_query)
+      "#{path}?query=#{new_query}"
+    end
+    # Return the path to sort the current search results by date.
+    #
+    # Based on http://code.google.com/apis/searchappliance/documentation/46/xml_reference.html#request_sort
+    def sort_by_date_path
+      "#{path}?query=#{query}&sort=#{SORT_BY_DATE_PARAM}"
+    end
+
+    # Returns the path to sort the current results by relevance (inverse of sort_by_date_path).
+    def sort_by_relevance_path
+      "#{path}?query=#{query}&sort=#{SORT_BY_RELEVANCE_PARAM}"
+    end
+
     def next_page_path
       "#{path}?query=#{query}&start=#{next_start}"
     end

data/app/portlets/google_mini_search_engine_portlet.rb

@@ -1,12 +1,28 @@
 class GoogleMiniSearchEnginePortlet < Portlet
 
-  enable_template_editor true
-  
+  enable_template_editor false
+
   def render
-    @query = params[:query]
     @site = params[:site]
     @start = params[:start] ? params[:start].to_i : 0
-    @results = SearchResult.find(@query, {:start => @start, :portlet => @portlet, :site=>@site})
+    options = {:start => @start, :portlet => self, :site=>@site, :sort=>params[:sort]}
+    query_string = params[:query]
+
+    @results = SearchResult.find(query_string, options.clone) # Need to clone, so that :portlet isn't removed for the 2nd call.
+
+    # This is temporary, while the API is being reworked. Ideally, the search results would contain a reference
+    # to the query, so that two X calls isn't needed.
+    @query = SearchResult.create_query(query_string, options.clone)
+
+    if narrow_your_search?
+      @appliance = SearchResult.new_gsa(self)
+      @suggested_queries = @appliance.find_narrow_search_results(query_string)
+    end
   end
-    
+
+  # Handles the fact that all portlet attributes, including checkboxes like enable_your_search are stored as strings.
+  def narrow_your_search?
+    self.enable_narrow_your_search == "1"
+  end
+
 end

data/app/views/layouts/templates/default.html.erb.html.erb

@@ -0,0 +1,17 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
+    <title><%= page_title %></title>
+    <%= yield :html_head %>
+  </head>
+  <body style="margin: 0; padding: 0; text-align: center;">
+    <%= cms_toolbar %>
+    <div id="wrapper" style="width: 700px; margin: 0 auto; text-align: left; padding: 30px">
+      Breadcrumbs: <%= render_breadcrumbs %>
+      Main Menu: <%= render_menu %>
+      <h1><%= page_title %></h1>
+      <%= container :main %>
+    </div>
+  </body>
+</html>

data/app/views/portlets/google_mini_search_engine/_form.html.erb

@@ -3,4 +3,6 @@
 <%= f.cms_text_field :service_url, :default_value=> "http://", :instructions => "Full Domain name where the Google Mini server is hosted, i.e. 'http://mini.somedomain.com'." %>
 <%= f.cms_text_field :collection_name, :instructions => "Copy the name of the Collection from Google Mini here. (Can pass 'site' param to override as well).", :default_value=>"default_collection" %>
 <%= f.cms_text_field :front_end_name, :instructions => "Copy the name of the Collection front end from Google Mini here.", :default_value=>"default_frontend" %>
+<%= f.cms_check_box :enable_narrow_your_search, :instructions => "The 'Narrow Your Search' feature is a only available for Google Search Appliance, not with Google Mini.",
+                    :label=>"Enable Narrowing?" %>
 <%= f.cms_template_editor :template %>

data/app/views/portlets/google_mini_search_engine/render.html.erb

@@ -1,33 +1,55 @@
+
 <h2>Search Results</h2>
-For '<%= @results.query %>', found <%= @results.results_count %> results. <br />
-<% if @results.previous_page? %><%= link_to h("< Back"), @results.previous_page_path %><% end %>
-<% if @results.next_page? %><%= link_to h("Next >"), @results.next_page_path %><% end %>
+For '<%= @results.query %>', found <%= @results.results_count %> results. <br/>
+<%= link_to_unless @results.sorting_by_date?(params), "Sort by Date", @results.sort_by_date_path %> /
+<%= link_to_if @results.sorting_by_date?(params), "Sort by Relevance", @results.sort_by_relevance_path %> <br/>
+<% if @results.previous_page? %><%= link_to h("< Back"), @results.previous_page_path %>
+<% end %>
+<% if @results.next_page? %><%= link_to h("Next >"), @results.next_page_path %>
+<% end %>
 <% if @results.key_matches? %>
     <ul class="key_matches">
-    <% @results.key_matches.each do |match| %>
-        <li><%= link_to match.title, match.url %></li>    
-    <% end %>
+      <% @results.key_matches.each do |match| %>
+          <li><%= link_to match.title, match.url %></li>
+      <% end %>
     </ul>
 <% end %>
 <% if @results.synonyms? %>
     <span class="synonyms">You could also try:
-    <% @results.synonyms.each do |synonym| %>
+      <% @results.synonyms.each do |synonym| %>
         <%= link_to synonym.label, synonym.url %>    
     <% end %>
     </span>
 <% end %>
 <ul class="search_results">
-  <% @results.each do |result|%>
-    <li>
-        <%= result.number %> <%= link_to result.title, result.url,  :class=>"search_result_title" %><br />
-        <span class="search_result_description"><%= result.description %></span> <br />
-        <span class="search_result_url"><%= result.url %></span> - 
+  <% @results.each do |result| %>
+      <li>
+        <%= result.number %> <%= link_to result.title, result.url, :class=>"search_result_title" %>
+        <br/>
+        <span class="search_result_description"><%= result.description %></span> <br/>
+        <span class="search_result_url"><%= result.url %></span> -
         <span class="search_result_size"><%= result.size %></span>
-    </li>
+        <span class="search_result_cached"><%= link_to "Cached", result.cached_document_url(@query) %></span>
+
+      </li>
   <% end %>
 </ul>
-<% if @results.previous_page? %><%= link_to h("< Back"), @results.previous_page_path %><% end %>
-<%  @results.pages.each do |p| %>
-      <%= link_to_unless @results.current_page?(p), p, @results.page_path(p) %>
+
+<% if @portlet.narrow_your_search? %>
+<div id="clustering">
+  <h3>Narrow your search</h3>
+  <ul>
+    <% @suggested_queries.each_with_index do |suggestion, i| %>
+    <li id="cluster_label<%= i %>"><%= link_to suggestion.query, @results.path_for(suggestion.query) %></li>
+    <% end %>
+  </ul>
+</div>
+<% end %>
+
+<% if @results.previous_page? %><%= link_to h("< Back"), @results.previous_page_path %>
+<% end %>
+<% @results.pages.each do |p| %>
+    <%= link_to_unless @results.current_page?(p), p, @results.page_path(p) %>
+<% end %>
+<% if @results.next_page? %><%= link_to h("Next >"), @results.next_page_path %>
 <% end %>
-<% if @results.next_page? %><%= link_to h("Next >"), @results.next_page_path %><% end %>

data/lib/bcms_google_mini_search.rb

@@ -1 +1,2 @@
 require 'bcms_google_mini_search/routes'
+require 'bcms_google_mini_search/gsa'

data/lib/bcms_google_mini_search/gsa.rb

@@ -0,0 +1,144 @@
+# A general purpose API for querying a Google Search Appliance for results.
+module GSA
+
+  # Represents a single instance of a Google Mini
+  class Engine
+    attr_accessor :host, :port, :path, :default_collection, :default_front_end
+
+    def initialize(options = {})
+      self.port = 8080
+      self.path = "/search"
+      self.host = options[:host]
+      self.default_front_end = options[:front_end]
+      self.default_collection = options[:collection]
+    end
+
+    # Return a Hash suitable to be passed to SearchResult.find()
+    def options_for_query
+      {:host=>host, :front_end=>default_front_end, :collection=>default_collection}
+    end
+  end
+
+  # GSA support slightly different features than Google Mini.
+  class Appliance < Engine
+
+
+
+    # Fetch a set of Suggested queries, based on a given query.
+    #
+    # See http://code.google.com/apis/searchappliance/documentation/50/admin_searchexp/ce_understanding.html#h3drc for the spec.
+    # See http://groups.google.com/group/Google-Search-Appliance-Help/browse_thread/thread/8a821fc8475a5e24/34a5c3c8ab74ed35?hl=en&lnk=gst#34a5c3c8ab74ed35
+    #   for details about how this is implemented.
+    #
+    # Clustering (aka Narrow your search) is only supported by GSA.
+    # @param [String] query A term to fetch 'suggested' queries for/
+    # @return [GSA::SuggestedQueries] A set of suggested queries
+    def find_narrow_search_results(query)
+      return [] unless query
+
+      url = narrow_search_results_url(query)
+      document = SearchResult.fetch_document(url)
+      SuggestedQueries.new(document)
+    end
+
+    private
+
+    # Returns the URL to GET a set of Dynamic Search Clusters for a particular query.
+    def narrow_search_results_url(query)
+      "#{host}/cluster?coutput=xml&q=#{CGI::escape(query)}&site=#{default_collection}&client=#{default_front_end}&output=xml_no_dtd&oe=UTF-8&ie=UTF-8"
+    end
+  end
+
+  # Represents a set of suggested search terms, based on results from a GSA.
+  # AKA DynamicResultClusters
+  class SuggestedQueries
+    def initialize(xml_as_string)
+      @clusters = []
+      doc = REXML::Document.new(xml_as_string)
+      doc.elements.each('toplevel/Response/cluster/gcluster') do |ele|
+        @clusters << Suggestion.new(ele.elements["label"].attributes["data"])
+      end
+
+    end
+
+    delegate :each, :each_with_index, :size, '[]', :to=>:clusters
+
+    private
+
+    def clusters
+      @clusters
+    end
+
+
+    # Since generating are handled in the view, this might no longer be necessary a separate class, and could probably be converted into a String.
+    class Suggestion
+      attr_accessor :query
+
+      def initialize(query)
+        self.query = query
+      end
+
+    end
+  end
+
+
+
+
+  class Query
+    attr_reader :engine, :query, :front_end, :collection
+
+    def initialize(options={})
+      @engine = options[:engine]
+      @query = options[:query]
+      @front_end = options[:front_end]
+      @collection = options[:collection]
+    end
+  end
+
+  # Represent a collection of results from a GSA search.
+  class Results
+
+    attr_accessor :query
+
+
+  end
+
+  # Represents a single result (aka Hit) from a GSA query.
+  # Defined by http://code.google.com/apis/searchappliance/documentation/46/xml_reference.html#results_xml_tag_r
+  class Result
+    attr_accessor :number, :title, :url, :description, :size, :cache_id, :results
+
+    # @param [RXEML::Element] xml_element The <R> result from GSA a search.
+    def initialize(xml_element = nil)
+      return if xml_element == nil
+      self.number = xml_element.attributes["N"]
+      self.title = xml_element.elements["T"].text
+      self.url = xml_element.elements["U"].text
+      self.description = xml_element.elements["S"].text
+
+      cache_element = xml_element.elements["HAS/C"]
+
+      if cache_element
+        self.size = cache_element.attributes["SZ"]
+        self.cache_id = cache_element.attributes["CID"]
+      else
+        self.size = ""
+        self.cache_id=""
+      end
+
+    end
+
+    # Returns the value for q if a user wants to request the cached version of this document.
+    def cached_document_param
+      param = "cache:#{cache_id}:#{url}"
+      if results
+        param += "+#{results.query}"
+      end
+      param
+    end
+
+    def cached_document_url(gsa_query)
+      SearchResult.query_url(cached_document_param, {:host=>gsa_query.engine.host, :collection=>gsa_query.collection, :front_end=>gsa_query.front_end, :as_xml=>false})
+    end
+  end
+end

data/test/unit/gsa_test.rb

@@ -0,0 +1,182 @@
+require "test_helper"
+
+class GSA::ApplianceTest < ActiveSupport::TestCase
+
+  test "Create Engine" do
+    app = GSA::Engine.new
+    app.host = "http://example.com"
+    assert_equal "http://example.com", app.host
+    assert_equal 8080, app.port
+    assert_equal "/search", app.path
+  end
+
+  test "Create from options" do
+    app = GSA::Engine.new({:host=>"http://example.com", :front_end=>"F", :collection=>"C"})
+    assert_equal "http://example.com", app.host
+    assert_equal "F", app.default_front_end
+    assert_equal "C", app.default_collection
+  end
+
+  test "options_for_query" do
+    options = {:host=>"http://example.com", :front_end=>"F", :collection=>"C"}
+    app = GSA::Engine.new(options)
+    assert_equal options, app.options_for_query
+  end
+end
+
+class SuggestedQueries < ActiveSupport::TestCase
+
+  def setup
+    @cluster_xml = <<XML
+<toplevel>
+  <Response>
+    <algorithm data="Concepts"/>
+    <t_cluster int="95"/>
+    <cluster>
+      <gcluster>
+        <label data="label 0"/>
+      </gcluster>
+      <gcluster>
+        <label data="label 1"/>
+      </gcluster>
+      <gcluster>
+        <label data="label 2"/>
+      </gcluster>
+      <gcluster>
+        <label data="label 3"/>
+      </gcluster>
+      <gcluster>
+        <label data="label 4"/>
+      </gcluster>
+      <gcluster>
+        <label data="label 5"/>
+      </gcluster>
+      <gcluster>
+        <label data="label 6"/>
+      </gcluster>
+      <gcluster>
+        <label data="label 7"/>
+      </gcluster>
+      <gcluster>
+        <label data="label 8"/>
+      </gcluster>
+      <gcluster>
+        <label data="label 9"/>
+      </gcluster>
+    </cluster>
+  </Response>
+</toplevel>
+XML
+
+    @app = GSA::Appliance.new(:host=>"http://example.com", :collection=>"My_Collection", :front_end=>"My_Front")
+
+  end
+
+  test "parse results" do
+    suggested_queries = GSA::SuggestedQueries.new(@cluster_xml)
+    assert_equal 10, suggested_queries.size
+    assert_equal "label 0", suggested_queries[0].query
+    assert_equal "label 9", suggested_queries[9].query
+  end
+
+  test "Google Search Appliances should generate the URL for Dynamic Results Clustering" do
+    expected = "http://example.com/cluster?coutput=xml&q=TEST&site=My_Collection&client=My_Front&output=xml_no_dtd&oe=UTF-8&ie=UTF-8"
+    assert_equal expected, @app.send(:narrow_search_results_url, "TEST")
+  end
+
+  test "URLs will escape queries" do
+    expected = "http://example.com/cluster?coutput=xml&q=TWO+WORDS&site=My_Collection&client=My_Front&output=xml_no_dtd&oe=UTF-8&ie=UTF-8"
+    assert_equal expected, @app.send(:narrow_search_results_url, "TWO WORDS")
+  end
+
+  test "find narrowed search results" do
+    @app.expects(:narrow_search_results_url).with("TEST").returns("EXPECTED URL")
+    SearchResult.expects(:fetch_document).with("EXPECTED URL").returns("XML Content")
+    expected_suggestions = mock()
+    GSA::SuggestedQueries.expects(:new).with("XML Content").returns(expected_suggestions)
+
+    assert_equal expected_suggestions, @app.find_narrow_search_results("TEST")
+
+  end
+
+  test "each_with_index" do
+    suggestions = GSA::SuggestedQueries.new(@cluster_xml)
+    count = 0
+    suggestions.each_with_index do |s, i|
+      assert_not_nil s
+      assert_not_nil i
+      count += 1
+    end
+    assert_equal suggestions.size, count
+  end
+
+  test "each" do
+    suggestions = GSA::SuggestedQueries.new(@cluster_xml)
+    count = 0
+    suggestions.each do |s|
+      assert_not_nil s
+      count += 1
+    end
+    assert_equal suggestions.size, count
+  end
+
+  test "A nil query should return an empty set of Suggested Queries" do
+    r = @app.find_narrow_search_results(nil)
+    assert_equal 0, r.size
+  end
+end
+
+class ResultsTest < ActiveSupport::TestCase
+
+  def setup
+    @results = GSA::Results.new
+    @results.query = "QUERY"
+    @result = GSA::Result.new
+    @result.results = @results
+
+    @engine = GSA::Engine.new(:host=>"http://mini.someurl.com")
+    @query = GSA::Query.new(:engine=>@engine, :collection=>"COLLECT", :front_end=>"FRONT_END")
+  end
+
+  test "Create result from xml" do
+    xml = <<XML
+  <R N="1">
+    <U>http://someurl.com</U>
+    <T>TITLE</T>
+    <S>BLURB</S>
+    <HAS>
+      <C SZ="1k" CID="Ax1j5"/>
+    </HAS>
+  </R>
+XML
+    xml_doc = REXML::Document.new(xml)
+    result = GSA::Result.new(xml_doc.elements.first)
+    assert_equal "http://someurl.com", result.url
+    assert_equal "TITLE", result.title
+    assert_equal "BLURB", result.description
+    assert_equal "1k", result.size
+    assert_equal "1", result.number
+    assert_equal "Ax1j5", result.cache_id
+  end
+
+  test "cached_document_param" do
+    @result.cache_id = "A2B"
+    @result.url = "http://example.com"
+
+    assert_equal "cache:A2B:http://example.com+QUERY", @result.cached_document_param
+  end
+
+  test "cached_document_param with no result attached" do
+    @result.results = nil
+    @result.cache_id = "A2B"
+    @result.url = "http://example.com"
+
+    assert_equal "cache:A2B:http://example.com", @result.cached_document_param
+  end
+
+  test "cached_document_url" do
+    @result.expects(:cached_document_param).returns("cache:something")
+    expected_url = "http://mini.someurl.com/search?q=cache%3Asomething&output=xml_no_dtd&client=FRONT_END&site=COLLECT&filter=0&proxystylesheet=FRONT_END&oe=UTF-8&ie=UTF-8"
+    assert_equal expected_url, @result.cached_document_url(@query)
+  end
+end

data/test/unit/portlets/google_mini_search_engine_portlet_test.rb

@@ -2,14 +2,52 @@ require File.join(File.dirname(__FILE__), '/../../test_helper')
 
 class GoogleMiniSearchEngineTest < ActiveSupport::TestCase
 
+  def setup
+    @portlet = GoogleMiniSearchEnginePortlet.new(:name=>"Engine", :path => "/engine")
+  end
+
   test "Should be able to create new instance of a portlet" do
     assert GoogleMiniSearchEnginePortlet.create!(:name => "New Portlet")
   end
 
-
-
   test "Path attribute can be set in constructor" do
     portlet = GoogleMiniSearchEnginePortlet.create!(:name=>"Engine", :path => "/engine")
     assert_equal "/engine", portlet.path
   end
+
+  test "Determine if Narrow Your Search is enabled?" do
+    @portlet.enable_narrow_your_search = "1"
+    assert_equal true, @portlet.narrow_your_search?
+
+    @portlet.enable_narrow_your_search = "0"
+    assert_equal false, @portlet.narrow_your_search?
+
+    @portlet.enable_narrow_your_search = ""
+    assert_equal false, @portlet.narrow_your_search?
+
+    @portlet.enable_narrow_your_search = nil
+    assert_equal false, @portlet.narrow_your_search?
+  end
+
+
+end
+
+class RenderTest < ActiveSupport::TestCase
+  def setup
+    @portlet = GoogleMiniSearchEnginePortlet.new(:name=>"Engine", :path => "/engine")
+    @params = {:start => 10, :query => "X", :site=>'default_collection', :sort=>"date:D:S:d1"}
+    @portlet.expects('params').returns(@params).at_least_once
+  end
+
+  test "Sort params" do
+    SearchResult.expects(:find).with("X", {:start => 10, :portlet => @portlet, :site=>'default_collection', :sort=>"date:D:S:d1"})
+    @portlet.render
+  end
+
+  test "Find narrow queries only if enabled" do
+    @portlet.enable_narrow_your_search = "1"
+    GSA::Appliance.any_instance.expects(:find_narrow_search_results).with("X")
+    SearchResult.expects(:find).with("X", {:start => 10, :portlet => @portlet, :site=>'default_collection', :sort=>"date:D:S:d1"})
+    @portlet.render
+  end
 end

data/test/unit/search_result_test.rb

@@ -1,5 +1,6 @@
 require File.join(File.dirname(__FILE__), '/../test_helper')
 
+
 class SearchResultTest < ActiveSupport::TestCase
 
   def setup
@@ -205,14 +206,7 @@ EOF
     assert_equal [], results.pages
   end
 
-  test "Behavior of ranges" do
-    c = 0
-    (1..4).each_with_index do |i, count|
-      assert_equal count + 1, i
-      c = count
-    end
-    assert_equal 3, c
-  end
+
 
   test "current_page should check to see if the current page matches" do
     results = SearchResult::QueryResult.new
@@ -225,45 +219,6 @@ EOF
 
   end
 
-  test "Path to next page" do
-    results = SearchResult::QueryResult.new
-    results.start = 0
-    results.path = "/search/search-results"
-    results.query = "X"
-
-    assert_equal "/search/search-results?query=X&start=10", results.next_page_path
-  end
-
-  test "Path to previous page" do
-    results = SearchResult::QueryResult.new
-    results.start = 20
-    results.path = "/search/search-results"
-    results.query = "X"
-
-    assert_equal "/search/search-results?query=X&start=10", results.previous_page_path
-  end
-
-  test "Sets path to default search-results" do
-    results = SearchResult::QueryResult.new
-    assert_equal "/search/search-results", results.path
-  end
-
-  test "Setting path overrides the defaults" do
-    results = SearchResult::QueryResult.new
-    results.path = "/other"
-    assert_equal "/other", results.path
-  end
-
-  test "page_path" do
-    results = SearchResult::QueryResult.new
-    results.query = "X"
-
-    assert_equal "/search/search-results?query=X&start=0", results.page_path(1)
-    assert_equal "/search/search-results?query=X&start=10", results.page_path(2)
-    assert_equal "/search/search-results?query=X&start=20", results.page_path(3)
-    assert_equal "/search/search-results?query=X&start=30", results.page_path(4)
-
-  end
 
   test "Portlet attributes are used to look up path" do
     portlet = GoogleMiniSearchEnginePortlet.new(:name=>"Engine", :path => "/engine")
@@ -285,12 +240,48 @@ EOF
             :name=>"Engine", :path => "/engine", :service_url => "http://mini.someurl.com",
             :collection_name => "COLLECT", :front_end_name => "FRONT_END")
 
-    url = SearchResult.build_mini_url({:portlet => portlet}, "STUFF")
-    assert_equal "http://mini.someurl.com/search?q=STUFF&output=xml_no_dtd&client=FRONT_END&site=COLLECT&filter=0", url
+    url = SearchResult.create_url_for_query({:portlet => portlet}, "STUFF")
+    assert_equal "http://mini.someurl.com/search?q=STUFF&output=xml_no_dtd&client=FRONT_END&site=COLLECT&filter=0&oe=UTF-8&ie=UTF-8", url
+
+    url = SearchResult.create_url_for_query({:portlet => portlet, :start=>100}, "STUFF")
+    assert_equal "http://mini.someurl.com/search?q=STUFF&output=xml_no_dtd&client=FRONT_END&site=COLLECT&filter=0&start=100&oe=UTF-8&ie=UTF-8", url
 
-    url = SearchResult.build_mini_url({:portlet => portlet, :start=>100}, "STUFF")
-    assert_equal "http://mini.someurl.com/search?q=STUFF&output=xml_no_dtd&client=FRONT_END&site=COLLECT&filter=0&start=100", url
+  end
+
+  test "Create Engine and Query from portlet attributes" do
+    portlet = GoogleMiniSearchEnginePortlet.new(
+            :name=>"Engine", :path => "/engine", :service_url => "http://mini.someurl.com",
+            :collection_name => "COLLECT", :front_end_name => "FRONT_END")
 
+    query = SearchResult.create_query("therapy", {:portlet=>portlet})
+    assert_equal "http://mini.someurl.com", query.engine.host
+    assert_equal portlet.front_end_name, query.front_end
+    assert_equal portlet.collection_name, query.collection
+    assert_equal "therapy", query.query
+  end
+
+  test "should look up options from portlet and add to hash" do
+    portlet = GoogleMiniSearchEnginePortlet.new(
+            :name=>"Engine", :path => "/engine", :service_url => "http://mini.someurl.com",
+            :collection_name => "COLLECT", :front_end_name => "FRONT_END")
+    options = {:portlet=>portlet}
+    SearchResult.normalize_query_options(options)
+
+    assert_equal "FRONT_END", options[:front_end]
+    assert_equal "COLLECT", options[:collection]
+    assert_equal "http://mini.someurl.com", options[:host]
+    assert_equal nil, options[:portlet]
+  end
+
+  test "Create an appliance from attributes in the portlet." do
+    portlet = GoogleMiniSearchEnginePortlet.new(
+            :name=>"Engine", :path => "/engine", :service_url => "http://mini.someurl.com",
+            :collection_name => "COLLECT", :front_end_name => "FRONT_END")
+
+    gsa = SearchResult.new_gsa(portlet)
+    assert_equal "http://mini.someurl.com", gsa.host
+    assert_equal "FRONT_END", gsa.default_front_end
+    assert_equal "COLLECT", gsa.default_collection
   end
 
   test "Explicitly passing a collection in will query with that rather than a default collection" do
@@ -298,13 +289,23 @@ EOF
             :name=>"Engine", :path => "/engine", :service_url => "http://mini.someurl.com",
             :collection_name => "COLLECT", :front_end_name => "FRONT_END")
 
-    url = SearchResult.build_mini_url({:portlet => portlet, :site=>"ANOTHER_COLLECTION"}, "STUFF")
-    assert_equal "http://mini.someurl.com/search?q=STUFF&output=xml_no_dtd&client=FRONT_END&site=ANOTHER_COLLECTION&filter=0", url
+    url = SearchResult.create_url_for_query({:portlet => portlet, :site=>"ANOTHER_COLLECTION"}, "STUFF")
+    assert_equal "http://mini.someurl.com/search?q=STUFF&output=xml_no_dtd&client=FRONT_END&site=ANOTHER_COLLECTION&filter=0&oe=UTF-8&ie=UTF-8", url
   end
 
   test "Handles multiword queries" do
-    url = SearchResult.build_mini_url({}, "One Two")
-    assert_equal "/search?q=One+Two&output=xml_no_dtd&client=&site=&filter=0", url
+    url = SearchResult.create_url_for_query({}, "One Two")
+    assert_equal "/search?q=One+Two&output=xml_no_dtd&client=&site=&filter=0&oe=UTF-8&ie=UTF-8", url
+  end
+
+  test "sort is added to google mini query" do
+    url = SearchResult.create_url_for_query({:sort=>"XYZ"}, "STUFF")
+    assert_equal "/search?q=STUFF&output=xml_no_dtd&client=&site=&filter=0&sort=XYZ&oe=UTF-8&ie=UTF-8", url
+  end
+
+  test "sort params are escaped" do
+    url = SearchResult.create_url_for_query({:sort=>"date:D:S:d1"}, "STUFF")
+    assert_equal "/search?q=STUFF&output=xml_no_dtd&client=&site=&filter=0&sort=date%3AD%3AS%3Ad1&oe=UTF-8&ie=UTF-8", url
   end
 
   test "Handles keymatches in results" do
@@ -464,5 +465,123 @@ EOF
       assert_equal "TITLE 2", results[1].title
       assert_equal "BLURB 2", results[1].description
       assert_equal "", results[1].size
+  end
+
+end
+
+class SearchPathsTest < ActiveSupport::TestCase
+
+  def setup
+    @results = SearchResult::QueryResult.new
+    @results.start = 0
+    @results.path = "/search/search-results"
+    @results.query = "X"
+  end
+
+  test "path_for" do
+    assert_equal "/search/search-results?query=Y", @results.path_for("Y")
+  end
+  
+  test "sort by date" do
+    assert_equal "#{@results.path}?query=#{@results.query}&sort=#{SearchResult::QueryResult::SORT_BY_DATE_PARAM}", @results.sort_by_date_path
+  end
+
+  test "sort by relevance" do
+    assert  @results.sort_by_relevance_path != @results.sort_by_date_path, "Paths should not be the same."
+    assert_equal "#{@results.path}?query=#{@results.query}&sort=#{SearchResult::QueryResult::SORT_BY_RELEVANCE_PARAM}", @results.sort_by_relevance_path
+  end
+
+  test "Path to next page" do
+    assert_equal "/search/search-results?query=X&start=10", @results.next_page_path
+  end
+
+  test "Path to previous page" do
+    @results.start = 20
+    assert_equal "/search/search-results?query=X&start=10", @results.previous_page_path
+  end
+
+  test "Sets path to default search-results" do
+    assert_equal "/search/search-results", @results.path
+  end
+
+  test "Setting path overrides the defaults" do
+    @results.path = "/other"
+    assert_equal "/other", @results.path
+  end
+
+  test "page_path" do
+    assert_equal "/search/search-results?query=X&start=0", @results.page_path(1)
+    assert_equal "/search/search-results?query=X&start=10", @results.page_path(2)
+    assert_equal "/search/search-results?query=X&start=20", @results.page_path(3)
+    assert_equal "/search/search-results?query=X&start=30", @results.page_path(4)
+  end
+
+  test "sorting_by_date?" do
+    assert_equal true, @results.sorting_by_date?({:sort=>SearchResult::QueryResult::SORT_BY_DATE_PARAM})
+    assert_equal false, @results.sorting_by_date?({:sort=>SearchResult::QueryResult::SORT_BY_RELEVANCE_PARAM})
+    assert_equal false, @results.sorting_by_date?({})
+  end
+end
+
+
+class PagingTest < ActiveSupport::TestCase
+
+  def setup
+    @results = SearchResult::QueryResult.new
+    and_the_max_number_pages_is 100
+  end
+
+  test "Behavior of Ruby Ranges" do
+      c = 0
+      (1..4).each_with_index do |i, count|
+        assert_equal count + 1, i
+        c = count
+      end
+      assert_equal 3, c
     end
+
+
+  test "When on page 1, show links for pages 1 - 10" do
+    when_current_page_is(1)
+    assert_equal (1..10), @results.pages
+  end
+
+  test "When on page 11, show links for pages 1-20" do
+    when_current_page_is(11)
+    assert_equal (1..20), @results.pages
+  end
+
+  test "When on page 12, show links for pages 2-22" do
+    when_current_page_is 12
+    assert_equal (2..21), @results.pages
+  end
+
+  test "When less than 10 pages only show up to last page" do
+    when_current_page_is 1
+    and_the_max_number_pages_is 4
+
+    assert_equal (1..4), @results.pages
+  end
+
+  test "When no results, should be empty set of pages." do
+    when_current_page_is 1
+    and_the_max_number_pages_is 0
+    assert_equal [], @results.pages
+  end
+
+  test "With one page, return a single page." do
+    when_current_page_is 1
+    and_the_max_number_pages_is 1
+    assert_equal [], @results.pages, "A single page of results needs no pager control"
+  end
+
+  private
+
+  def and_the_max_number_pages_is(number)
+    @results.expects(:num_pages).returns(number).times(0..5)
+  end
+
+  def when_current_page_is(current_page)
+    @results.expects(:current_page).returns(current_page).times(0..5)
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: bcms_google_mini_search
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 31
   prerelease: false
   segments: 
   - 1
-  - 1
-  - 1
-  version: 1.1.1
+  - 2
+  - 0
+  version: 1.2.0
 platform: ruby
 authors: 
 - BrowserMedia
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-09 00:00:00 -05:00
+date: 2011-04-05 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -33,16 +33,19 @@ files:
 - app/models/search_result.rb
 - app/portlets/google_mini_search_engine_portlet.rb
 - app/portlets/search_box_portlet.rb
+- app/views/layouts/templates/default.html.erb.html.erb
 - app/views/portlets/google_mini_search_engine/_form.html.erb
 - app/views/portlets/google_mini_search_engine/render.html.erb
 - app/views/portlets/search_box/_form.html.erb
 - app/views/portlets/search_box/render.html.erb
 - lib/bcms_google_mini_search.rb
+- lib/bcms_google_mini_search/gsa.rb
 - lib/bcms_google_mini_search/routes.rb
 - rails/init.rb
 - README.markdown
 - test/performance/browsing_test.rb
 - test/test_helper.rb
+- test/unit/gsa_test.rb
 - test/unit/helpers/search_engine_helper_test.rb
 - test/unit/portlets/google_mini_search_engine_portlet_test.rb
 - test/unit/portlets/search_box_portlet_test.rb
@@ -52,8 +55,8 @@ homepage: http://github.com/browsermedia/bcms_google_mini_search
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -84,6 +87,7 @@ summary: A Google Mini Search Module for BrowserCMS
 test_files: 
 - test/performance/browsing_test.rb
 - test/test_helper.rb
+- test/unit/gsa_test.rb
 - test/unit/helpers/search_engine_helper_test.rb
 - test/unit/portlets/google_mini_search_engine_portlet_test.rb
 - test/unit/portlets/search_box_portlet_test.rb