inquisitio 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dff28f9b5d191622a0c07139b2f03edb8ec8c87d
-  data.tar.gz: f03905452101150efceed98062cd8a9a9666b13b
+  metadata.gz: f276ddda623e737c046197a26d4696dc87859265
+  data.tar.gz: 60eac7285494fc1adad7edb022ca36e6030f9db5
 SHA512:
-  metadata.gz: 40362fa85a4a8bb8b71aa3b51f1d2aead37829b82cea692649fd0217d9936ac76e3b75f36de5cd467317d4d4bac606a98e325f03cd586a583bbf347ea819a2a7
-  data.tar.gz: 5068a7af2ad3f093d11821332c60cc0d3be383ec4dffa7fec84779a77d820a6d6caa84aefb48dcafaeee0a7006a2cddb9864a311696c157df92409a719d7f8ec
+  metadata.gz: 59bc49ebc2a61c0dcf17118ad7de9329be918b13088df8c78e9175ec8bb964135523e3972a743864b704057442e4e4f39286933ed3b131528682004eb96246fe
+  data.tar.gz: b48f671ce616589f245bd9ecf308920832900ca35711385579b9544324769e3f37e0d7b08436f9a5ade1a63539467b0c569a250d1f1dba783e3d3ae7c079689c

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+2.1.0 / 2015-07-22
+[FEATURE] Add support for filter queries (fq) as Searcher#filter
+[FEATURE] Add support for facets as Searcher#facets
+
 2.0.0 / 2015-07-21
 [FEATURE] Removed support for 2011-02-01 api
 

data/lib/inquisitio/facets.rb

@@ -0,0 +1,16 @@
+module Inquisitio
+  class Facets
+    extend Forwardable
+
+    def initialize(facets)
+      @facets = JSON.parse(facets.to_json, symbolize_names: true)
+    end
+
+    def fields
+      @facets.keys
+    end
+
+    def_delegator :@facets, :[]
+
+  end
+end

data/lib/inquisitio/search_url_builder.rb

@@ -6,78 +6,78 @@ module Inquisitio
     end
 
     def initialize(options = {})
-      @query = options[:query]
-      @named_fields = options[:named_fields] || {}
+      @query_terms = options[:query][:terms]
+      @query_named_fields = options[:query][:named_fields] || {}
+      @filter_query = options[:filter_query] || {}
+      @filter_query_terms = @filter_query[:terms] || []
+      @filter_query_named_fields = @filter_query[:named_fields] || {}
+      @facets = options[:facets] || {}
       @q_options = options[:q_options] || {}
       @expressions = options[:expressions] || {}
-      @arguments = options[:arguments] || {}
       @return_fields = options[:return_fields] || []
       @size = options[:size] || Inquisitio.config.default_search_size
       @start = options[:start] || 0
       @sort = options[:sort] || {}
-      @q_parser = options[:q_parser] || (is_simple? ? nil : :structured)
+      @q_parser = options[:q_parser] || (is_simple?(@query_terms, @query_named_fields) ? nil : :structured)
     end
 
     def build
-      components = [url_root]
-      components << (is_simple? ? simple_query : boolean_query)
-      components << "&q.parser=#{@q_parser}" if @q_parser && Inquisitio.config.api_version == '2013-01-01'
-      components << "&return=#{CGI::escape(@return_fields.join(',').gsub('\'', ''))}" unless @return_fields.empty?
-      components << arguments
-      components << '&q.options=' + CGI::escape(@q_options.to_json) unless @q_options.empty?
+      components = []
+      components << 'q=' + CGI::escape(build_query(@query_terms, @query_named_fields))
+      if !@filter_query_terms.empty? || !@filter_query_named_fields.empty?
+        components << 'fq=' + CGI::escape(build_query(@filter_query_terms, @filter_query_named_fields))
+      end
+      components << "q.parser=#{@q_parser}" if @q_parser
+      components << "return=#{CGI::escape(@return_fields.join(',').gsub('\'', ''))}" unless @return_fields.empty?
+      # components << arguments
+      @facets.each do |field,settings|
+        components << "facet.#{field}=#{CGI::escape(settings.to_json)}"
+      end
+      components << 'q.options=' + CGI::escape(@q_options.to_json) unless @q_options.empty?
       @expressions.each do |name, expression|
-        components << "&expr.#{name}=" + CGI::escape(expression)
+        components << "expr.#{name}=" + CGI::escape(expression)
       end
