searchkick 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a492bb88396370b25f7bd69d7c5cebad46fde482
-  data.tar.gz: d958c3ee3261ddf1cf7aed5f1ef1b6e50348194c
+  metadata.gz: 12242ee03581e51bcb73eb5301309a0ba85b0c8b
+  data.tar.gz: 94f6e444569e05c8d1a56054da8f079cdf43bf50
 SHA512:
-  metadata.gz: c510e1a08aa01f34f23220a6af5676520be76ab1920843acb3d8ca205fb621de39ee9de3607f6363c49bda2bd416f9bfa1cad9666c42c7e3c4be81bbe678c59a
-  data.tar.gz: 5f51db56e29051fc7fe37242e9b94a09e1a4d05883709b8fe102a750db8197f642753c89a5a186233fe310c5de75a00ee6da1e8cd967061e891ba335097d314f
+  metadata.gz: 56a50ceacda73f6aee353c22b84191d721afe481808ed69beb7d79601d4e6cd57deed76ac8f70f4ccc37d753ee4d16758b5b269359cbd79ec363180290c4ee99
+  data.tar.gz: 71953014b0b9233519f0088da6d3246a2f45fa3babff843dcce2143b0b9f24b8ddeb0523418b5b764485785921c11a2ad6f723b028cd84d420162bba15bf4438

data/.travis.yml

@@ -26,3 +26,6 @@ matrix:
   include:
     - gemfile: test/gemfiles/nobrainer.gemfile
       env: NOBRAINER=true
+  allow_failures:
+    - gemfile: test/gemfiles/nobrainer.gemfile
+      env: NOBRAINER=true

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 1.0.3
+
+- Added support for Elasticsearch 2.1
+
 ## 1.0.2
 
 - Throw `Searchkick::ImportError` for errors when importing records

data/README.md

@@ -280,7 +280,7 @@ Call `Product.reindex` after changing synonyms.
 
 ### WordNet
 
