waistband 0.4.2 → 0.7.0

data/lib/waistband.rb

@@ -9,7 +9,6 @@ module Waistband
   autoload :QueryResult,      "waistband/query_result"
   autoload :QueryHelpers,     "waistband/query_helpers"
   autoload :Query,            "waistband/query"
-  autoload :FreeQuery,        "waistband/free_query"
   autoload :Index,            "waistband/index"
   autoload :QuickError,       "waistband/quick_error"
   autoload :Model,            "waistband/model"

data/lib/waistband/index.rb

@@ -54,12 +54,8 @@ module Waistband
       connection.read @index, key
     end
 
-    def query(term, options = {})
-      ::Waistband::Query.new @index, term, options
-    end
-
-    def free_query(options = {})
-      ::Waistband::FreeQuery.new @index, options
+    def query(options = {})
+      ::Waistband::Query.new @index, options
     end
 
     def search_url

data/lib/waistband/query.rb

@@ -1,7 +1,4 @@
-require 'json'
-require 'rest-client'
-require 'active_support/core_ext/object/blank'
-require 'kaminari/models/array_extension' if defined?(Kaminari)
+require 'active_support/core_ext/hash/indifferent_access'
 
 module Waistband
   class Query
@@ -10,180 +7,26 @@ module Waistband
 
     attr_accessor :page, :page_size
 
-    def initialize(index, search_term, options = {})
-      @index          = index
-      @search_term    = search_term
-      @wildcards      = []
-      @fields         = []
-      @ranges         = []
-      @sorts          = []
-      @terms          = {}
-      @exclude_terms  = {}
-      @optional_terms = {}
-      @page           = (options[:page] || 1).to_i
-      @page_size      = (options[:page_size] || 20).to_i
+    def initialize(index, options = {})
+      @index      = index
+      @page       = (options[:page] || 1).to_i
+      @page_size  = (options[:page_size] || 20).to_i
     end
 
-    def add_match(field)
-      @match = field
-    end
-
-    def add_fields(*fields)
-      @fields |= fields
-      @fields = @fields.compact.uniq
-    end
-    alias :add_field :add_fields
-
-    def add_wildcard(wildcard, value)
-      @wildcards << {
-        wildcard: wildcard,
-        value: value
-      }
-    end
-
-    def add_range(field, min, max)
-      @ranges << {
-        field: field,
-        min: min,
-        max: max
-      }
-    end
-
-    def add_terms(key, words)
-      @terms[key] ||= {
-        keywords: []
-      }
-      @terms[key][:keywords] += prep_words_uniquely(words)
-    end
-    alias :add_term :add_terms
-
-    def add_exclude_terms(key, words)
-      @exclude_terms[key] ||= {
-        keywords: []
-      }
-      @exclude_terms[key][:keywords] += prep_words_uniquely(words)
-    end
-    alias :add_exclude_term :add_exclude_terms
-
-    def add_optional_terms(key, words)
-      @optional_terms[key] ||= {
-        keywords: []
-      }
-      @optional_terms[key][:keywords] += prep_words_uniquely(words)
-    end
-    alias :add_optional_term :add_optional_terms
-
-    def add_sort(key, ord)
-      @sorts << {
-        key: key,
-        ord: ord
-      }
-    end
-
-    def add_random_sort
-      @random_sort = {
-        _script:  {
-          script:   "Math.random()",
-          type:     :number,
-          params:   {},
-          order:    :asc
-        }
-      }
+    def prepare(hash)
+      @hash = hash.with_indifferent_access
+      self
     end
 
     private
 
       def to_hash
-        {
-          query: {
-            bool: {
-              must:     must_to_hash,
-              must_not: must_not_to_hash,
-              should:   should_to_hash
-            }
-          },
-          from: from,
-          size: @page_size,
-          sort: sort_to_hash
-        }
-      end
-
-      def sort_to_hash
-        return @random_sort if @random_sort
+        raise "No query has been prepared yet!" unless @hash
 
