arelastic 1.3.1 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d96135e275fd9ab247666893b15e684ee782dead
-  data.tar.gz: cdc3cd878e4c5f71a0f90d9c3337e9b4611e3df3
+  metadata.gz: 2235317037c0d00226ff1d0d0199c26094dc9458
+  data.tar.gz: 3bf89dcf40341c09cf22304858105610a76f0066
 SHA512:
-  metadata.gz: 82a9a205c20da2f7aa6908faa80073c1ed170173580436eac6b92b3e2903bdb88b1fa016cc5d89e3e1f256e979a48cf8e372d41f904cf3f40e698fb117a52c1b
-  data.tar.gz: 93736e6182ddfdfefabf2680e94c2d4e65d9fff3de38d02ce94827758d444d9c8ec56b2d8dd52c40aba5fe1c7af8697eb82f95e55d421ab3eb81946e094b6296
+  metadata.gz: 3e498c09d739f8c92a392512cd3d1ea7b9dac13a84a4dd29c1921d608926a2a2fc28113b5fde9051deb843b4aec0b45d93c41e12d770f3e998cdaed24217486c
+  data.tar.gz: afe811fa073caec58e99251271fddfeb1e72532a101a49e2b97a9a3551bdb8d1d03223e7019b24e863f5944676ffa5082f0cf2f1638fab6a15768cad87dbacde

data/lib/arelastic.rb

@@ -2,7 +2,6 @@ require 'arelastic/arities'
 require 'arelastic/nodes'
 require 'arelastic/aggregations'
 require 'arelastic/queries'
-require 'arelastic/filters'
 require 'arelastic/mappings'
 require 'arelastic/searches'
 require 'arelastic/sorts'

data/lib/arelastic/arities/unary.rb

@@ -14,7 +14,7 @@ module Arelastic
 
       module Methods
         def initialize expr
-          # raise "#{expr.inspect} must be an Arelastic::Filters::Filter" unless expr.is_a?(Arelastic::Filters::Filter)
+          # raise "#{expr.inspect} must be an Arelastic::Queries::Filter" unless expr.is_a?(Arelastic::Queries::Filter)
           @expr = expr
         end
 

data/lib/arelastic/builders/filter.rb

@@ -7,16 +7,16 @@ module Arelastic
         end
 
         def ids *ids
-          Arelastic::Filters::Ids.new ids.flatten
+          Arelastic::Queries::Ids.new ids.flatten
         end
 
         def not expr
-          Arelastic::Filters::Not.new expr
+          Arelastic::Queries::Bool.new must_not: expr
         end
       end
 
       def eq other
-        Arelastic::Filters::Term.new field, other
+        Arelastic::Queries::Term.new field, other
       end
 
       def not_eq other
@@ -32,7 +32,7 @@ module Arelastic
             range 'gte' => other.begin, 'lte' => other.end
           end
         else
-          Arelastic::Filters::Terms.new field, other, options
+          Arelastic::Queries::Terms.new field, other, options
         end
       end
 
@@ -41,19 +41,19 @@ module Arelastic
       end
 
       def prefix other
-        Arelastic::Filters::Prefix.new field, other
+        Arelastic::Queries::Prefix.new field, other
       end
 
-      def exists
-        Arelastic::Filters::Exists.new field
+      def exists(options = {})
+        Arelastic::Queries::Exists.new field, options
       end
 
       def missing(options = {})
-        Arelastic::Filters::Missing.new field, options
+        exists(options).negate
       end
 
       def regexp other
-        Arelastic::Filters::Regexp.new field, other
+        Arelastic::Queries::Regexp.new field, other
       end
 
       def gteq other
@@ -74,7 +74,7 @@ module Arelastic
 
       private
         def range options
-          Arelastic::Filters::Range.new field, options
+          Arelastic::Queries::Range.new field, options
         end
     end
   end

data/lib/arelastic/builders/query.rb

@@ -10,8 +10,8 @@ module Arelastic
           query Arelastic::Queries::ConstantScore.new(search)
         end
 
-        def filtered(query: nil, filter: nil)
-          query Arelastic::Queries::Filtered.new(query: query, filter: filter)
+        def bool(must: nil, filter: nil, should: nil, must_not: nil)
+          query Arelastic::Queries::Bool.new(must: must, filter: filter, should: should, must_not: must_not)
         end
 
         def match_all

data/lib/arelastic/nodes.rb

@@ -1,4 +1,3 @@
 require 'arelastic/nodes/node'
 
-require 'arelastic/nodes/nested'
 require 'arelastic/nodes/hash_group'

data/lib/arelastic/queries.rb

@@ -2,15 +2,25 @@ require 'arelastic/queries/query'
 
 require 'arelastic/queries/bool'
 require 'arelastic/queries/constant_score'
+require 'arelastic/queries/exists'
 require 'arelastic/queries/field'
-require 'arelastic/queries/filtered'
+require 'arelastic/queries/geo_bounding_box'
+require 'arelastic/queries/geo_distance'
+require 'arelastic/queries/has_child'
+require 'arelastic/queries/ids'
+require 'arelastic/queries/limit'
 require 'arelastic/queries/match'
 require 'arelastic/queries/match_all'