-      components << "&size=#{@size}" unless @arguments[:size]
-      components << "&start=#{@start}" unless @arguments[:start] || @start == 0 || @start == '0'
-      components << '&sort=' + @sort.map { |k, v| "#{k}%20#{v}" }.join(',') unless @sort.empty?
-      components.join('')
+      components << "size=#{@size}"
+      components << "start=#{@start}" unless @start == 0 || @start == '0'
+      components << 'sort=' + @sort.map { |k, v| "#{k}%20#{v}" }.join(',') unless @sort.empty?
+      url_root + components.join('&')
     end
 
-    def is_simple?
-      @named_fields.empty? && Array(@query).size == 1
+    def is_simple?(terms, named_fields)
+      Array(terms).size == 1 && named_fields.empty?
     end
 
     private
-    def simple_query
-      "q=#{CGI::escape(@query.first)}"
-    end
-
-    def boolean_query
 
+    def build_query(terms, named_fields)
+      return terms.first if is_simple?(terms, named_fields)
       query_blocks = []
+      query_blocks << '(and' unless terms.empty? || named_fields.empty?
 
-      if Array(@query).empty?
-#        query_blocks = []
-      elsif @query.size == 1
-        query_blocks << "'#{sanitise(@query.first)}'"
-      else
-        query_blocks << "(or #{@query.map { |q| "'#{sanitise(q)}'" }.join(' ')})"
+      if terms.size == 1
+        query_blocks << "'#{dequote(terms.first)}'"
+      elsif terms.size > 1
+        query_blocks << "(or #{terms.map { |q| "'#{dequote(q)}'" }.join(' ')})"
       end
 
-      query_blocks += @named_fields.map do |key, value|
-        if value.is_a?(String)
-          "#{sanitise(key)}:'#{sanitise(value)}'"
-        elsif value.is_a?(Array)
-          "(or #{value.map { |v| "#{sanitise(key)}:'#{sanitise(v)}'" }.join(" ")})"
-        else
-          raise InquisitioError.new('Filter values must be strings or arrays.')
-        end
+      return query_blocks.join(' ') if named_fields.empty?
+
+      query_blocks += named_fields.map do |key, value|
+        raise InquisitioError.new('Named field values must be strings or arrays.') unless value.is_a?(String) || value.is_a?(Array)
+        block = "#{dequote(key)}:'#{dequote(value)}'" if value.is_a?(String)
+        block = "#{dequote(key)}:'#{dequote(value.first)}'" if value.is_a?(Array) && value.size == 1
+        block = "(or #{value.map { |v| "#{dequote(key)}:'#{dequote(v)}'" }.join(' ')})" if value.is_a?(Array) && value.size > 1
+        block
       end
 