-        sort = []
-
-        @sorts.each do |s|
-          sort << {s[:key] => s[:ord]}
-        end
-
-        sort << '_score'
-
-        sort
-      end
-
-      def must_to_hash
-        must = []
-
-        must << {
-          multi_match: {
-            query: @search_term,
-            fields: @fields
-          }
-        } if @fields.any?
-
-        @wildcards.each do |wc|
-          must << {
-            wildcard: {
-              wc[:wildcard] => wc[:value]
-            }
-          }
-        end
-
-        @ranges.each do |range|
-          must << {
-            range: {
-              range[:field] => {
-                lte: range[:max],
-                gte: range[:min],
-              }
-            }
-          }
-        end
-
-        must << {
-          match: {
-            @match => @search_term
-          }
-        } if @match.present?
-
-        prep_term_hash(@terms).each do |term|
-          must << term
-        end
-
-        must
-      end
-
-      def must_not_to_hash
-        prep_term_hash(@exclude_terms).map { |term| term }
-      end
-
-      def should_to_hash
-        prep_term_hash(@optional_terms).map { |term| term }
-      end
-
-      def prep_term_hash(terms)
-        terms.map do |key, term|
-          {
-            terms: {
-              key.to_sym => term[:keywords]
-            }
-          }
-        end
-      end
+        @hash[:from] = from       unless @hash[:from]
+        @hash[:size] = @page_size unless @hash[:size]
 
-      def prep_words_uniquely(val)
-        val.to_s.gsub(/ +/, ' ').strip.split(' ').uniq
+        @hash
       end
 
     # /private

data/lib/waistband/version.rb

@@ -1,3 +1,3 @@
 module Waistband
-  VERSION = "0.4.2"
+  VERSION = "0.7.0"
 end

data/spec/lib/index_spec.rb

@@ -32,11 +32,7 @@ describe Waistband::Index do
   end
 
   it "proxies to a query" do
-    index.query('shopping').should be_a Waistband::Query
-  end
-
-  it "proxies to a free query" do
-    index.free_query.should be_a Waistband::FreeQuery
+    index.query.should be_a Waistband::Query
   end
 
   describe "storing" do

data/spec/lib/query_spec.rb

@@ -1,373 +1,161 @@
 require 'spec_helper'
-require 'active_support/core_ext/kernel/reporting'
-
-Kernel.silence_stderr do
-  require 'kaminari'
-end
 
 describe Waistband::Query do
 