+require 'arelastic/queries/match_none'
 require 'arelastic/queries/multi_match'
 require 'arelastic/queries/nested'
 require 'arelastic/queries/prefix'
+require 'arelastic/queries/query'
 require 'arelastic/queries/query_string'
+require 'arelastic/queries/range'
+require 'arelastic/queries/regexp'
+require 'arelastic/queries/script'
 require 'arelastic/queries/simple_query_string'
-require 'arelastic/queries/terms'
 require 'arelastic/queries/term'
+require 'arelastic/queries/terms'
 require 'arelastic/queries/wildcard'

data/lib/arelastic/queries/bool.rb

@@ -1,18 +1,27 @@
 module Arelastic
   module Queries
     class Bool < Arelastic::Queries::Query
-      attr_accessor :options
-      def initialize(options)
-        @options = options
+      attr_accessor :must, :filter, :should, :must_not
+      def initialize(must: nil, filter: nil, should: nil, must_not: nil)
+        @must     = must
+        @filter   = filter
+        @should   = should
+        @must_not = must_not
       end
 
       def as_elastic
-        params = {}
-        options.each do |key, value|
-          params[key] = convert_to_elastic(value)
+        searches = {}
+
+        {
+          'must'     => must,
+          'filter'   => filter,
+          'should'   => should,
+          'must_not' => must_not
+        }.each do |k, v|
+          searches[k] = convert_to_elastic(v) if v
         end
 
-        { "bool" => params }
+        {'bool' => searches}
       end
     end
   end

data/lib/arelastic/{filters/missing.rb → queries/exists.rb}

@@ -1,11 +1,10 @@
 module Arelastic
-  module Filters
-    class Missing < Arelastic::Filters::Filter
+  module Queries
+    class Exists < Arelastic::Queries::Query
       attr_reader :field, :options
 
       # Options:
-      #   "existence" => true defaults to true
-      #   "null_value" => true defaults to false
+      #   "null_value" => "_null_"
       def initialize field, options = {}
         @field = field
         @options = options
@@ -13,8 +12,8 @@ module Arelastic
 
       def as_elastic
         params = {"field" => field}.update(options)
-        {"missing" => params}
+        {"exists" => params}
       end
     end
   end
-end
+end

data/lib/arelastic/queries/filter.rb

@@ -0,0 +1,9 @@
+module Arelastic
+  module Queries
+    class Filter < Arelastic::Queries::Query
+      def nested path
+        Arelastic::Queries::Nested.new path, self
+      end
+    end
+  end
+end

data/lib/arelastic/{filters → queries}/geo_bounding_box.rb

@@ -1,6 +1,6 @@
 module Arelastic
-  module Filters
-    class GeoBoundingBox < Arelastic::Filters::Filter
+  module Queries
+    class GeoBoundingBox < Arelastic::Queries::Query
       attr_accessor :field, :bounds, :options
       def initialize(field, bounds, options = {})
         @field    = field

data/lib/arelastic/{filters → queries}/geo_distance.rb

@@ -1,6 +1,6 @@
 module Arelastic
-  module Filters
-    class GeoDistance < Arelastic::Filters::Filter
+  module Queries
+    class GeoDistance < Arelastic::Queries::Query
       attr_accessor :field, :location, :distance, :options
       def initialize(field, location, distance, options = {})
         @field = field

data/lib/arelastic/{filters → queries}/has_child.rb

@@ -1,6 +1,6 @@
 module Arelastic
-  module Filters
-    class HasChild < Arelastic::Filters::Filter
+  module Queries
+    class HasChild < Arelastic::Queries::Query
       attr_reader :type, :query
 
       def initialize type, query

data/lib/arelastic/{filters → queries}/ids.rb

@@ -1,6 +1,6 @@
 module Arelastic
-  module Filters
-    class Ids < Arelastic::Filters::Filter
+  module Queries
+    class Ids < Arelastic::Queries::Query
       attr_reader :values
 
       def initialize values

data/lib/arelastic/{filters → queries}/limit.rb

@@ -1,6 +1,6 @@
 module Arelastic
-  module Filters
-    class Limit < Arelastic::Filters::Filter
+  module Queries
+    class Limit < Arelastic::Queries::Query
       attr_reader :value
 
       def initialize value

data/lib/arelastic/queries/match_none.rb

@@ -0,0 +1,9 @@
+module Arelastic
+  module Queries
+    class MatchNone < Arelastic::Queries::Query
+      def as_elastic
+        {"match_none" => {}}
+      end
+    end
+  end
+end

data/lib/arelastic/queries/nested.rb

@@ -1,7 +1,21 @@
 module Arelastic
   module Queries
     class Nested < Arelastic::Queries::Query
-      include Arelastic::Nodes::Nested
+      attr_accessor :path, :expr
+
+      def initialize(path, expr)
+        @path = path
+        @expr = expr
+      end
+
+      def as_elastic
+        params = {
+          'path'   => path,
+          'query'  => convert_to_elastic(expr)
+        }
+
+        { 'nested' => params }
+      end
     end
   end
 end