-      "q=#{CGI::escape("(and #{query_blocks.join(' ')})").gsub('&', '%26')}"
+      query_blocks << ')' unless terms.empty? || named_fields.empty?
+      query_blocks.join(' ')
     end
 
-    def sanitise(value)
+    def dequote(value)
       value.to_s.gsub('\'', '')
     end
 
-
-    def arguments
-      return '' if @arguments.nil?
-      @arguments.map { |key, value| "&#{key.to_s.gsub('\'', '')}=#{value.to_s.gsub('\'', '')}" }.join("")
-    end
-
     def url_root
       "#{Inquisitio.config.search_endpoint}/#{Inquisitio.config.api_version}/search?"
     end

data/lib/inquisitio/searcher.rb

@@ -11,8 +11,11 @@ module Inquisitio
 
     def initialize(params = nil)
       @params = params || {
-          criteria: [],
-          named_fields: {},
+          query_terms: [],
+          query_named_fields: {},
+          filter_query_terms: [],
+          filter_query_named_fields: {},
+          facets: {},
           per: 10,
           page: 1,
           returns: [],
@@ -20,7 +23,6 @@ module Inquisitio
           q_options: {},
           expressions: {}
       }
-      @failed_attempts = 0
 
       yield(self) if block_given?
     end
@@ -67,19 +69,42 @@ module Inquisitio
     def where(value)
       clone do |s|
         if value.is_a?(Array)
-          s.params[:criteria] += value
+          s.params[:query_terms] += value
         elsif value.is_a?(Hash)
           value.each do |k, v|
             k = k.to_sym
-            s.params[:named_fields][k] ||= []
+            s.params[:query_named_fields][k] ||= []
             if v.is_a?(Array)
-              s.params[:named_fields][k] = v
+              s.params[:query_named_fields][k] = v
             else
-              s.params[:named_fields][k] << v
+              s.params[:query_named_fields][k] << v
             end
           end
         else
-          s.params[:criteria] << value
+          s.params[:query_terms] << value
+        end
+      end
+    end
+
+    def filter(value)
+      clone do |s|
+        if value.nil?
+          s.params[:filter_query_terms] = []
+          s.params[:filter_query_named_fields] = {}
+        elsif value.is_a?(Array)
+          s.params[:filter_query_terms] += value
+        elsif value.is_a?(Hash)
+          value.each do |k, v|
+            k = k.to_sym
+            s.params[:filter_query_named_fields][k] ||= []
+            if v.is_a?(Array)
+              s.params[:filter_query_named_fields][k] = v
+            else
+              s.params[:filter_query_named_fields][k] << v
+            end
+          end
+        else
+          s.params[:filter_query_terms] << value
         end
       end
     end
@@ -90,6 +115,12 @@ module Inquisitio
       end
     end
 
+    def facets(value)
+      clone do |s|
+        s.params[:facets] = value
+      end
+    end
+
     def expressions(value)
       clone do |s|
         s.params[:expressions] = value
@@ -130,6 +161,10 @@ module Inquisitio
       end
     end
 
+    def result_facets
+      @result_facets ||= Facets.new(cloudsearch_body['facets'])
+    end
+
     # Proxy everything to the results so that this this class
     # transparently acts as an Array.
     def method_missing(name, *args, &block)
@@ -139,35 +174,41 @@ module Inquisitio
     private
 
     def results
-      return @results unless @results.nil?
-
-      Inquisitio.config.logger.info("Performing search: #{search_url}")
-      response = Excon.get(search_url)
-      raise InquisitioError.new("Search failed with status code: #{response.status} Message #{response.body}") unless response.status == 200
-      body = JSON.parse(response.body)
-      time_ms = body['status']['time-ms']
-      @results = Results.new(body['hits']['hit'],
-                             params[:page],
-                             params[:per],
-                             body['hits']['found'],
-                             time_ms)
-    rescue => e
-      @failed_attempts += 1
-      Inquisitio.config.logger.error("Exception Performing search: #{search_url} #{e}")
-
-      if @failed_attempts < Inquisitio.config.max_attempts
-        Inquisitio.config.logger.error("Retrying search #{@failed_attempts}/#{Inquisitio.config.max_attempts}")
-        results
-      else
-        raise InquisitioError.new('Exception performing search')
+      @results ||= begin
+        Results.new(cloudsearch_body['hits']['hit'],
+                    params[:page],
+                    params[:per],
+                    cloudsearch_body['hits']['found'],
+                    cloudsearch_body['status']['time-ms'])
+      end
+    end
+
+    def cloudsearch_body
+      failed = 0
+      @cloudsearch_body ||= begin
+        Inquisitio.config.logger.info("Performing search: #{search_url}")
+        response = Excon.get(search_url)
+        raise InquisitioError.new("Search failed with status code: #{response.status} Message #{response.body}") unless response.status == 200
+        JSON.parse(response.body)
+      rescue => e
+        failed += 1
+        Inquisitio.config.logger.error("Exception Performing search: #{search_url} #{e}")
+
+        if failed < Inquisitio.config.max_attempts
+          Inquisitio.config.logger.error("Retrying search #{@failed_attempts}/#{Inquisitio.config.max_attempts}")
+          retry
+        else
+          raise InquisitioError.new('Exception performing search')
+        end
       end
     end
 
     def search_url
       @search_url ||= begin
         SearchUrlBuilder.build(
-            query: params[:criteria],
-            named_fields: params[:named_fields],
+            query: {terms: params[:query_terms], named_fields: params[:query_named_fields]},
+            filter_query: {terms: params[:filter_query_terms], named_fields: params[:filter_query_named_fields]},
+            facets: params[:facets],
             size: params[:per],
             start: params[:per] * (params[:page] - 1),
             sort: params[:sort],

data/lib/inquisitio/version.rb

@@ -1,3 +1,3 @@
 module Inquisitio
-  VERSION = '2.0.0'
+  VERSION = '2.1.0'
 end

data/lib/inquisitio.rb

@@ -7,6 +7,7 @@ require 'inquisitio/document'
 require 'inquisitio/search_url_builder'
 require 'inquisitio/searcher'
 require 'inquisitio/results'
+require 'inquisitio/facets'
 require 'inquisitio/indexer'
 
 module Inquisitio

data/test/facets_test.rb

@@ -0,0 +1,72 @@
+require File.expand_path('../test_helper', __FILE__)
+
+module Inquisitio
+  class FacetsTest < Minitest::Test
+    def setup
+      super
+      @search_endpoint = 'http://my.search-endpoint.com'
+      Inquisitio.config.search_endpoint = @search_endpoint
+      @body = {
+          'status' => {'rid' => '9d3b24b', 'time-ms' => 3},
+          'hits' => {'found' => 1, 'start' => 0, 'hit' => [{'data' => {'id' => ['20'], 'title' => ['Foobar2'], 'type' => ['Module_Dog']}}], },
+          'facets' => {
+              'genres' => {
+                  'buckets' => [
+                      {'value' => 'Drama', 'count' => 12},
+                      {'value' => 'Romance', 'count' => 9}]
+              },
+              'rating' => {
+                  'buckets' => [
+                      {'value' => '6.3', 'count' => 3},
+                      {'value' => '6.2', 'count' => 2},
+                      {'value' => '7.1', 'count' => 2},
+                      {'value' => '7.6', 'count' => 1}]
+              },
+          }
+      }.to_json
+
+      Excon.defaults[:mock] = true
+      Excon.stub({}, {body: @body, status: 200})
+    end
+
+    def teardown
+      super
+      Excon.stubs.clear
+    end
+
+    def test_should_return_fields
+      searcher = Searcher.where('star_wars')
+      facets = searcher.result_facets
+      assert_equal [:genres, :rating], facets.fields
+    end
+
+    def test_should_access_buckets_by_symbols
+      searcher = Searcher.where('star_wars')
+      facets = searcher.result_facets
+      refute_nil facets[:genres]
+      refute_nil facets[:rating]
+    end
+
+    def test_should_have_bucket_lengths
+      searcher = Searcher.where('star_wars')
+      facets = searcher.result_facets
+      assert_equal 2, facets[:genres][:buckets].length
+      assert_equal 4, facets[:rating][:buckets].length
+    end
+
+    def test_should_have_bucket_entry_values
+      searcher = Searcher.where('star_wars')
+      facets = searcher.result_facets
+      assert_equal 'Drama', facets[:genres][:buckets].first[:value]
+      assert_equal '6.2', facets[:rating][:buckets][1][:value]
+    end
+
+    def test_should_have_bucket_entry_counts
+      searcher = Searcher.where('star_wars')
+      facets = searcher.result_facets
+      assert_equal 12, facets[:genres][:buckets].first[:count]
+      assert_equal 2, facets[:rating][:buckets][1][:count]
+    end
+
+  end
+end

data/test/results_test.rb

@@ -41,7 +41,10 @@ module Inquisitio
     end
 
     def test_should_return_time_taken
-      body = "{\"status\": {\"rid\" : \"u9aP4eYo8gIK0csK\", \"time-ms\": 4}, \"hits\" : {\"#{@found}\": 33, \"#{@start}\": 0, \"hit\":#{@expected_results.to_json} }}"
+      body = {
+          'status' => {'rid' => 'u9aP4eYo8gIK0csK', 'time-ms' => 4},
+          'hits' => {'found' => 33, 'start' => 0, 'hit' => @expected_results}
+      }.to_json
       Excon.stubs.clear
       Excon.stub({}, {body: body, status: 200})
 

data/test/search_url_builder_test.rb

@@ -10,94 +10,109 @@ module Inquisitio
       Inquisitio.config.default_search_size = '10'
     end
 
+    def test_uses_endpoint
+      url = SearchUrlBuilder.build(query: {terms: ['Star Wars']})
+      assert (/^#{@search_endpoint}\/2013-01-01\/search(\?|$)/ =~ url), "Should start with endpoint: #{url}"
+    end
+
     def test_create_correct_search_url_with_single_criteria_query
-      url = SearchUrlBuilder.build(query: ['Star Wars'])
-      expected_url = 'http://my.search-endpoint.com/2013-01-01/search?q=Star+Wars&size=10'
-      assert_equal expected_url, url
+      url = SearchUrlBuilder.build(query: {terms: ['Star Wars']})
+      assert /(&|\?)q=Star\+Wars(&|$)/ =~ url
+    end
+
+    def test_create_correct_search_url_with_single_criteria_query_and_single_filter_criteria
+      url = SearchUrlBuilder.build(query: {terms: ['Star Wars']}, filter_query: {terms: ['A New Hope']})
+      assert /(&|\?)q=Star\+Wars(&|$)/ =~ url, "should have query in url: #{url}"
+      assert /(&|\?)fq=A\+New\+Hope(&|$)/ =~ url, "should have filter query in url: #{url}"
     end
 
     def test_create_correct_search_url_with_ampersand
-      url = SearchUrlBuilder.build(query: ['Star&Wars'])
+      url = SearchUrlBuilder.build(query: {terms: ['Star&Wars']})
       expected_url = 'http://my.search-endpoint.com/2013-01-01/search?q=Star%26Wars&size=10'
       assert_equal expected_url, url
     end
 
     def test_create_correct_search_url_with_multiple_criteria_should_use_structured_parser
-      url = SearchUrlBuilder.build(query: ['Star Wars', 'Episode One'])
-      expected_url = 'http://my.search-endpoint.com/2013-01-01/search?q=%28and+%28or+%27Star+Wars%27+%27Episode+One%27%29%29&q.parser=structured&size=10'
+      url = SearchUrlBuilder.build(query: {terms: ['Star Wars', 'Episode One']})
+      expected_url = 'http://my.search-endpoint.com/2013-01-01/search?q=%28or+%27Star+Wars%27+%27Episode+One%27%29&q.parser=structured&size=10'
       assert_equal expected_url, url
     end
 
     def test_create_correct_search_url_with_multiple_criteria_with_ampersand
-      url = SearchUrlBuilder.build(query: ['Star&Wars', 'Episode One'])
-      expected_url = 'http://my.search-endpoint.com/2013-01-01/search?q=%28and+%28or+%27Star%26Wars%27+%27Episode+One%27%29%29&q.parser=structured&size=10'
+      url = SearchUrlBuilder.build(query: {terms: ['Star&Wars', 'Episode One']})
+      expected_url = 'http://my.search-endpoint.com/2013-01-01/search?q=%28or+%27Star%26Wars%27+%27Episode+One%27%29&q.parser=structured&size=10'
       assert_equal expected_url, url
     end
 
     def test_create_correct_search_url_including_return_fields
-      url = SearchUrlBuilder.build(query: ['Star Wars'], return_fields: %w(title year %))
+      url = SearchUrlBuilder.build(query: {terms: ['Star Wars']}, return_fields: %w(title year %))
       expected_url = 'http://my.search-endpoint.com/2013-01-01/search?q=Star+Wars&return=title%2Cyear%2C%25&size=10'
       assert_equal expected_url, url
     end
 
     def test_create_search_url_with_default_size
-      url = SearchUrlBuilder.build(query: ['Star Wars'])
+      url = SearchUrlBuilder.build(query: {terms: ['Star Wars']})
       expected_url = 'http://my.search-endpoint.com/2013-01-01/search?q=Star+Wars&size=10'
       assert_equal expected_url, url
     end
 
     def test_create_search_url_overriding_default_size
-      url = SearchUrlBuilder.build(query: ['Star Wars'], size: '200')
+      url = SearchUrlBuilder.build(query: {terms: ['Star Wars']}, size: '200')
       expected_url = 'http://my.search-endpoint.com/2013-01-01/search?q=Star+Wars&size=200'
       assert_equal expected_url, url
     end
 
     def test_create_search_url_with_start_and_default_size
-      url = SearchUrlBuilder.build(query: ['Star Wars'], start: '20')
+      url = SearchUrlBuilder.build(query: {terms: ['Star Wars']}, start: '20')
       assert /(&|\?)start=20(&|$)/ =~ url
       assert /(&|\?)size=10(&|$)/ =~ url
     end
 
     def test_create_search_url_with_start_and_size
-      url = SearchUrlBuilder.build(query: ['Star Wars'], start: '2', size: '200')
+      url = SearchUrlBuilder.build(query: {terms: ['Star Wars']}, start: '2', size: '200')
       assert /(&|\?)start=2(&|$)/ =~ url
       assert /(&|\?)size=200(&|$)/ =~ url
     end
 
     def test_create_search_url_with_named_fields_array
-      url = SearchUrlBuilder.build(query: ['Star Wars'], named_fields: {genre: ['Animation', 'Action']})
-      #TODO make the result use fq
-      expected_url = 'http://my.search-endpoint.com/2013-01-01/search?q=%28and+%27Star+Wars%27+%28or+genre%3A%27Animation%27+genre%3A%27Action%27%29%29&q.parser=structured&size=10'
-      assert_equal expected_url, url
+      url = SearchUrlBuilder.build(query: {terms: ['Star Wars'], named_fields: {genre: %w(Animation Action)}})
+      assert /(&|\?)q=%28and\+%27Star\+Wars%27\+%28or\+genre%3A%27Animation%27\+genre%3A%27Action%27%29\+%29(&|$)/ =~ url
+      assert /(&|\?)q.parser=structured(&|$)/ =~ url
+    end
+
+    def test_create_search_url_with_named_fields_in_filter_query
+      url = SearchUrlBuilder.build(query: {terms: ['Star Wars']}, filter_query: {terms: ['A New Hope'], named_fields: {genre: %w(Animation Action)}})
+      assert /(&|\?)q=Star\+Wars(&|$)/ =~ url, "should have query in url: #{url}"
+      assert /(&|\?)fq=%28and\+%27A\+New\+Hope%27\+%28or\+genre%3A%27Animation%27\+genre%3A%27Action%27%29\+%29(&|$)/ =~ url, "should have filter query in url: #{url}"
     end
 
     def test_create_search_url_with_query_options
-      url = SearchUrlBuilder.build(query: ['Star Wars'], q_options: {fields: %w(title^2.0 plot^0.5)})
+      url = SearchUrlBuilder.build(query: {terms: ['Star Wars']}, q_options: {fields: %w(title^2.0 plot^0.5)})
       expected_url = 'http://my.search-endpoint.com/2013-01-01/search?q=Star+Wars&q.options=%7B%22fields%22%3A%5B%22title%5E2.0%22%2C%22plot%5E0.5%22%5D%7D&size=10'
       assert_equal expected_url, url
     end
 
     def test_create_search_url_with_query_defaultoperator_option
-      url = SearchUrlBuilder.build(query: ['Star Wars'], q_options: {defaultOperator: 'or'})
+      url = SearchUrlBuilder.build(query: {terms: ['Star Wars']}, q_options: {defaultOperator: 'or'})
       expected_url = 'http://my.search-endpoint.com/2013-01-01/search?q=Star+Wars&q.options=%7B%22defaultOperator%22%3A%22or%22%7D&size=10'
       assert_equal expected_url, url
     end
 
     def test_create_search_url_with_expressions
-      url = SearchUrlBuilder.build(query: ['Star Wars'], expressions: {rank1: 'log10(clicks)*_score', rank2: 'cos( _score)'})
+      url = SearchUrlBuilder.build(query: {terms: ['Star Wars']}, expressions: {rank1: 'log10(clicks)*_score', rank2: 'cos( _score)'})
       expected_url = 'http://my.search-endpoint.com/2013-01-01/search?q=Star+Wars&expr.rank1=log10%28clicks%29%2A_score&expr.rank2=cos%28+_score%29&size=10'
       assert_equal expected_url, url
     end
 
     def test_create_url_with_parser
-      url = SearchUrlBuilder.build(query: ['Star Wars'], q_parser: :structured)
+      url = SearchUrlBuilder.build(query: {terms: ['Star Wars']}, q_parser: :structured)
       expected_url = 'http://my.search-endpoint.com/2013-01-01/search?q=Star+Wars&q.parser=structured&size=10'
       assert_equal expected_url, url
     end
 
     def test_create_url_with_overridden_parser
-      url = SearchUrlBuilder.build(query: ['Star Wars', 'Star Trek'], q_parser: :simple)
-      expected_url = 'http://my.search-endpoint.com/2013-01-01/search?q=%28and+%28or+%27Star+Wars%27+%27Star+Trek%27%29%29&q.parser=simple&size=10'
+      url = SearchUrlBuilder.build(query: {terms: ['Star Wars', 'Star Trek']}, q_parser: :simple)
+      expected_url = 'http://my.search-endpoint.com/2013-01-01/search?q=%28or+%27Star+Wars%27+%27Star+Trek%27%29&q.parser=simple&size=10'
       assert_equal expected_url, url
     end
 

data/test/searcher_test.rb

@@ -55,20 +55,20 @@ module Inquisitio
     def test_where_sets_variable
       criteria = 'Star Wars'
       searcher = Searcher.where(criteria)
-      assert_equal [criteria], searcher.params[:criteria]
+      assert_equal [criteria], searcher.params[:query_terms]
     end
 
     def test_where_sets_variable_with_an_array
       criteria = %w(Star Wars)
       searcher = Searcher.where(criteria)
-      assert_equal criteria, searcher.params[:criteria]
+      assert_equal criteria, searcher.params[:query_terms]
     end
 
     def test_where_doesnt_mutate_searcher
       initial_criteria = 'star wars'
       searcher = Searcher.where(initial_criteria)
       searcher.where('Return of the Jedi')
-      assert_equal [initial_criteria], searcher.params[:criteria]
+      assert_equal [initial_criteria], searcher.params[:query_terms]
     end
 
     def test_where_returns_a_new_searcher
@@ -80,28 +80,28 @@ module Inquisitio
     def test_where_sets_named_fields
       named_fields = {genre: 'Animation'}
       searcher = Searcher.where(named_fields)
-      assert_equal({genre: ['Animation']}, searcher.params[:named_fields])
+      assert_equal({genre: ['Animation']}, searcher.params[:query_named_fields])
     end
 
     def test_where_merges_named_fields
       named_fields1 = {genre: 'Animation'}
       named_fields2 = {foobar: 'Cat'}
       searcher = Searcher.where(named_fields1).where(named_fields2)
-      assert_equal({genre: ['Animation'], foobar: ['Cat']}, searcher.params[:named_fields])
+      assert_equal({genre: ['Animation'], foobar: ['Cat']}, searcher.params[:query_named_fields])
     end
 
     def test_symbolizes_where_keys
       named_fields1 = {'genre' => 'Animation'}
       named_fields2 = {'foobar' => 'Cat'}
       searcher = Searcher.where(named_fields1).where(named_fields2)
-      assert_equal({genre: ['Animation'], foobar: ['Cat']}, searcher.params[:named_fields])
+      assert_equal({genre: ['Animation'], foobar: ['Cat']}, searcher.params[:query_named_fields])
     end
 
     def test_where_merges_named_fields_with_same_key
       named_fields1 = {genre: 'Animation'}
       named_fields2 = {genre: 'Action'}
       searcher = Searcher.where(named_fields1).where(named_fields2)
-      assert_equal({genre: %w(Animation Action)}, searcher.params[:named_fields])
+      assert_equal({genre: %w(Animation Action)}, searcher.params[:query_named_fields])
     end
 
     def test_where_gets_correct_url
@@ -113,21 +113,22 @@ module Inquisitio
     def test_where_gets_correct_url_with_fields_in_search
       searcher = Searcher.where(title: 'Star Wars')
       search_url = searcher.send(:search_url)
-      assert(search_url.include?('q=%28and+%28or+title%3A%27Star+Wars%27%29%29&q.parser=structured'), "Search url should include query: #{search_url}")
+      assert /(\?|&)q=title%3A%27Star\+Wars%27(&|$)/ =~ search_url, "Search url should include query: #{search_url}"
+      assert /(\?|&)q.parser=structured(&|$)/ =~ search_url, "Search url should include parser: #{search_url}"
     end
 
     def test_where_works_with_array_in_a_hash
       criteria = {thing: %w(foo bar)}
       searcher = Searcher.where(criteria)
-      assert_equal criteria, searcher.params[:named_fields]
+      assert_equal criteria, searcher.params[:query_named_fields]
     end
 
     def test_where_works_with_string_and_array
       str_criteria = 'Star Wars'
       hash_criteria = {thing: %w(foo bar)}
       searcher = Searcher.where(str_criteria).where(hash_criteria)
-      assert_equal hash_criteria, searcher.params[:named_fields]
-      assert_equal [str_criteria], searcher.params[:criteria]
+      assert_equal hash_criteria, searcher.params[:query_named_fields]
+      assert_equal [str_criteria], searcher.params[:query_terms]
     end
 
     def test_per_doesnt_mutate_searcher
@@ -303,7 +304,6 @@ module Inquisitio
     end
 
     def test_should_not_specify_return_by_default
-      Inquisitio.config.api_version = '2013-01-01'
       searcher = Searcher.where('Star Wars')
       assert_equal [], searcher.params[:returns]
       refute searcher.send(:search_url).include? '&return='
@@ -405,17 +405,59 @@ module Inquisitio
     end
 
     def test_should_support_structured_parser
-      Inquisitio.config.api_version = '2013-01-01'
       searcher = Searcher.where('star wars').parser(:structured)
       search_url = searcher.send(:search_url)
       assert search_url =~ /(\?|&)q\.parser=structured(&|$)/, "search url should include q.parser parameter:\n#{search_url}"
     end
 
     def test_should_support_any_parser
-      Inquisitio.config.api_version = '2013-01-01'
       searcher = Searcher.where('star wars').parser(:foo_bar_baz)
       search_url = searcher.send(:search_url)
       assert search_url =~ /(\?|&)q\.parser=foo_bar_baz(&|$)/, "search url should include q.parser parameter:\n#{search_url}"
     end
+
+    def test_should_not_have_fq_if_no_filter
+      searcher = Searcher.where('star wars')
+      search_url = searcher.send(:search_url)
+      refute search_url =~ /(\?|&)fq=/, "search url should not include fq parameter:\n#{search_url}"
+    end
+
+    def test_should_take_a_filter_query
+      searcher = Searcher.where('star wars').filter('a new hope')
+      search_url = searcher.send(:search_url)
+      assert search_url =~ /(\?|&)fq=a\+new\+hope(&|$)/, "search url should include fq parameter:\n#{search_url}"
+    end
+
+    def test_should_take_a_filter_query_with_fields
+      searcher = Searcher.where('star wars').filter(tags: 'anewhope')
+      search_url = searcher.send(:search_url)
+      assert search_url =~ /(\?|&)fq=tags%3A%27anewhope%27(&|$)/, "search url should include fq parameter:\n#{search_url}"
+    end
+
+    def test_should_accept_empty_filter_to_reset_filters
+      searcher = Searcher.where('star wars').filter(tags: 'anewhope').filter(nil)
+      search_url = searcher.send(:search_url)
+      refute search_url =~ /(\?|&)fq=tags%3A%27anewhope%27(&|$)/, "search url should not include fq parameter:\n#{search_url}"
+    end
+
+    def test_should_tolerate_empty_filter
+      searcher = Searcher.where('star wars').filter(nil)
+      search_url = searcher.send(:search_url)
+      refute search_url =~ /(\?|&)fq=/, "search url should not include fq parameter:\n#{search_url}"
+    end
+
+    def test_should_take_a_facet
+      searcher = Searcher.where('star wars').facets(tags: {})
+      search_url = searcher.send(:search_url)
+      assert search_url =~ /(\?|&)facet\.tags=%7B%7D(&|$)/, "search url should include facet.tags parameter:\n#{search_url}"
+    end
+
+    def test_should_take_facets
+      searcher = Searcher.where('star wars').facets(tags: {}, genre: {sort:'bucket', size:5})
+      search_url = searcher.send(:search_url)
+      assert search_url =~ /(\?|&)facet\.tags=%7B%7D(&|$)/, "search url should include facet.tags parameter:\n#{search_url}"
+      assert search_url =~ /(\?|&)facet\.genre=%7B%22sort%22%3A%22bucket%22%2C%22size%22%3A5%7D(&|$)/, "search url should include facet.genre parameter:\n#{search_url}"
+    end
+
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inquisitio
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Jeremy Walker
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-22 00:00:00.000000000 Z
+date: 2015-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: excon
@@ -120,6 +120,7 @@ files:
 - lib/inquisitio/active_support.rb
 - lib/inquisitio/configuration.rb
 - lib/inquisitio/document.rb
+- lib/inquisitio/facets.rb
 - lib/inquisitio/indexer.rb
 - lib/inquisitio/inquisitio_error.rb
 - lib/inquisitio/logger.rb
@@ -129,6 +130,7 @@ files:
 - lib/inquisitio/version.rb
 - test/configuration_test.rb
 - test/document_test.rb
+- test/facets_test.rb
 - test/indexer_test.rb
 - test/logger_test.rb
 - test/results_test.rb
@@ -162,6 +164,7 @@ summary: This wraps AWS CloudSearch in a Ruby Gem
 test_files:
 - test/configuration_test.rb
 - test/document_test.rb
+- test/facets_test.rb
 - test/indexer_test.rb
 - test/logger_test.rb
 - test/results_test.rb