-Prepopulate English synonyms with the [WordNet database](http://en.wikipedia.org/wiki/WordNet).
+Prepopulate English synonyms with the [WordNet database](https://en.wikipedia.org/wiki/WordNet).
 
 Download [WordNet 3.0](http://wordnetcode.princeton.edu/3.0/WNprolog-3.0.tar.gz) to each Elasticsearch server and move `wn_s.pl` to the `/var/lib` directory.
 
@@ -301,7 +301,7 @@ end
 
 ### Misspellings
 
-By default, Searchkick handles misspelled queries by returning results with an [edit distance](http://en.wikipedia.org/wiki/Levenshtein_distance) of one.
+By default, Searchkick handles misspelled queries by returning results with an [edit distance](https://en.wikipedia.org/wiki/Levenshtein_distance) of one.
 
 You can change this with:
 
@@ -893,7 +893,7 @@ Searchkick uses `ENV["ELASTICSEARCH_URL"]` for the Elasticsearch server.  This d
 
 ### Heroku
 
-Choose an add-on: [SearchBox](https://addons.heroku.com/searchbox), [Bonsai](https://addons.heroku.com/bonsai), or [Found](https://addons.heroku.com/foundelasticsearch).
+Choose an add-on: [SearchBox](https://elements.heroku.com/addons/searchbox), [Bonsai](https://elements.heroku.com/addons/bonsai), or [Found](https://addons.heroku.com/foundelasticsearch).
 
 ```sh
 # SearchBox
@@ -1318,7 +1318,7 @@ For convenience, this is set by default in the test environment.
 
 ## Thanks
 
-Thanks to Karel Minarik for [Elasticsearch Ruby](https://github.com/elasticsearch/elasticsearch-ruby) and [Tire](https://github.com/karmi/tire), Jaroslav Kalistsuk for [zero downtime reindexing](https://gist.github.com/jarosan/3124884), and Alex Leschenko for [Elasticsearch autocomplete](https://github.com/leschenko/elasticsearch_autocomplete).
+Thanks to Karel Minarik for [Elasticsearch Ruby](https://github.com/elasticsearch/elasticsearch-ruby) and [Tire](https://github.com/karmi/retire), Jaroslav Kalistsuk for [zero downtime reindexing](https://gist.github.com/jarosan/3124884), and Alex Leschenko for [Elasticsearch autocomplete](https://github.com/leschenko/elasticsearch_autocomplete).
 
 ## Roadmap
 

data/lib/searchkick/query.rb

@@ -49,7 +49,7 @@ module Searchkick
 
       # pagination
       page = [options[:page].to_i, 1].max
-      per_page = (options[:limit] || options[:per_page] || 100_000).to_i
+      per_page = (options[:limit] || options[:per_page] || 1_000).to_i
       padding = [options[:padding].to_i, 0].max
       offset = options[:offset] || (page - 1) * per_page + padding
 
@@ -300,7 +300,7 @@ module Searchkick
           facets.each do |field, facet_options|
             # ask for extra facets due to
             # https://github.com/elasticsearch/elasticsearch/issues/1305
-            size = facet_options[:limit] ? facet_options[:limit] + 150 : 100_000
+            size = facet_options[:limit] ? facet_options[:limit] + 150 : 1_000
 
             if facet_options[:ranges]
               payload[:facets][field] = {
@@ -347,10 +347,10 @@ module Searchkick
           aggs = options[:aggs]
           payload[:aggs] = {}
 
-          aggs = aggs.map { |f| [f, {}] }.to_h if aggs.is_a?(Array) # convert to more advanced syntax
+          aggs = Hash[aggs.map { |f| [f, {}] }] if aggs.is_a?(Array) # convert to more advanced syntax
 
           aggs.each do |field, agg_options|
-            size = agg_options[:limit] ? agg_options[:limit] : 100_000
+            size = agg_options[:limit] ? agg_options[:limit] : 1_000
             shared_agg_options = agg_options.slice(:order)
 
             if agg_options[:ranges]

data/lib/searchkick/version.rb

@@ -1,3 +1,3 @@
 module Searchkick
-  VERSION = "1.0.2"
+  VERSION = "1.0.3"
 end

data/test/aggs_test.rb

@@ -95,7 +95,7 @@ class AggsTest < Minitest::Test
   protected
 
   def buckets_as_hash(agg)
-    agg["buckets"].map { |v| [v["key"], v["doc_count"]] }.to_h
+    Hash[agg["buckets"].map { |v| [v["key"], v["doc_count"]] }]
   end
 
   def store_agg(options, agg_key = "store_id")
@@ -104,8 +104,8 @@ class AggsTest < Minitest::Test
   end
 
   def store_multiple_aggs(options)
-    Product.search("Product", options).aggs.map do |field, filtered_agg|
+    Hash[Product.search("Product", options).aggs.map do |field, filtered_agg|
       [field, buckets_as_hash(filtered_agg)]
-    end.to_h
+    end]
   end
 end

data/test/dangerous_reindex_test.rb

@@ -0,0 +1,27 @@
+require_relative "test_helper"
+
+class DangerousReindexTest < Minitest::Test
+  def setup
+    skip if mongoid2? || nobrainer? || activerecord_below41?
+    super
+  end
+
+  def test_dangerous_reindex
+    assert_raises(Searchkick::DangerousOperation) { Product.where(id: [1, 2, 3]).reindex }
+  end
+
+  def test_dangerous_index_associations
+    Store.create!(name: "Test")
+    assert_raises(Searchkick::DangerousOperation) { Store.first.products.reindex }
+  end
+
+  def test_dangerous_reindex_accepted
+    store_names ["Product A", "Product B"]
+    Product.where(name: "Product A").reindex(accept_danger: true)
+    assert_search "product", ["Product A"]
+  end
+
+  def test_dangerous_reindex_inheritance
+    assert_raises(Searchkick::DangerousOperation) { Dog.where(id: [1, 2, 3]).reindex }
+  end
+end

data/test/index_test.rb

@@ -102,34 +102,12 @@ class IndexTest < Minitest::Test
     assert_raises(Searchkick::InvalidQueryError) { Product.search(query: {boom: true}) }
   end
 
-  unless mongoid2? || nobrainer? || activerecord_below41?
-    def test_dangerous_reindex
-      assert_raises(Searchkick::DangerousOperation) { Product.where(id: [1, 2, 3]).reindex }
-    end
-
-    def test_dangerous_index_associations
-      Store.create!(name: "Test")
-      assert_raises(Searchkick::DangerousOperation) { Store.first.products.reindex }
-    end
-
-    def test_dangerous_reindex_accepted
-      store_names ["Product A", "Product B"]
-      Product.where(name: "Product A").reindex(accept_danger: true)
-      assert_search "product", ["Product A"]
-    end
-
-    def test_dangerous_reindex_inheritance
-      assert_raises(Searchkick::DangerousOperation) { Dog.where(id: [1, 2, 3]).reindex }
-    end
-  end
-
-  if defined?(ActiveRecord)
-    def test_transaction
-      Product.transaction do
-        store_names ["Product A"]
-        raise ActiveRecord::Rollback
-      end
-      assert_search "product", []
+  def test_transaction
+    skip unless defined?(ActiveRecord)
+    Product.transaction do
+      store_names ["Product A"]
+      raise ActiveRecord::Rollback
     end
+    assert_search "product", []
   end
 end

data/test/misspellings_test.rb

@@ -0,0 +1,36 @@
+require_relative "test_helper"
+
+class MisspellingsTest < Minitest::Test
+  def test_misspellings
+    store_names ["abc", "abd", "aee"]
+    assert_search "abc", ["abc"], misspellings: false
+  end
+
+  def test_misspellings_distance
+    store_names ["abbb", "aabb"]
+    assert_search "aaaa", ["aabb"], misspellings: {distance: 2}
+  end
+
+  def test_misspellings_prefix_length
+    store_names ["ap", "api", "apt", "any", "nap", "ah", "ahi"]
+    assert_search "ap", ["ap"], misspellings: {prefix_length: 2}
+    assert_search "api", ["ap", "api", "apt"], misspellings: {prefix_length: 2}
+  end
+
+  def test_misspellings_prefix_length_operator
+    store_names ["ap", "api", "apt", "any", "nap", "ah", "aha"]
+    assert_search "ap ah", ["ap", "ah"], operator: "or", misspellings: {prefix_length: 2}
+    assert_search "api ahi", ["ap", "api", "apt", "ah", "aha"], operator: "or", misspellings: {prefix_length: 2}
+  end
+
+  def test_misspellings_fields_operator
+    store [
+      {name: "red", color: "red"},
+      {name: "blue", color: "blue"},
+      {name: "cyan", color: "blue green"},
+      {name: "magenta", color: "red blue"},
+      {name: "green", color: "green"}
+    ]
+    assert_search "red blue", ["red", "blue", "cyan", "magenta"], operator: "or", fields: ["color"], misspellings: false
+  end
+end

data/test/order_test.rb

@@ -0,0 +1,38 @@
+require_relative "test_helper"
+
+class OrderTest < Minitest::Test
+  def test_order_hash
+    store_names ["Product A", "Product B", "Product C", "Product D"]
+    assert_order "product", ["Product D", "Product C", "Product B", "Product A"], order: {name: :desc}
+  end
+
+  def test_order_string
+    store_names ["Product A", "Product B", "Product C", "Product D"]
+    assert_order "product", ["Product A", "Product B", "Product C", "Product D"], order: "name"
+  end
+
+  def test_order_id
+    store_names ["Product A", "Product B"]
+    product_a = Product.where(name: "Product A").first
+    product_b = Product.where(name: "Product B").first
+    assert_order "product", [product_a, product_b].sort_by(&:id).map(&:name), order: {id: :asc}
+  end
+
+  def test_order_multiple
+    store [
+      {name: "Product A", color: "blue", store_id: 1},
+      {name: "Product B", color: "red", store_id: 3},
+      {name: "Product C", color: "red", store_id: 2}
+    ]
+    assert_order "product", ["Product A", "Product B", "Product C"], order: {color: :asc, store_id: :desc}
+  end
+
+  def test_order_ignore_unmapped
+    assert_order "product", [], order: {not_mapped: {ignore_unmapped: true}}
+  end
+
+  def test_order_array
+    store [{name: "San Francisco", latitude: 37.7833, longitude: -122.4167}]
+    assert_order "francisco", ["San Francisco"], order: [{_geo_distance: {location: "0,0"}}]
+  end
+end

data/test/pagination_test.rb

@@ -0,0 +1,53 @@
+require_relative "test_helper"
+
+class PaginationTest < Minitest::Test
+  def test_limit
+    store_names ["Product A", "Product B", "Product C", "Product D"]
+    assert_order "product", ["Product A", "Product B"], order: {name: :asc}, limit: 2
+  end
+
+  def test_no_limit
+    names = 20.times.map { |i| "Product #{i}" }
+    store_names names
+    assert_search "product", names
+  end
+
+  def test_offset
+    store_names ["Product A", "Product B", "Product C", "Product D"]
+    assert_order "product", ["Product C", "Product D"], order: {name: :asc}, offset: 2
+  end
+
+  def test_pagination
+    store_names ["Product A", "Product B", "Product C", "Product D", "Product E", "Product F"]
+    products = Product.search("product", order: {name: :asc}, page: 2, per_page: 2, padding: 1)
+    assert_equal ["Product D", "Product E"], products.map(&:name)
+    assert_equal "product", products.entry_name
+    assert_equal 2, products.current_page
+    assert_equal 1, products.padding
+    assert_equal 2, products.per_page
+    assert_equal 2, products.size
+    assert_equal 2, products.length
+    assert_equal 3, products.total_pages
+    assert_equal 6, products.total_count
+    assert_equal 6, products.total_entries
+    assert_equal 2, products.limit_value
+    assert_equal 3, products.offset_value
+    assert_equal 3, products.offset
+    assert_equal 3, products.next_page
+    assert_equal 1, products.previous_page
+    assert_equal 1, products.prev_page
+    assert !products.first_page?
+    assert !products.last_page?
+    assert !products.empty?
+    assert !products.out_of_range?
+    assert products.any?
+  end
+
+  def test_pagination_nil_page
+    store_names ["Product A", "Product B", "Product C", "Product D", "Product E"]
+    products = Product.search("product", order: {name: :asc}, page: nil, per_page: 2)
+    assert_equal ["Product A", "Product B"], products.map(&:name)
+    assert_equal 1, products.current_page
+    assert products.first_page?
+  end
+end

data/test/sql_test.rb

@@ -1,226 +1,6 @@
 require_relative "test_helper"
 
 class SqlTest < Minitest::Test
-  def test_limit
-    store_names ["Product A", "Product B", "Product C", "Product D"]
-    assert_order "product", ["Product A", "Product B"], order: {name: :asc}, limit: 2
-  end
-
-  def test_no_limit
-    names = 20.times.map { |i| "Product #{i}" }
-    store_names names
-    assert_search "product", names
-  end
-
-  def test_offset
-    store_names ["Product A", "Product B", "Product C", "Product D"]
-    assert_order "product", ["Product C", "Product D"], order: {name: :asc}, offset: 2
-  end
-
-  def test_pagination
-    store_names ["Product A", "Product B", "Product C", "Product D", "Product E", "Product F"]
-    products = Product.search("product", order: {name: :asc}, page: 2, per_page: 2, padding: 1)
-    assert_equal ["Product D", "Product E"], products.map(&:name)
-    assert_equal "product", products.entry_name
-    assert_equal 2, products.current_page
-    assert_equal 1, products.padding
-    assert_equal 2, products.per_page
-    assert_equal 2, products.size
-    assert_equal 2, products.length
-    assert_equal 3, products.total_pages
-    assert_equal 6, products.total_count
-    assert_equal 6, products.total_entries
-    assert_equal 2, products.limit_value
-    assert_equal 3, products.offset_value
-    assert_equal 3, products.offset
-    assert_equal 3, products.next_page
-    assert_equal 1, products.previous_page
-    assert_equal 1, products.prev_page
-    assert !products.first_page?
-    assert !products.last_page?
-    assert !products.empty?
-    assert !products.out_of_range?
-    assert products.any?
-  end
-
-  def test_pagination_nil_page
-    store_names ["Product A", "Product B", "Product C", "Product D", "Product E"]
-    products = Product.search("product", order: {name: :asc}, page: nil, per_page: 2)
-    assert_equal ["Product A", "Product B"], products.map(&:name)
-    assert_equal 1, products.current_page
-    assert products.first_page?
-  end
-
-  def test_where
-    now = Time.now
-    store [
-      {name: "Product A", store_id: 1, in_stock: true, backordered: true, created_at: now, orders_count: 4, user_ids: [1, 2, 3]},
-      {name: "Product B", store_id: 2, in_stock: true, backordered: false, created_at: now - 1, orders_count: 3, user_ids: [1]},
-      {name: "Product C", store_id: 3, in_stock: false, backordered: true, created_at: now - 2, orders_count: 2, user_ids: [1, 3]},
-      {name: "Product D", store_id: 4, in_stock: false, backordered: false, created_at: now - 3, orders_count: 1}
-    ]
-    assert_search "product", ["Product A", "Product B"], where: {in_stock: true}
-    # date
-    assert_search "product", ["Product A"], where: {created_at: {gt: now - 1}}
-    assert_search "product", ["Product A", "Product B"], where: {created_at: {gte: now - 1}}
-    assert_search "product", ["Product D"], where: {created_at: {lt: now - 2}}
-    assert_search "product", ["Product C", "Product D"], where: {created_at: {lte: now - 2}}
-    # integer
-    assert_search "product", ["Product A"], where: {store_id: {lt: 2}}
-    assert_search "product", ["Product A", "Product B"], where: {store_id: {lte: 2}}
-    assert_search "product", ["Product D"], where: {store_id: {gt: 3}}
-    assert_search "product", ["Product C", "Product D"], where: {store_id: {gte: 3}}
-    # range
-    assert_search "product", ["Product A", "Product B"], where: {store_id: 1..2}
-    assert_search "product", ["Product A"], where: {store_id: 1...2}
-    assert_search "product", ["Product A", "Product B"], where: {store_id: [1, 2]}
-    assert_search "product", ["Product B", "Product C", "Product D"], where: {store_id: {not: 1}}
-    assert_search "product", ["Product C", "Product D"], where: {store_id: {not: [1, 2]}}
-    assert_search "product", ["Product A"], where: {user_ids: {lte: 2, gte: 2}}
-    # or
-    assert_search "product", ["Product A", "Product B", "Product C"], where: {or: [[{in_stock: true}, {store_id: 3}]]}
-    assert_search "product", ["Product A", "Product B", "Product C"], where: {or: [[{orders_count: [2, 4]}, {store_id: [1, 2]}]]}
-    assert_search "product", ["Product A", "Product D"], where: {or: [[{orders_count: 1}, {created_at: {gte: now - 1}, backordered: true}]]}
-    # all
-    assert_search "product", ["Product A", "Product C"], where: {user_ids: {all: [1, 3]}}
-    assert_search "product", [], where: {user_ids: {all: [1, 2, 3, 4]}}
-    # any / nested terms
-    assert_search "product", ["Product B", "Product C"], where: {user_ids: {not: [2], in: [1, 3]}}
-    # not / exists
-    assert_search "product", ["Product D"], where: {user_ids: nil}
-    assert_search "product", ["Product A", "Product B", "Product C"], where: {user_ids: {not: nil}}
-    assert_search "product", ["Product A", "Product C", "Product D"], where: {user_ids: [3, nil]}
-    assert_search "product", ["Product B"], where: {user_ids: {not: [3, nil]}}
-  end
-
-  def test_regexp
-    store_names ["Product A"]
-    assert_search "*", ["Product A"], where: {name: /Pro.+/}
-  end
-
-  def test_alternate_regexp
-    store_names ["Product A", "Item B"]
-    assert_search "*", ["Product A"], where: {name: {regexp: "Pro.+"}}
-  end
-
-  def test_where_string
-    store [
-      {name: "Product A", color: "RED"}
-    ]
-    assert_search "product", ["Product A"], where: {color: "RED"}
-  end
-
-  def test_where_nil
-    store [
-      {name: "Product A"},
-      {name: "Product B", color: "red"}
-    ]
-    assert_search "product", ["Product A"], where: {color: nil}
-  end
-
-  def test_where_id
-    store_names ["Product A"]
-    product = Product.last
-    assert_search "product", ["Product A"], where: {id: product.id.to_s}
-  end
-
-  def test_where_empty
-    store_names ["Product A"]
-    assert_search "product", ["Product A"], where: {}
-  end
-
-  def test_where_empty_array
-    store_names ["Product A"]
-    assert_search "product", [], where: {store_id: []}
-  end
-
-  # http://elasticsearch-users.115913.n3.nabble.com/Numeric-range-quey-or-filter-in-an-array-field-possible-or-not-td4042967.html
-  # https://gist.github.com/jprante/7099463
-  def test_where_range_array
-    store [
-      {name: "Product A", user_ids: [11, 23, 13, 16, 17, 23]},
-      {name: "Product B", user_ids: [1, 2, 3, 4, 5, 6, 7, 8, 9]},
-      {name: "Product C", user_ids: [101, 230, 150, 200]}
-    ]
-    assert_search "product", ["Product A"], where: {user_ids: {gt: 10, lt: 24}}
-  end
-
-  def test_where_range_array_again
-    store [
-      {name: "Product A", user_ids: [19, 32, 42]},
-      {name: "Product B", user_ids: [13, 40, 52]}
-    ]
-    assert_search "product", ["Product A"], where: {user_ids: {gt: 26, lt: 36}}
-  end
-
-  def test_near
-    store [
-      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
-      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000}
-    ]
-    assert_search "san", ["San Francisco"], where: {location: {near: [37.5, -122.5]}}
-  end
-
-  def test_near_within
-    store [
-      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
-      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000},
-      {name: "San Marino", latitude: 43.9333, longitude: 12.4667}
-    ]
-    assert_search "san", ["San Francisco", "San Antonio"], where: {location: {near: [37, -122], within: "2000mi"}}
-  end
-
-  def test_top_left_bottom_right
-    store [
-      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
-      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000}
-    ]
-    assert_search "san", ["San Francisco"], where: {location: {top_left: [38, -123], bottom_right: [37, -122]}}
-  end
-
-  def test_multiple_locations
-    store [
-      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
-      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000}
-    ]
-    assert_search "san", ["San Francisco"], where: {multiple_locations: {near: [37.5, -122.5]}}
-  end
-
-  def test_order_hash
-    store_names ["Product A", "Product B", "Product C", "Product D"]
-    assert_order "product", ["Product D", "Product C", "Product B", "Product A"], order: {name: :desc}
-  end
-
-  def test_order_string
-    store_names ["Product A", "Product B", "Product C", "Product D"]
-    assert_order "product", ["Product A", "Product B", "Product C", "Product D"], order: "name"
-  end
-
-  def test_order_id
-    store_names ["Product A", "Product B"]
-    product_a = Product.where(name: "Product A").first
-    product_b = Product.where(name: "Product B").first
-    assert_order "product", [product_a, product_b].sort_by(&:id).map(&:name), order: {id: :asc}
-  end
-
-  def test_order_multiple
-    store [
-      {name: "Product A", color: "blue", store_id: 1},
-      {name: "Product B", color: "red", store_id: 3},
-      {name: "Product C", color: "red", store_id: 2}
-    ]
-    assert_order "product", ["Product A", "Product B", "Product C"], order: {color: :asc, store_id: :desc}
-  end
-
-  def test_order_ignore_unmapped
-    assert_order "product", [], order: {not_mapped: {ignore_unmapped: true}}
-  end
-
-  def test_order_array
-    store [{name: "San Francisco", latitude: 37.7833, longitude: -122.4167}]
-    assert_order "francisco", ["San Francisco"], order: [{_geo_distance: {location: "0,0"}}]
-  end
-
   def test_partial
     store_names ["Honey"]
     assert_search "fresh honey", []
@@ -233,39 +13,6 @@ class SqlTest < Minitest::Test
     assert_search "fresh honey", ["Honey"], operator: "or"
   end
 
-  def test_misspellings
-    store_names ["abc", "abd", "aee"]
-    assert_search "abc", ["abc"], misspellings: false
-  end
-
-  def test_misspellings_distance
-    store_names ["abbb", "aabb"]
-    assert_search "aaaa", ["aabb"], misspellings: {distance: 2}
-  end
-
-  def test_misspellings_prefix_length
-    store_names ["ap", "api", "apt", "any", "nap", "ah", "ahi"]
-    assert_search "ap", ["ap"], misspellings: {prefix_length: 2}
-    assert_search "api", ["ap", "api", "apt"], misspellings: {prefix_length: 2}
-  end
-
-  def test_misspellings_prefix_length_operator
-    store_names ["ap", "api", "apt", "any", "nap", "ah", "aha"]
-    assert_search "ap ah", ["ap", "ah"], operator: "or", misspellings: {prefix_length: 2}
-    assert_search "api ahi", ["ap", "api", "apt", "ah", "aha"], operator: "or", misspellings: {prefix_length: 2}
-  end
-
-  def test_misspellings_fields_operator
-    store [
-      {name: "red", color: "red"},
-      {name: "blue", color: "blue"},
-      {name: "cyan", color: "blue green"},
-      {name: "magenta", color: "red blue"},
-      {name: "green", color: "green"}
-    ]
-    assert_search "red blue", ["red", "blue", "cyan", "magenta"], operator: "or", fields: ["color"], misspellings: false
-  end
-
   def test_fields_operator
     store [
       {name: "red", color: "red"},
@@ -355,11 +102,9 @@ class SqlTest < Minitest::Test
     assert_equal aisle, Product.search("product", load: false).first.aisle.to_hash
   end
 
-  # TODO see if Mongoid is loaded
-  unless defined?(Mongoid) || defined?(NoBrainer)
-    def test_include
-      store_names ["Product A"]
-      assert Product.search("product", include: [:store]).first.association(:store).loaded?
-    end
+  def test_include
+    skip unless defined?(ActiveRecord)
+    store_names ["Product A"]
+    assert Product.search("product", include: [:store]).first.association(:store).loaded?
   end
 end

data/test/synonyms_test.rb

@@ -41,8 +41,9 @@ class SynonymsTest < Minitest::Test
     assert_search "scallions", ["Green Onions"]
   end
 
-  # def test_wordnet
-  #   store_names ["Creature", "Beast", "Dragon"], Animal
-  #   assert_search "animal", ["Creature", "Beast"], {}, Animal
-  # end
+  def test_wordnet
+    skip unless ENV["TEST_WORDNET"]
+    store_names ["Creature", "Beast", "Dragon"], Animal
+    assert_search "animal", ["Creature", "Beast"], {}, Animal
+  end
 end

data/test/where_test.rb

@@ -0,0 +1,138 @@
+require_relative "test_helper"
+
+class WhereTest < Minitest::Test
+  def test_where
+    now = Time.now
+    store [
+      {name: "Product A", store_id: 1, in_stock: true, backordered: true, created_at: now, orders_count: 4, user_ids: [1, 2, 3]},
+      {name: "Product B", store_id: 2, in_stock: true, backordered: false, created_at: now - 1, orders_count: 3, user_ids: [1]},
+      {name: "Product C", store_id: 3, in_stock: false, backordered: true, created_at: now - 2, orders_count: 2, user_ids: [1, 3]},
+      {name: "Product D", store_id: 4, in_stock: false, backordered: false, created_at: now - 3, orders_count: 1}
+    ]
+    assert_search "product", ["Product A", "Product B"], where: {in_stock: true}
+    # date
+    assert_search "product", ["Product A"], where: {created_at: {gt: now - 1}}
+    assert_search "product", ["Product A", "Product B"], where: {created_at: {gte: now - 1}}
+    assert_search "product", ["Product D"], where: {created_at: {lt: now - 2}}
+    assert_search "product", ["Product C", "Product D"], where: {created_at: {lte: now - 2}}
+    # integer
+    assert_search "product", ["Product A"], where: {store_id: {lt: 2}}
+    assert_search "product", ["Product A", "Product B"], where: {store_id: {lte: 2}}
+    assert_search "product", ["Product D"], where: {store_id: {gt: 3}}
+    assert_search "product", ["Product C", "Product D"], where: {store_id: {gte: 3}}
+    # range
+    assert_search "product", ["Product A", "Product B"], where: {store_id: 1..2}
+    assert_search "product", ["Product A"], where: {store_id: 1...2}
+    assert_search "product", ["Product A", "Product B"], where: {store_id: [1, 2]}
+    assert_search "product", ["Product B", "Product C", "Product D"], where: {store_id: {not: 1}}
+    assert_search "product", ["Product C", "Product D"], where: {store_id: {not: [1, 2]}}
+    assert_search "product", ["Product A"], where: {user_ids: {lte: 2, gte: 2}}
+    # or
+    assert_search "product", ["Product A", "Product B", "Product C"], where: {or: [[{in_stock: true}, {store_id: 3}]]}
+    assert_search "product", ["Product A", "Product B", "Product C"], where: {or: [[{orders_count: [2, 4]}, {store_id: [1, 2]}]]}
+    assert_search "product", ["Product A", "Product D"], where: {or: [[{orders_count: 1}, {created_at: {gte: now - 1}, backordered: true}]]}
+    # all
+    assert_search "product", ["Product A", "Product C"], where: {user_ids: {all: [1, 3]}}
+    assert_search "product", [], where: {user_ids: {all: [1, 2, 3, 4]}}
+    # any / nested terms
+    assert_search "product", ["Product B", "Product C"], where: {user_ids: {not: [2], in: [1, 3]}}
+    # not / exists
+    assert_search "product", ["Product D"], where: {user_ids: nil}
+    assert_search "product", ["Product A", "Product B", "Product C"], where: {user_ids: {not: nil}}
+    assert_search "product", ["Product A", "Product C", "Product D"], where: {user_ids: [3, nil]}
+    assert_search "product", ["Product B"], where: {user_ids: {not: [3, nil]}}
+  end
+
+  def test_regexp
+    store_names ["Product A"]
+    assert_search "*", ["Product A"], where: {name: /Pro.+/}
+  end
+
+  def test_alternate_regexp
+    store_names ["Product A", "Item B"]
+    assert_search "*", ["Product A"], where: {name: {regexp: "Pro.+"}}
+  end
+
+  def test_where_string
+    store [
+      {name: "Product A", color: "RED"}
+    ]
+    assert_search "product", ["Product A"], where: {color: "RED"}
+  end
+
+  def test_where_nil
+    store [
+      {name: "Product A"},
+      {name: "Product B", color: "red"}
+    ]
+    assert_search "product", ["Product A"], where: {color: nil}
+  end
+
+  def test_where_id
+    store_names ["Product A"]
+    product = Product.last
+    assert_search "product", ["Product A"], where: {id: product.id.to_s}
+  end
+
+  def test_where_empty
+    store_names ["Product A"]
+    assert_search "product", ["Product A"], where: {}
+  end
+
+  def test_where_empty_array
+    store_names ["Product A"]
+    assert_search "product", [], where: {store_id: []}
+  end
+
+  # http://elasticsearch-users.115913.n3.nabble.com/Numeric-range-quey-or-filter-in-an-array-field-possible-or-not-td4042967.html
+  # https://gist.github.com/jprante/7099463
+  def test_where_range_array
+    store [
+      {name: "Product A", user_ids: [11, 23, 13, 16, 17, 23]},
+      {name: "Product B", user_ids: [1, 2, 3, 4, 5, 6, 7, 8, 9]},
+      {name: "Product C", user_ids: [101, 230, 150, 200]}
+    ]
+    assert_search "product", ["Product A"], where: {user_ids: {gt: 10, lt: 24}}
+  end
+
+  def test_where_range_array_again
+    store [
+      {name: "Product A", user_ids: [19, 32, 42]},
+      {name: "Product B", user_ids: [13, 40, 52]}
+    ]
+    assert_search "product", ["Product A"], where: {user_ids: {gt: 26, lt: 36}}
+  end
+
+  def test_near
+    store [
+      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
+      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000}
+    ]
+    assert_search "san", ["San Francisco"], where: {location: {near: [37.5, -122.5]}}
+  end
+
+  def test_near_within
+    store [
+      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
+      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000},
+      {name: "San Marino", latitude: 43.9333, longitude: 12.4667}
+    ]
+    assert_search "san", ["San Francisco", "San Antonio"], where: {location: {near: [37, -122], within: "2000mi"}}
+  end
+
+  def test_top_left_bottom_right
+    store [
+      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
+      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000}
+    ]
+    assert_search "san", ["San Francisco"], where: {location: {top_left: [38, -123], bottom_right: [37, -122]}}
+  end
+
+  def test_multiple_locations
+    store [
+      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
+      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000}
+    ]
+    assert_search "san", ["San Francisco"], where: {multiple_locations: {near: [37.5, -122.5]}}
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: searchkick
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-16 00:00:00.000000000 Z
+date: 2015-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -123,6 +123,7 @@ files:
 - test/autocomplete_test.rb
 - test/boost_test.rb
 - test/ci/before_install.sh
+- test/dangerous_reindex_test.rb
 - test/facets_test.rb
 - test/gemfiles/activerecord31.gemfile
 - test/gemfiles/activerecord32.gemfile
@@ -137,7 +138,10 @@ files:
 - test/index_test.rb
 - test/inheritance_test.rb
 - test/match_test.rb
+- test/misspellings_test.rb
 - test/model_test.rb
+- test/order_test.rb
+- test/pagination_test.rb
 - test/query_test.rb
 - test/records_test.rb
 - test/reindex_job_test.rb
@@ -149,6 +153,7 @@ files:
 - test/suggest_test.rb
 - test/synonyms_test.rb
 - test/test_helper.rb
+- test/where_test.rb
 homepage: https://github.com/ankane/searchkick
 licenses:
 - MIT
@@ -169,7 +174,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Searchkick learns what your users are looking for. As more people search,
@@ -180,6 +185,7 @@ test_files:
 - test/autocomplete_test.rb
 - test/boost_test.rb
 - test/ci/before_install.sh
+- test/dangerous_reindex_test.rb
 - test/facets_test.rb
 - test/gemfiles/activerecord31.gemfile
 - test/gemfiles/activerecord32.gemfile
@@ -194,7 +200,10 @@ test_files:
 - test/index_test.rb
 - test/inheritance_test.rb
 - test/match_test.rb
+- test/misspellings_test.rb
 - test/model_test.rb
+- test/order_test.rb
+- test/pagination_test.rb
 - test/query_test.rb
 - test/records_test.rb
 - test/reindex_job_test.rb
@@ -206,4 +215,4 @@ test_files:
 - test/suggest_test.rb
 - test/synonyms_test.rb
 - test/test_helper.rb
-has_rdoc: 
+- test/where_test.rb