data/lib/arelastic/queries/query.rb

@@ -10,4 +10,4 @@ module Arelastic
       end
     end
   end
-end
+end

data/lib/arelastic/queries/range.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Queries
+    class Range < Arelastic::Queries::Query
+      binary 'range'
+    end
+  end
+end

data/lib/arelastic/{filters → queries}/regexp.rb

@@ -1,5 +1,5 @@
 module Arelastic
-  module Filters
+  module Queries
     #
     # Implements support for the Regexp filter.
     #
@@ -9,7 +9,7 @@ module Arelastic
     #
     # Reference: https://www.elastic.co/guide/en/elasticsearch/reference/1.7/query-dsl-regexp-filter.html
     #
-    class Regexp < Filter
+    class Regexp < Query
       binary 'regexp'
 
       def initialize(field, value, options = {})

data/lib/arelastic/{filters → queries}/script.rb

@@ -1,6 +1,6 @@
 module Arelastic
-  module Filters
-    class Script < Arelastic::Filters::Filter
+  module Queries
+    class Script < Arelastic::Queries::Query
       attr_reader :script, :options
 
       def initialize script, options = {}

data/lib/arelastic/searches.rb

@@ -1,7 +1,6 @@
 require 'arelastic/searches/search'
 
 require 'arelastic/searches/aggregations'
-require 'arelastic/searches/filter'
 require 'arelastic/searches/from'
 require 'arelastic/searches/query'
 require 'arelastic/searches/size'

data/test/arelastic/aggregations/filter_test.rb

@@ -1,6 +1,6 @@
 require 'helper'
 