-  let(:index) { Waistband::Index.new('search') }
-  let(:query) { index.query('shopping ikea') }
-
-  describe '#execute!' do
-
-    before { add_result! }
-
-    it "gets results from elastic search" do
-      json = query.send(:execute!)
-
-      json['hits'].should be_a Hash
-      json['hits']['total'].should > 0
-      json['hits']['hits'].size.should eql 2
-
-      hit = json['hits']['hits'].first
-
-      hit['_id'].should match(/^task_.*/)
-      hit['_source'].should be_a Hash
-      hit['_source']['id'].should eql 123123
-      hit['_source']['name'].should eql 'some shopping in ikea'
-      hit['_source']['user_id'].should eql 999
-      hit['_source']['description'].should eql 'i need you to pick up some stuff in ikea'
-    end
-
-    it "boosts results with optional terms" do
-      query = index.query('shopping ikea')
-      query.add_field('name')
-      query.add_optional_term('internal', 'true')
-
-      json = query.send(:execute!)
-
-      json['hits']['hits'].size.should eql 2
-
-      hit = json['hits']['hits'].first
-
-      hit['_id'].should match(/^task_.*/)
-      hit['_source'].should be_a Hash
-      hit['_source']['id'].should eql 234234
-      hit['_source']['name'].should eql "some shopping in ikea and trader joe's"
-      hit['_source']['user_id'].should eql 987
-      hit['_source']['description'].should eql 'pick me up some eggs'
-    end
-
-    it "excludes results" do
-      query = index.query('shopping ikea')
-      query.add_field('name')
-      query.add_exclude_term('internal', 'true')
-
-      json = query.send(:execute!)
-
-      json['hits']['hits'].size.should eql 1
-
-      hit = json['hits']['hits'].first
-
-      hit['_id'].should match(/^task_.*/)
-      hit['_source'].should be_a Hash
-      hit['_source']['id'].should eql 123123
-      hit['_source']['name'].should eql 'some shopping in ikea'
-      hit['_source']['user_id'].should eql 999
-      hit['_source']['description'].should eql 'i need you to pick up some stuff in ikea'
-      hit['_source']['internal'].should be_false
-    end
-
-  end
-
-  describe '#add_sort' do
-
-    it "adds sort field" do
-      query.add_sort('created_at', 'asc')
-      query.instance_variable_get('@sorts').should eql [{key: 'created_at', ord: 'asc'}]
-
-      query.add_sort('updated_at', 'desc')
-      query.instance_variable_get('@sorts').should eql [{key: 'created_at', ord: 'asc'}, {key: 'updated_at', ord: 'desc'}]
-    end
-
-  end
-
-  describe '#add_random_sort' do
-
-    it "sets the correct instance variables" do
-      query.add_random_sort
-
-      query.instance_variable_get('@random_sort').should eql({
-        _script:  {
-          script:   "Math.random()",
-          type:     :number,
-          params:   {},
-          order:    :asc
-        }
-      })
-
-      query.send(:sort_to_hash).should eql({
-        _script:  {
-          script:   "Math.random()",
-          type:     :number,
-          params:   {},
-          order:    :asc
+  let(:index)     { Waistband::Index.new('search') }
+  let(:geo_index) { Waistband::Index.new('geo') }
+
+  let(:query)     { Waistband::Query.new('search') }
+  let(:geo_query) { Waistband::Query.new('geo') }
+
+  let(:attrs) do
+    {
+      'query' => {
+        'bool' => {
+          'must' => [
+            {
+              'multi_match' => {
+                'query' => "shopping ikea",
+                'fields' => ['name']
+              },
+            }
+          ]
         }
-      })
-    end
-
-    it "sorts restuls randomly" do
-      add_result!
-
-      query = index.query('shopping ikea')
-
-      query.add_field('name')
-      query.add_random_sort
-
-      query.results.size.should eql 2
-    end
-
-  end
-
-  describe '#add_range' do
-
-    it "adds a range" do
-      query.add_range('task_id', 5, 10)
-      query.instance_variable_get('@ranges').should eql [{field: 'task_id', min: 5, max: 10}]
-    end
-
-  end
-
-  describe '#add_field' do
-
-    it "adds field" do
-      query.add_field('name')
-      query.instance_variable_get('@fields').should eql ['name']
-    end
-
-    it "adds multiple fields at once" do
-      query.add_field('name', 'description')
-      query.instance_variable_get('@fields').should eql ['name', 'description']
-    end
-
+      }
+    }
   end
 
-  describe '#add_term' do
-
-    it "adds the term on the key" do
-      query.add_term('metro', 'boston')
-      query.instance_variable_get('@terms')['metro'][:keywords].should eql ['boston']
-    end
-
-    it "adds several terms on multiple words" do
-      query.add_term('metro', 'sf bay area')
-      query.instance_variable_get('@terms')['metro'][:keywords].should eql ['sf', 'bay', 'area']
-    end
+  it "correclty forms a query hash" do
+    add_result!
+    query.prepare(attrs)
 
+    expect(query.instance_variable_get('@hash')).to eql(attrs)
   end
 
-  describe '#add_exclude_term' do
+  it "finds results for a query" do
+    add_result!
+    query.prepare(attrs)
+    json = query.send(:execute!)
 
-    it "adds the term on the key" do
-      query.add_exclude_term('metro', 'boston')
-      query.instance_variable_get('@exclude_terms')['metro'][:keywords].should eql ['boston']
-    end
+    json['hits'].should be_a Hash
+    json['hits']['total'].should > 0
+    json['hits']['hits'].size.should eql 2
 
-    it "adds several terms on multiple words" do
-      query.add_exclude_term('metro', 'sf bay area')
-      query.instance_variable_get('@exclude_terms')['metro'][:keywords].should eql ['sf', 'bay', 'area']
-    end
+    hit = json['hits']['hits'].first
 
+    hit['_id'].should match(/^task_.*/)
+    hit['_source'].should be_a Hash
+    hit['_source']['id'].should eql 123123
+    hit['_source']['name'].should eql 'some shopping in ikea'
+    hit['_source']['user_id'].should eql 999
+    hit['_source']['description'].should eql 'i need you to pick up some stuff in ikea'
   end
 
-  describe '#add_optional_term' do
-
-    it "adds the term on the key" do
-      query.add_optional_term('metro', 'boston')
-      query.instance_variable_get('@optional_terms')['metro'][:keywords].should eql ['boston']
-    end
-
-    it "adds several terms on multiple words" do
-      query.add_optional_term('metro', 'sf bay area')
-      query.instance_variable_get('@optional_terms')['metro'][:keywords].should eql ['sf', 'bay', 'area']
-    end
-
-  end
-
-  describe '#must_to_hash' do
-
-    it "creates an array of the must of the query" do
-      query.add_term('metro', 'sf bay area')
-      query.add_field('name')
-      query.send(:must_to_hash).should eql([
-        {
-          multi_match: {
-            query: "shopping ikea",
-            fields: ['name']
-          }
-        },
-        {
-          terms: {
-            metro: ["sf", "bay", "area"]
+  it "permits storing and fetching geo results" do
+    add_geo_results!
+    geo_query.prepare({
+      "query" => {
+        "filtered" => {
+          "query" => { "match_all" => {} },
+          "filter" => {
+             "geo_shape" => {
+               "work_area" => {
+                 "relation" => "intersects",
+                 "shape" => {
+                   "type" => "Point",
+                   "coordinates" => [-122.39455,37.7841]
+                 }
+               }
+             }
           }
         }
-      ])
-    end
-
-  end
-
-  describe '#must_not_to_hash' do
-
-    it "creates an array of the must of the query" do
-      query.add_exclude_term('metro', 'sf bay area')
-
-      query.send(:must_not_to_hash).should eql([
-        {
-          terms: {
-            metro: ["sf", "bay", "area"]
+      }
+    })
+
+    json = geo_query.send(:execute!)
+
+    json['hits'].should be_a Hash
+    json['hits']['total'].should eql 3
+    json['hits']['hits'].size.should eql 3
+
+    geo_query.prepare({
+      "query" => {
+        "filtered" => {
+          "query" => { "match_all" => {} },
+          "filter" => {
+             "geo_shape" => {
+               "work_area" => {
+                 "relation" => "intersects",
+                 "shape" => {
+                   "type" => "Point",
+                   "coordinates" => [-122.3859222222222,37.78292222222222]
+                 }
+               }
+             }
           }
         }
-      ])
-    end
-
-  end
-
-  describe '#from' do
-
-    it "returns 0 when page is 1" do
-      Waistband::Query.new('search', 'shopping ikea', page: 1, page_size: 20).send(:from).should eql 0
-    end
-
-    it "returns 20 when page is 2 and page_size is 20" do
-      Waistband::Query.new('search', 'shopping ikea', page: 2, page_size: 20).send(:from).should eql 20
-    end
-
-    it "returns 30 when page is 4 and page_size is 10" do
-      Waistband::Query.new('search', 'shopping ikea', page: 4, page_size: 10).send(:from).should eql 30
-    end
-
-    it "returns 10 when page is 2 and page_size is 10" do
-      Waistband::Query.new('search', 'shopping ikea', page: 2, page_size: 10).send(:from).should eql 10
-    end
+      }
+    })
 
-  end
-
-  describe '#to_hash' do
-
-    it "constructs the query's json" do
-      query.add_term('metro', 'sf bay area')
-      query.add_field('name')
-      query.add_sort('created_at', 'desc')
-      query.add_range('task_id', 1, 10)
-
-      query.send(:to_hash).should eql({
-        query: {
-          bool: {
-            must: [
-              {
-                multi_match: {
-                  query: "shopping ikea",
-                  fields: ['name']
-                },
-              },
-              {
-                range: {
-                  'task_id' => {
-                    lte: 10,
-                    gte: 1
-                  }
-                }
-              },
-              {
-                terms: {
-                  metro: ["sf","bay","area"]
-                }
-              }
-            ],
-            must_not: [],
-            should: []
-          }
-        },
-        from: 0,
-        size: 20,
-        sort: [
-          {'created_at' => 'desc'},
-          '_score'
-        ]
-      })
-    end
-
-    it 'constructs the query with several terms' do
-      query.add_term('metro', 'sf bay area')
-      query.add_term('geography', 'San Francisco')
-      query.add_optional_term('internal', 'true')
-      query.add_exclude_term('user_id', '999')
-      query.add_field('name')
-      query.add_field('description')
-      
-      query.send(:to_hash).should eql({
-        query: {
-          bool: {
-            must: [
-              {
-                multi_match: {
-                  query: "shopping ikea",
-                  fields: ['name', 'description']
-                }
-              },
-              {
-                terms: {
-                  metro: ["sf", "bay", "area"]
-                }
-              },
-              {
-                terms: {
-                  geography: ["San", "Francisco"]
-                }
-              }
-            ],
-            must_not: [
-              {
-                terms: {
-                  user_id: ['999']
-                }
-              }
-            ],
-            should: [
-              {
-                terms: {
-                  internal: ['true']
-                }
-              }
-            ]
-          }
-        },
-        from: 0,
-        size: 20,
-        sort: ['_score']
-      })
-    end
-
-  end
-
-  describe '#results' do
-
-    it "returns a QueryResult array" do
-      add_result!
-
-      query.results.first.should be_a Waistband::QueryResult
-    end
-
-  end
-
-  describe '#paginated_results' do
-
-    it "returns a kaminari paginated array" do
-      add_result!
-
-      query.paginated_results.should be_an Array
-    end
+    json = geo_query.send(:execute!)
 
+    json['hits'].should be_a Hash
+    json['hits']['total'].should eql 1
+    json['hits']['hits'].size.should eql 1
   end
 
   def add_result!
     index.store!("task_123123", {id: 123123, name: 'some shopping in ikea',                   user_id: 999, description: 'i need you to pick up some stuff in ikea',  internal: false})
     index.store!("task_234234", {id: 234234, name: "some shopping in ikea and trader joe's",  user_id: 987, description: 'pick me up some eggs',                      internal: true})
     index.refresh
+  end
 
-    query.add_field('name')
+  def add_geo_results!
+    geo_index.store!("rabbit_1", {
+      id: "rabbit_1",
+      work_area: {
+        type: 'polygon',
+        coordinates: [[
+          [-122.4119,37.78211],
+          [-122.39285,37.79649],
+          [-122.37997,37.78415],
+          [-122.39817,37.77248],
+          [-122.40932,37.77302],
+          [-122.4119,37.78211]
+        ]]
+      }
+    })
+
+    geo_index.store!("rabbit_2", {
+      id: "rabbit_2",
+      work_area: {
+        type: 'polygon',
+        coordinates: [[
+          [-122.41087,37.78822],
+          [-122.43174,37.78578],
+          [-122.42816,37.75938],
+          [-122.38787,37.76882],
+          [-122.39199,37.78584],
+          [-122.41087,37.78822]
+        ]]
+      }
+    })
+
+    geo_index.store!("rabbit_3", {
+      id: "rabbit_3",
+      work_area: {
+        type: 'polygon',
+        coordinates: [[
+          [-122.41997,37.79744],
+          [-122.39576,37.79975],
+          [-122.38461,37.78469],
+          [-122.40294,37.77738],
+          [-122.41997,37.79744]
+        ]]
+      }
+    })
+
+    geo_index.refresh
   end
 
 end