-class Arelastic::Aggregations::TermsTest < Minitest::Test
+class Arelastic::Aggregations::FilterTest < Minitest::Test
   def test_as_elastic
     aggregation = Arelastic::Aggregations::Filter.new('foo', 'exists' => {'field' => 'color'})
     expected = {
@@ -17,7 +17,7 @@ class Arelastic::Aggregations::TermsTest < Minitest::Test
   end
 
   def test_as_elastic_with_node
-    aggregation = Arelastic::Aggregations::Filter.new('foo', Arelastic::Filters::Exists.new('color'))
+    aggregation = Arelastic::Aggregations::Filter.new('foo', Arelastic::Queries::Exists.new('color'))
     expected = {
       "foo" => {
         "filter" => {

data/test/arelastic/builders/filter_test.rb

@@ -7,7 +7,7 @@ class Arelastic::Builders::FilterTest < Minitest::Test
   end
 
   def test_not
-    expected = {"not" => {"terms" => {"color" => "blue"}}}
+    expected = {"bool" => {"must_not" => {"terms" => {"color" => "blue"}}}}
     assert_equal expected, Arelastic::Builders::Filter.not({"terms" => {"color" => "blue"}}).as_elastic    
   end
 
@@ -17,7 +17,7 @@ class Arelastic::Builders::FilterTest < Minitest::Test
   end
 
   def test_not_eq
-    expected = {"not" => {"term" => {"color"=>"blue"}}}
+    expected = {"bool" => {"must_not" => {"term" => {"color" => "blue"}}}}
     assert_equal expected, builder.not_eq('blue').as_elastic
   end
 
@@ -40,7 +40,7 @@ class Arelastic::Builders::FilterTest < Minitest::Test
   end
 
   def test_not_in
-    expected = {"not" => {"terms" => {"color"=>["blue"]}}}
+    expected = {"bool" => {"must_not" => {"terms" => {"color"=>["blue"]}}}}
     assert_equal expected, builder.not_in(['blue']).as_elastic
   end
 
@@ -55,7 +55,7 @@ class Arelastic::Builders::FilterTest < Minitest::Test
   end
 
   def test_missing
-    expected = {"missing" => {"field" => "color"}}
+    expected = {"bool" => {"must_not" => {"exists" => {"field" => "color"}}}}
     assert_equal expected, builder.missing.as_elastic
   end
 

data/test/arelastic/builders/query_test.rb

@@ -8,12 +8,12 @@ class Arelastic::Builders::QueryTest < Minitest::Test
     assert_equal expected, query.as_elastic
   end
 
-  def test_filtered
-    query = Arelastic::Builders::Query.filtered(
-      query: {"query_string" => "foo"},
+  def test_bool
+    query = Arelastic::Builders::Query.bool(
+      must: {"query_string" => "foo"},
       filter: {"term" => "bar"}
     )
-    expected = {"query" => {"filtered" => {"query" => {"query_string" => "foo"}, "filter" => {"term" => "bar"}}}}
+    expected = {"query" => {"bool" => {"must" => {"query_string" => "foo"}, "filter" => {"term" => "bar"}}}}
 
     assert_equal expected, query.as_elastic
   end

data/test/arelastic/builders/search_test.rb

@@ -13,11 +13,11 @@ class Arelastic::Builders::SearchTest < Minitest::Test
     assert_equal Arelastic::Builders::Aggregation, Arelastic::Builders::Search.aggregation
   end
 
-  def test_filter
+  def test_query
     assert_equal Arelastic::Builders::Query, Arelastic::Builders::Search.query
   end
 
-  def test_filter
+  def test_sort
     assert_equal Arelastic::Builders::Sort, Arelastic::Builders::Search.sort
   end
 end

data/test/arelastic/queries/bool_test.rb

@@ -1,15 +1,32 @@
 require 'helper'
 
 class Arelastic::Queries::BoolTest < Minitest::Test
+  # def test_as_elastic
+  #   filtered = Arelastic::Queries::Filtered.new(
+  #     query: {"query_string" => "bar"},
+  #     filter: {"term" => "baz"}
+  #   )
+  #   expected = {"filtered" => {"query" => {"query_string" => "bar"}, "filter" => {"term" => "baz"}}}
+  #
+  #   assert_equal expected, filtered.as_elastic
+  # end
+  #
+  # def test_as_elastic_with_query_node
+  #   filtered = Arelastic::Queries::Filtered.new(query: Arelastic::Queries::QueryString.new("bar"))
+  #   expected = {"filtered" => {"query" => {"query_string" => {"query"=>"bar"}}}}
+  #
+  #   assert_equal expected, filtered.as_elastic
+  # end
+  
   def test_as_elastic
     bool = Arelastic::Queries::Bool.new(
-      'must' => {
+      must: {
         'prefix' => {
           'user' => 'kimchy'
         }
       },
-      'must_not' => Arelastic::Queries::Match.new('color', 'green'),
-      'should' => [
+      must_not: Arelastic::Queries::Match.new('color', 'green'),
+      should: [
         Arelastic::Queries::Match.new('height', 6)
       ]
     )

data/test/arelastic/queries/exists_test.rb

@@ -0,0 +1,15 @@
+require 'helper'
+
+class Arelastic::Queries::ExistsTest < Minitest::Test
+  def test_as_elastic
+    expected = {"exists" => { "field" => "color" }}
+
+    assert_equal expected, Arelastic::Queries::Exists.new('color').as_elastic
+  end
+
+  def test_with_options
+    expected = {"exists" => { "field" => "color", "null_value" => "_null" }}
+
+    assert_equal expected, Arelastic::Queries::Exists.new('color', 'null_value' => "_null").as_elastic
+  end
+end

data/test/arelastic/queries/filter_test.rb

@@ -0,0 +1,22 @@
+require 'helper'
+
+class Arelastic::Queries::FilterTest < Minitest::Test
+  def test_nested
+    filter = Arelastic::Queries::Term.new('foo', 'bar')
+
+    nested_filter = filter.nested 'links'
+
+    assert nested_filter.is_a?(Arelastic::Queries::Nested)
+    expected = {
+      "nested" => {
+        "path" => "links",
+        "query" => {
+          "term" => {
+            "foo" => "bar"
+          }
+        }
+      }
+    }
+    assert_equal(expected, nested_filter.as_elastic)
+  end
+end

data/test/arelastic/{filters → queries}/geo_bounding_box_test.rb

@@ -1,6 +1,6 @@
 require 'helper'
 
-class Arelastic::Filters::GeoBoundingBoxTest < Minitest::Test
+class Arelastic::Queries::GeoBoundingBoxTest < Minitest::Test
   def test_as_elastic
     expected = {
       "geo_bounding_box" => {
@@ -13,7 +13,7 @@ class Arelastic::Filters::GeoBoundingBoxTest < Minitest::Test
 
     assert_equal(
       expected,
-      Arelastic::Filters::GeoBoundingBox.new('location', 'top_left' => [40, -70], 'bottom_right' => [30, -60]).as_elastic
+      Arelastic::Queries::GeoBoundingBox.new('location', 'top_left' => [40, -70], 'bottom_right' => [30, -60]).as_elastic
     )
   end
 
@@ -30,7 +30,7 @@ class Arelastic::Filters::GeoBoundingBoxTest < Minitest::Test
 
     assert_equal(
       expected,
-      Arelastic::Filters::GeoBoundingBox.new('location', {'top_left' => [40, -70], 'bottom_right' => [30, -60]}, 'index' => true).as_elastic
+      Arelastic::Queries::GeoBoundingBox.new('location', {'top_left' => [40, -70], 'bottom_right' => [30, -60]}, 'index' => true).as_elastic
     )
   end
 end

data/test/arelastic/{filters → queries}/geo_distance_test.rb

@@ -1,6 +1,6 @@
 require 'helper'
 
-class Arelastic::Filters::GeoDistanceTest < Minitest::Test
+class Arelastic::Queries::GeoDistanceTest < Minitest::Test
   def test_as_elastic
     expected = {
       "geo_distance" => {
@@ -9,6 +9,6 @@ class Arelastic::Filters::GeoDistanceTest < Minitest::Test
       }
     }
 
-    assert_equal expected, Arelastic::Filters::GeoDistance.new('pin.location', [40, -70], '12km').as_elastic
+    assert_equal expected, Arelastic::Queries::GeoDistance.new('pin.location', [40, -70], '12km').as_elastic
   end
 end

data/test/arelastic/{filters → queries}/has_child_test.rb

@@ -1,9 +1,9 @@
 require 'helper'
 
-class Arelastic::Filters::HasChildTest < Minitest::Test
+class Arelastic::Queries::HasChildTest < Minitest::Test
   def test_as_elastic
     expected = {"has_child" => {"type" => "comment", "query" => {"query_string" => "lol"}}}
 
-    assert_equal expected, Arelastic::Filters::HasChild.new("comment", {"query_string" => "lol"}).as_elastic
+    assert_equal expected, Arelastic::Queries::HasChild.new("comment", {"query_string" => "lol"}).as_elastic
   end
 end

data/test/arelastic/{filters → queries}/ids_test.rb

@@ -1,9 +1,9 @@
 require 'helper'
 
-class Arelastic::Filters::IdsTest < Minitest::Test
+class Arelastic::Queries::IdsTest < Minitest::Test
   def test_as_elastic
     expected = {"ids" => {"values" => ["foo", "bar"]}}
 
-    assert_equal expected, Arelastic::Filters::Ids.new(['foo', 'bar']).as_elastic
+    assert_equal expected, Arelastic::Queries::Ids.new(['foo', 'bar']).as_elastic
   end
 end

data/test/arelastic/queries/match_none_test.rb

@@ -0,0 +1,10 @@
+require 'helper'
+
+class Arelastic::Queries::MatchAllTest < Minitest::Test
+  def test_as_elastic
+    match_all = Arelastic::Queries::MatchNone.new
+
+    expected = {"match_none" => {}}
+    assert_equal expected, match_all.as_elastic
+  end
+end

data/test/arelastic/queries/query_test.rb

@@ -22,6 +22,6 @@ class Arelastic::Queries::QueryTest < Minitest::Test
     negated_filter = filter.negate
 
     assert negated_filter.is_a?(Arelastic::Queries::Bool)
-    assert_equal filter, negated_filter.options[:must_not]
+    assert_equal filter, negated_filter.must_not
   end
-end
+end

data/test/arelastic/{filters → queries}/regexp_test.rb

@@ -1,15 +1,15 @@
 require 'helper'
 
-class Arelastic::Filters::ExistsTest < Minitest::Test
+class Arelastic::Queries::ExistsTest < Minitest::Test
   def test_setting_value_as_regexp_object
     assert_raises TypeError do
-      Arelastic::Filters::Regexp.new('color', /yellow(-green)?/)
+      Arelastic::Queries::Regexp.new('color', /yellow(-green)?/)
     end
   end
 
   def test_string_value
     expected = { 'regexp' => { 'color' => 'blue(-green)?' } }
 
-    assert_equal expected, Arelastic::Filters::Regexp.new('color', 'blue(-green)?').as_elastic
+    assert_equal expected, Arelastic::Queries::Regexp.new('color', 'blue(-green)?').as_elastic
   end
 end

data/test/arelastic/{filters → queries}/script_test.rb

@@ -1,15 +1,15 @@
 require 'helper'
 
-class Arelastic::Filters::ScriptTest < Minitest::Test
+class Arelastic::Queries::ScriptTest < Minitest::Test
   def test_as_elastic
     expected = {"script" => {"script" => "doc['color'].value.charAt(0) == 'r'"}}
 
-    assert_equal expected, Arelastic::Filters::Script.new("doc['color'].value.charAt(0) == 'r'").as_elastic
+    assert_equal expected, Arelastic::Queries::Script.new("doc['color'].value.charAt(0) == 'r'").as_elastic
   end
 
   def test_with_options
     expected = {"script" => {"script" => "doc['color'].value.length() == length", "params" => {"length" => 3}}}
 
-    assert_equal expected, Arelastic::Filters::Script.new("doc['color'].value.length() == length", 'params' => {"length" => 3}).as_elastic
+    assert_equal expected, Arelastic::Queries::Script.new("doc['color'].value.length() == length", 'params' => {"length" => 3}).as_elastic
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arelastic
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 2.0.1
 platform: ruby
 authors:
 - Matthew Higgins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-09 00:00:00.000000000 Z
+date: 2017-07-11 00:00:00.000000000 Z
 dependencies: []
 description: Build Elastic Search queries with objects
 email: developer@matthewhiggins.com
@@ -40,27 +40,6 @@ files:
 - lib/arelastic/builders/query.rb
 - lib/arelastic/builders/search.rb
 - lib/arelastic/builders/sort.rb
-- lib/arelastic/filters.rb
-- lib/arelastic/filters/and.rb
-- lib/arelastic/filters/exists.rb
-- lib/arelastic/filters/filter.rb
-- lib/arelastic/filters/geo_bounding_box.rb
-- lib/arelastic/filters/geo_distance.rb
-- lib/arelastic/filters/has_child.rb
-- lib/arelastic/filters/ids.rb
-- lib/arelastic/filters/limit.rb
-- lib/arelastic/filters/match_all.rb
-- lib/arelastic/filters/missing.rb
-- lib/arelastic/filters/nested.rb
-- lib/arelastic/filters/not.rb
-- lib/arelastic/filters/or.rb
-- lib/arelastic/filters/prefix.rb
-- lib/arelastic/filters/query.rb
-- lib/arelastic/filters/range.rb
-- lib/arelastic/filters/regexp.rb
-- lib/arelastic/filters/script.rb
-- lib/arelastic/filters/term.rb
-- lib/arelastic/filters/terms.rb
 - lib/arelastic/mappings.rb
 - lib/arelastic/mappings/type.rb
 - lib/arelastic/mappings/types/binary.rb
@@ -72,27 +51,35 @@ files:
 - lib/arelastic/mappings/types/string.rb
 - lib/arelastic/nodes.rb
 - lib/arelastic/nodes/hash_group.rb
-- lib/arelastic/nodes/nested.rb
 - lib/arelastic/nodes/node.rb
 - lib/arelastic/queries.rb
 - lib/arelastic/queries/bool.rb
 - lib/arelastic/queries/constant_score.rb
+- lib/arelastic/queries/exists.rb
 - lib/arelastic/queries/field.rb
-- lib/arelastic/queries/filtered.rb
+- lib/arelastic/queries/filter.rb
+- lib/arelastic/queries/geo_bounding_box.rb
+- lib/arelastic/queries/geo_distance.rb
+- lib/arelastic/queries/has_child.rb
+- lib/arelastic/queries/ids.rb
+- lib/arelastic/queries/limit.rb
 - lib/arelastic/queries/match.rb
 - lib/arelastic/queries/match_all.rb
+- lib/arelastic/queries/match_none.rb
 - lib/arelastic/queries/multi_match.rb
 - lib/arelastic/queries/nested.rb
 - lib/arelastic/queries/prefix.rb
 - lib/arelastic/queries/query.rb
 - lib/arelastic/queries/query_string.rb
+- lib/arelastic/queries/range.rb
+- lib/arelastic/queries/regexp.rb
+- lib/arelastic/queries/script.rb
 - lib/arelastic/queries/simple_query_string.rb
 - lib/arelastic/queries/term.rb
 - lib/arelastic/queries/terms.rb
 - lib/arelastic/queries/wildcard.rb
 - lib/arelastic/searches.rb
 - lib/arelastic/searches/aggregations.rb
-- lib/arelastic/searches/filter.rb
 - lib/arelastic/searches/from.rb
 - lib/arelastic/searches/query.rb
 - lib/arelastic/searches/search.rb
@@ -119,30 +106,25 @@ files:
 - test/arelastic/builders/query_test.rb
 - test/arelastic/builders/search_test.rb
 - test/arelastic/builders/sort_test.rb
-- test/arelastic/filters/exists_test.rb
-- test/arelastic/filters/filter_test.rb
-- test/arelastic/filters/geo_bounding_box_test.rb
-- test/arelastic/filters/geo_distance_test.rb
-- test/arelastic/filters/has_child_test.rb
-- test/arelastic/filters/ids_test.rb
-- test/arelastic/filters/match_all_test.rb
-- test/arelastic/filters/match_test.rb
-- test/arelastic/filters/missing_test.rb
-- test/arelastic/filters/nested_test.rb
-- test/arelastic/filters/not_test.rb
-- test/arelastic/filters/query_test.rb
-- test/arelastic/filters/regexp_test.rb
-- test/arelastic/filters/script_test.rb
 - test/arelastic/mappings/types/binary_test.rb
 - test/arelastic/mappings/types/multi_field_test.rb
 - test/arelastic/mappings/types/string_test.rb
 - test/arelastic/nodes/node_test.rb
 - test/arelastic/queries/bool_test.rb
-- test/arelastic/queries/filtered_test.rb
+- test/arelastic/queries/exists_test.rb
+- test/arelastic/queries/filter_test.rb
+- test/arelastic/queries/geo_bounding_box_test.rb
+- test/arelastic/queries/geo_distance_test.rb
+- test/arelastic/queries/has_child_test.rb
+- test/arelastic/queries/ids_test.rb
 - test/arelastic/queries/match_all_test.rb
+- test/arelastic/queries/match_none_test.rb
+- test/arelastic/queries/match_test.rb
 - test/arelastic/queries/multi_match_test.rb
 - test/arelastic/queries/query_string_test.rb
 - test/arelastic/queries/query_test.rb
+- test/arelastic/queries/regexp_test.rb
+- test/arelastic/queries/script_test.rb
 - test/arelastic/queries/simple_query_string_test.rb
 - test/arelastic/queries/wildcard_test.rb
 - test/arelastic/searches/aggregations_test.rb

data/lib/arelastic/filters.rb

@@ -1,21 +0,0 @@
-require 'arelastic/filters/filter'
-
-require 'arelastic/filters/and'
-require 'arelastic/filters/exists'
-require 'arelastic/filters/geo_bounding_box'
-require 'arelastic/filters/geo_distance'
-require 'arelastic/filters/has_child'
-require 'arelastic/filters/ids'
-require 'arelastic/filters/limit'
-require 'arelastic/filters/match_all'
-require 'arelastic/filters/missing'
-require 'arelastic/filters/nested'
-require 'arelastic/filters/not'
-require 'arelastic/filters/or'
-require 'arelastic/filters/prefix'
-require 'arelastic/filters/query'
-require 'arelastic/filters/range'
-require 'arelastic/filters/regexp'
-require 'arelastic/filters/script'
-require 'arelastic/filters/term'
-require 'arelastic/filters/terms'

data/lib/arelastic/filters/and.rb

@@ -1,7 +0,0 @@
-module Arelastic
-  module Filters
-    class And < Arelastic::Filters::Filter
-      polyadic 'and'
-    end
-  end
-end

data/lib/arelastic/filters/exists.rb

@@ -1,15 +0,0 @@
-module Arelastic
-  module Filters
-    class Exists < Arelastic::Filters::Filter
-      attr_reader :field
-
-      def initialize field
-        @field = field
-      end
-
-      def as_elastic
-        {"exists" => { "field" => field }}
-      end
-    end
-  end
-end

data/lib/arelastic/filters/filter.rb

@@ -1,17 +0,0 @@
-module Arelastic
-  module Filters
-    class Filter < Arelastic::Queries::Query
-      def or other
-        Arelastic::Filters::Or.new [self, other]
-      end
-
-      def and other
-        Arelastic::Filters::And.new [self, other]
-      end
-
-      def nested path
-        Arelastic::Filters::Nested.new path, self
-      end
-    end
-  end
-end

data/lib/arelastic/filters/match_all.rb

@@ -1,9 +0,0 @@
-module Arelastic
-  module Filters
-    class MatchAll < Arelastic::Filters::Filter
-      def as_elastic
-        {"match_all" => {}}
-      end
-    end
-  end
-end

data/lib/arelastic/filters/nested.rb

@@ -1,7 +0,0 @@
-module Arelastic
-  module Filters
-    class Nested < Arelastic::Filters::Filter
-      include Arelastic::Nodes::Nested
-    end
-  end
-end

data/lib/arelastic/filters/not.rb

@@ -1,15 +0,0 @@
-module Arelastic
-  module Filters
-    class Not < Arelastic::Filters::Filter
-      attr_reader :expr
-
-      def initialize expr
-        @expr = expr
-      end
-
-      def as_elastic
-        {"not" => convert_to_elastic(expr)}
-      end
-    end
-  end
-end

data/lib/arelastic/filters/or.rb

@@ -1,7 +0,0 @@
-module Arelastic
-  module Filters
-    class Or < Arelastic::Filters::Filter
-      polyadic 'or'
-    end
-  end
-end

data/lib/arelastic/filters/prefix.rb

@@ -1,7 +0,0 @@
-module Arelastic
-  module Filters
-    class Prefix < Arelastic::Filters::Filter
-      binary 'prefix'
-    end
-  end
-end

data/lib/arelastic/filters/query.rb

@@ -1,14 +0,0 @@
-module Arelastic
-  module Filters
-    class Query < Arelastic::Filters::Filter
-      attr_reader :expr
-      def initialize(expr)
-        @expr = expr.is_a?(String) ? {'query_string' => {'query' => expr}} : expr
-      end
-
-      def as_elastic
-        {'query' => convert_to_elastic(expr)}
-      end
-    end
-  end
-end

data/lib/arelastic/filters/range.rb

@@ -1,7 +0,0 @@
-module Arelastic
-  module Filters
-    class Range < Arelastic::Filters::Filter
-      binary 'range'
-    end
-  end
-end

data/lib/arelastic/filters/term.rb

@@ -1,7 +0,0 @@
-module Arelastic
-  module Filters
-    class Term < Arelastic::Filters::Filter
-      binary 'term'
-    end
-  end
-end

data/lib/arelastic/filters/terms.rb

@@ -1,7 +0,0 @@
-module Arelastic
-  module Filters
-    class Terms < Arelastic::Filters::Filter
-      binary 'terms'
-    end
-  end
-end

data/lib/arelastic/nodes/nested.rb

@@ -1,29 +0,0 @@
-module Arelastic
-  module Nodes
-    module Nested
-      def self.included(klass)
-        klass.class_eval do
-          attr_accessor :path, :expr
-        end
-      end
-
-      def initialize(path, expr)
-        @path = path
-        @expr = expr
-      end
-
-      def search_context
-        is_a?(Arelastic::Filters::Filter) ? 'filter' : 'query'
-      end
-
-      def as_elastic
-        params = {
-          'path'          => path,
-          search_context  => convert_to_elastic(expr)
-        }
-
-        { 'nested' => params }
-      end
-    end
-  end
-end

data/lib/arelastic/queries/filtered.rb

@@ -1,19 +0,0 @@
-module Arelastic
-  module Queries
-    class Filtered < Arelastic::Queries::Query
-      attr_accessor :query, :filter
-      def initialize(query: nil, filter: nil)
-        @query = query
-        @filter = filter
-      end
-
-      def as_elastic
-        searches = {}
-        searches['query']  = convert_to_elastic(query)  if query
-        searches['filter'] = convert_to_elastic(filter) if filter
-
-        { "filtered" => searches }
-      end
-    end
-  end
-end

data/lib/arelastic/searches/filter.rb

@@ -1,7 +0,0 @@
-module Arelastic
-  module Searches
-    class Filter < Arelastic::Searches::Search
-      unary 'filter', expects: Arelastic::Filters::Filter
-    end
-  end
-end

data/test/arelastic/filters/exists_test.rb

@@ -1,9 +0,0 @@
-require 'helper'
-
-class Arelastic::Filters::ExistsTest < Minitest::Test
-  def test_as_elastic
-    expected = {"exists" => { "field" => "color" }}
-
-    assert_equal expected, Arelastic::Filters::Exists.new('color').as_elastic
-  end
-end

data/test/arelastic/filters/filter_test.rb

@@ -1,36 +0,0 @@
-require 'helper'
-
-class Arelastic::FilterTest < Minitest::Test
-  def test_and
-    filter = Arelastic::Filters::Filter.new
-
-    and_filter = filter.and(filter)
-
-    assert and_filter.is_a?(Arelastic::Filters::And)
-    assert_equal [filter, filter], and_filter.children
-  end
-
-  def test_or
-    filter = Arelastic::Filters::Filter.new
-
-    and_filter = filter.or(filter)
-
-    assert and_filter.is_a?(Arelastic::Filters::Or)
-    assert_equal [filter, filter], and_filter.children
-  end
-
-  def test_nested
-    filter = Arelastic::Filters::Term.new('foo', 'bar')
-
-    nested_filter = filter.nested 'links'
-
-    assert nested_filter.is_a?(Arelastic::Filters::Nested)
-    expected = {
-      "nested" => {
-        "path" => "links",
-        "filter" => filter.as_elastic
-      }
-    }
-    assert_equal(expected, nested_filter.as_elastic)
-  end
-end

data/test/arelastic/filters/match_all_test.rb

@@ -1,10 +0,0 @@
-require 'helper'
-
-class Arelastic::Filters::MatchAllTest < Minitest::Test
-  def test_as_elastic
-    match_all = Arelastic::Queries::MatchAll.new
-    expected = {"match_all" => {}}
-
-    assert_equal expected, match_all.as_elastic
-  end
-end

data/test/arelastic/filters/missing_test.rb

@@ -1,15 +0,0 @@
-require 'helper'
-
-class Arelastic::Filters::MissingTest < Minitest::Test
-  def test_as_elastic
-    expected = {"missing" => { "field" => "color" }}
-
-    assert_equal expected, Arelastic::Filters::Missing.new('color').as_elastic
-  end
-
-  def test_with_options
-    expected = {"missing" => { "field" => "color", "null_value" => true }}
-
-    assert_equal expected, Arelastic::Filters::Missing.new('color', 'null_value' => true).as_elastic
-  end
-end

data/test/arelastic/filters/nested_test.rb

@@ -1,19 +0,0 @@
-require 'helper'
-
-class Arelastic::Filters::NestedTest < Minitest::Test
-  def test_as_elastic
-    expected = {
-      "nested" => {
-        "path"  => "bunnies",
-        "filter" => {
-          "match" => {
-            "name" => "Harry"
-          }
-        }
-      }
-    }
-
-    assert_equal expected, Arelastic::Filters::Nested.new('bunnies', Arelastic::Queries::Match.new('name', 'Harry')).as_elastic
-  end
-
-end

data/test/arelastic/filters/not_test.rb

@@ -1,9 +0,0 @@
-require 'helper'
-
-class Arelastic::Filters::NotTest < Minitest::Test
-  def test_as_elastic
-    expected = {"not" => { "foo" => "bar" }}
-
-    assert_equal expected, Arelastic::Filters::Not.new('foo' => 'bar').as_elastic
-  end
-end

data/test/arelastic/filters/query_test.rb

@@ -1,15 +0,0 @@
-require 'helper'
-
-class Arelastic::Filters::QueryTest < Minitest::Test
-  def test_as_elastic
-    expected = {"query" => { "match" => {"message" => "this is a test"} }}
-
-    assert_equal expected, Arelastic::Filters::Query.new(Arelastic::Queries::Match.new('message', 'this is a test')).as_elastic
-  end
-
-  def test_with_string
-    expected = {'query' => { 'query_string' => {'query' => 'blue dog'}}}
-
-    assert_equal expected, Arelastic::Filters::Query.new("blue dog").as_elastic
-  end
-end

data/test/arelastic/queries/filtered_test.rb

@@ -1,20 +0,0 @@
-require 'helper'
-
-class Arelastic::Queries::FilteredTest < Minitest::Test
-  def test_as_elastic
-    filtered = Arelastic::Queries::Filtered.new(
-      query: {"query_string" => "bar"},
-      filter: {"term" => "baz"}
-    )
-    expected = {"filtered" => {"query" => {"query_string" => "bar"}, "filter" => {"term" => "baz"}}}
-
-    assert_equal expected, filtered.as_elastic
-  end
-
-  def test_as_elastic_with_query_node
-    filtered = Arelastic::Queries::Filtered.new(query: Arelastic::Queries::QueryString.new("bar"))
-    expected = {"filtered" => {"query" => {"query_string" => {"query"=>"bar"}}}}
-
-    assert_equal expected, filtered.as_elastic
-  end
-end