elasticsearch-dsl-builder 0.0.14 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4b68f810a7e501951cafe0ace207769c6c03d36
-  data.tar.gz: d25a1c5fdccf86444559be220f9a3464ec488a85
+  metadata.gz: 3cd56b7c2da3fde323d2b45b9a44cfa90aa2ad1b
+  data.tar.gz: 8d3cbbd3d97b17a88ca1ba879c38eb4981e4a09d
 SHA512:
-  metadata.gz: f6b5b0f60006cd83e625489ea03b14ac26fe47fc9dc30e0f31686eb39e23d3cb2e6618cd060fbf0401998aed156ad2b9df696d38bb3e942ddd3f8774dd6f0e7f
-  data.tar.gz: d08ed977c1887649bae135bd57b90b5bbb718ad979cdc9c012b0fa96b675cc036fe0773b7face50156c87d0c499566756f42a9fba3a74b613dea1e8e6d83af02
+  metadata.gz: d78f1a2d967897f2b5e39125ab947792c3226dce95a6c9ed17bfc5e42c928e3202a46a31e5b2d2f7fdd65768f4f96027f3629282d67d3c8bde9b13234dd3f014
+  data.tar.gz: 349e21160f7121ae9ba3882721968961ccb2c5fe8c7ac87d5c2bb4e8e8e824b32db227388520933a78672c849e481874f667785faa6b2174c9580477f9912929

data/elasticsearch-dsl-builder.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'elasticsearch-dsl-builder'
-  s.version     = '0.0.14'
+  s.version     = '0.0.15'
   s.date        = '2017-10-06'
   s.summary     = 'Library utilizing builder pattern providing Ruby API for the Elasticsearch Query DSL'
   s.description = 'TBD'

data/lib/elasticsearch_dsl_builder/dsl.rb

@@ -2,11 +2,11 @@ require 'elasticsearch_dsl_builder/dsl/version'
 
 require 'elasticsearch_dsl_builder/dsl/search/aggregation'
 require 'elasticsearch_dsl_builder/dsl/search/query'
+require 'elasticsearch_dsl_builder/dsl/search/script'
 require 'elasticsearch_dsl_builder/dsl/search/sort'
 require 'elasticsearch_dsl_builder/exceptions'
 
 Dir[File.expand_path('../dsl/search/queries/**/*.rb', __FILE__)].each        { |f| require f }
-Dir[File.expand_path('../dsl/search/filters/**/*.rb', __FILE__)].each        { |f| require f }
 Dir[File.expand_path('../dsl/search/aggregations/**/*.rb', __FILE__)].each   { |f| require f }
 
 require 'elasticsearch_dsl_builder/dsl/search'

data/lib/elasticsearch_dsl_builder/dsl/search/aggregations/cardinality.rb

@@ -0,0 +1,33 @@
+module ElasticsearchDslBuilder
+  module DSL
+    module Search
+      module Aggregations
+        class Cardinality < Aggregation
+          def initialize
+            @type = :cardinality
+            super()
+          end
+
+          def field(field)
+            raise ArgumentError, 'field must be a String' unless field.instance_of?(String)
+            @field = field
+            self
+          end
+
+          def script(script)
+            raise ArgumentError, 'script must be a Script' unless script.instance_of?(Script)
+            @script = script.to_hash
+            self
+          end
+
+          def to_hash
+            @aggregation = {}
+            @aggregation.update(field: @field) if @field
+            @aggregation.update(script: @script) if @script
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch_dsl_builder/dsl/search/aggregations/children.rb

@@ -0,0 +1,26 @@
+module ElasticsearchDslBuilder
+  module DSL
+    module Search
+      module Aggregations
+        class Children < Aggregation
+          def initialize(type)
+            @type = :children
+            type(type)
+            super()
+          end
+
+          def type(type)
+            raise ArgumentError, 'type must be a String' unless type.instance_of?(String)
+            @child_type = type
+            self
+          end
+
+          def to_hash
+            @aggregation = { type: @child_type }
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch_dsl_builder/dsl/search/aggregations/date_histogram.rb

@@ -0,0 +1,40 @@
+module ElasticsearchDslBuilder
+  module DSL
+    module Search
+      module Aggregations
+        class DateHistogram < Aggregation
+          def initialize(field = nil, interval = nil)
+            @type = :date_histogram
+            field(field)
+            interval(interval)
+            super()
+          end
+
+          def field(field)
+            raise ArgumentError, 'field must be a String' unless field.instance_of?(String)
+            @field = field
+            self
+          end
+
+          def interval(interval)
+            raise ArgumentError, 'interval must be a String' unless interval.instance_of?(String)
+            @interval = interval
+            self
+          end
+
+          def format(format)
+            raise ArgumentError, 'format must be a String' unless format.instance_of?(String)
+            @format = format
+            self
+          end
+
+          def to_hash
+            @aggregation = { field: @field, interval: @interval }
+            @aggregation.update(format: @format) if @format
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch_dsl_builder/dsl/search/aggregations/date_range.rb

@@ -0,0 +1,56 @@
+module ElasticsearchDslBuilder
+  module DSL
+    module Search
+      module Aggregations
+        class DateRange < Aggregation
+          def initialize(field = nil)
+            @type = :date_range
+            field(field)
+            super()
+          end
+
+          def field(field)
+            raise ArgumentError, 'field must be a String' unless field.instance_of?(String)
+            @field = field
+            self
+          end
+
+          def format(format)
+            raise ArgumentError, 'format must be a String' unless format.instance_of?(String)
+            @format = format
+            self
+          end
+
+          def keyed(keyed)
+            raise ArgumentError, 'keyed must be a boolean' unless !!keyed == keyed
+            @keyed = keyed
+            self
+          end
+
+          def range(from: nil, to: nil, key: nil)
+            @ranges ||= []
+            raise ArgumentError, 'must pass at least one of from or to' if from.nil? && to.nil?
+            from_valid = from.instance_of?(String) || from.is_a?(Numeric)
+            raise ArgumentError, 'from must be String or Numeric' if !from.nil? && !from_valid
+            to_valid = to.instance_of?(String) || to.is_a?(Numeric)
+            raise ArgumentError, 'to must be String or Numeric' if !to.nil? && !to_valid
+            range = {}
+            range.update(from: from) if from
+            range.update(to: to) if to
+            range.update(key: key) if key
+            @ranges << range
+            self
+          end
+
+          def to_hash
+            @aggregation = { field: @field }
+            @aggregation.update(format: @format) if @format
+            @aggregation.update(keyed: @keyed) if @keyed
+            @aggregation.update(ranges: @ranges) if @ranges
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch_dsl_builder/dsl/search/aggregations/filter.rb

@@ -0,0 +1,26 @@
+module ElasticsearchDslBuilder
+  module DSL
+    module Search
+      module Aggregations
+        class Filter < Aggregation
+          def initialize(query)
+            @type = :filter
+            filter(query)
+            super()
+          end
+
+          def filter(query)
+            raise ArgumentError, 'query must be a Queries::Query' unless query.is_a?(Queries::Query)
+            @query = query.to_hash
+            self
+          end
+
+          def to_hash
+            @aggregation = @query
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch_dsl_builder/dsl/search/aggregations/filters.rb

@@ -0,0 +1,40 @@
+module ElasticsearchDslBuilder
+  module DSL
+    module Search
+      module Aggregations
+        class Filters < Aggregation
+          def initialize
+            @type = :filters
+            super()
+          end
+
+          def filter(query, name = nil)
+            raise ArgumentError, 'query must extend type Queries::Query' unless query.is_a?(Queries::Query)
+            query = query.to_hash
+
+            if name.nil?
+              # Adding an anonymous filter
+              raise ArgumentError, 'this aggregation already contains named filters. cannot mix' if @filters.instance_of?(Hash)
+              @filters ||= []
+              @filters << query
+            else
+              # Adding named filter
+              raise ArgumentError, 'this aggregation already contains anonymous filters. cannot mix' if @filters.instance_of?(Array)
+              name_valid = name.instance_of?(String) || name.instance_of?(Symbol)
+              raise ArgumentError, 'name must be a String or Symbol' unless name_valid
+              @filters ||= {}
+              @filters[name.to_sym] = query
+            end
+            self
+          end
+
+          def to_hash
+            raise ArgumentError, 'no filters were added' if @filters.nil?
+            @aggregation = { filters: @filters }
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch_dsl_builder/dsl/search/aggregations/geohash_grid.rb

@@ -0,0 +1,47 @@
+module ElasticsearchDslBuilder
+  module DSL
+    module Search
+      module Aggregations
+        class GeohashGrid < Aggregation
+          def initialize(field)
+            @type = :geohash_grid
+            field(field)
+            super()
+          end
+
+          def field(field)
+            raise ArgumentError, 'field must be a String' unless field.instance_of?(String)
+            @field = field
+            self
+          end
+
+          def precision(precision)
+            raise ArgumentError, 'precision must be a Numeric' unless precision.is_a?(Numeric)
+            @precision = precision
+            self
+          end
+
+          def size(size)
+            raise ArgumentError, 'size must be a Numeric' unless size.is_a?(Numeric)
+            @size = size
+            self
+          end
+
+          def shard_size(shard_size)
+            raise ArgumentError, 'shard_size must be a Numeric' unless shard_size.is_a?(Numeric)
+            @shard_size = shard_size
+            self
+          end
+
+          def to_hash
+            @aggregation = { field: @field }
+            @aggregation.update(precision: @precision) if @precision
+            @aggregation.update(size: @size) if @size
+            @aggregation.update(shard_size: @shard_size) if @shard_size
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch_dsl_builder/dsl/search/aggregations/range.rb

@@ -0,0 +1,57 @@
+module ElasticsearchDslBuilder
+  module DSL
+    module Search
+      module Aggregations
+        class Range < Aggregation
+          def initialize
+            @type = :range
+            super()
+          end
+
+          def field(field)
+            raise ArgumentError, 'field must be a String' unless field.instance_of?(String)
+            @field = field
+            self
+          end
+
+          def script(script)
+            raise ArgumentError, 'script must be a Script' unless script.instance_of?(Script)
+            @script = script.to_hash
+            self
+          end
+
+          def keyed(keyed)
+            raise ArgumentError, 'keyed must be a boolean' unless !!keyed == keyed
+            @keyed = keyed
+            self
+          end
+
+          def range(from: nil, to: nil, key: nil)
+            @ranges ||= []
+            raise ArgumentError, 'must pass at least one of from or to' if from.nil? && to.nil?
+            from_valid = from.instance_of?(String) || from.is_a?(Numeric)
+            raise ArgumentError, 'from must be String or Numeric' if !from.nil? && !from_valid
+            to_valid = to.instance_of?(String) || to.is_a?(Numeric)
+            raise ArgumentError, 'to must be String or Numeric' if !to.nil? && !to_valid
+            range = {}
+            range.update(from: from) if from
+            range.update(to: to) if to
+            range.update(key: key) if key
+            @ranges << range
+            self
+          end
+
+          def to_hash
+            raise ArgumentError, 'must have set at least one of [field, script]' if @field.nil? && @script.nil?
+            @aggregation = {}
+            @aggregation.update(field: @field) if @field
+            @aggregation.update(script: @script) if @script
+            @aggregation.update(keyed: @keyed) if @keyed
+            @aggregation.update(ranges: @ranges) if @ranges
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch_dsl_builder/dsl/search/aggregations/stats.rb

@@ -0,0 +1,40 @@
+module ElasticsearchDslBuilder
+  module DSL
+    module Search
+      module Aggregations
+        class Stats < Aggregation
+          def initialize
+            @type = :stats
+            super()
+          end
+
+          def field(field)
+            raise ArgumentError, 'field must be a String' unless field.instance_of?(String)
+            @field = field
+            self
+          end
+
+          def script(script)
+            raise ArgumentError, 'script must be a Script' unless script.instance_of?(Script)
+            @script = script.to_hash
+            self
+          end
+
+          def missing(missing)
+            @missing = missing
+            self
+          end
+
+          def to_hash
+            raise ArgumentError, 'must have set at least one of [field, script]' if @field.nil? && @script.nil?
+            @aggregation = {}
+            @aggregation.update(field: @field) if @field
+            @aggregation.update(script: @script) if @script
+            @aggregation.update(missing: @missing) if @missing
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch_dsl_builder/dsl/search/aggregations/sum.rb

@@ -0,0 +1,40 @@
+module ElasticsearchDslBuilder
+  module DSL
+    module Search
+      module Aggregations
+        class Sum < Aggregation
+          def initialize
+            @type = :sum
+            super()
+          end
+
+          def field(field)
+            raise ArgumentError, 'field must be a String' unless field.instance_of?(String)
+            @field = field
+            self
+          end
+
+          def script(script)
+            raise ArgumentError, 'script must be a Script' unless script.instance_of?(Script)
+            @script = script.to_hash
+            self
+          end
+
+          def missing(missing)
+            @missing = missing
+            self
+          end
+
+          def to_hash
+            raise ArgumentError, 'must have set at least one of [field, script]' if @field.nil? && @script.nil?
+            @aggregation = {}
+            @aggregation.update(field: @field) if @field
+            @aggregation.update(script: @script) if @script
+            @aggregation.update(missing: @missing) if @missing
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch_dsl_builder/dsl/search/aggregations/sum_bucket.rb

@@ -0,0 +1,41 @@
+module ElasticsearchDslBuilder
+  module DSL
+    module Search
+      module Aggregations
+        class SumBucket < Aggregation
+          def initialize(buckets_path)
+            @type = :sum_bucket
+            buckets_path(buckets_path)
+            super()
+          end
+
+          def buckets_path(buckets_path)
+            raise ArgumentError, 'buckets_path must be a String' unless buckets_path.instance_of?(String)
+            @buckets_path = buckets_path
+            self
+          end
+
+          def gap_policy(gap_policy)
+            raise ArgumentError, 'gap_policy must be a String' unless gap_policy.instance_of?(String)
+            @gap_policy = gap_policy
+            self
+          end
+
+          def format(format)
+            raise ArgumentError, 'format must be a String' unless format.instance_of?(String)
+            @format = format
+            self
+          end
+
+          def to_hash
+            @aggregation = { buckets_path: @buckets_path }
+            @aggregation.update(field: @field) if @field
+            @aggregation.update(gap_policy: @gap_policy) if @gap_policy
+            @aggregation.update(format: @format) if @format
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch_dsl_builder/dsl/search/aggregations/terms.rb

@@ -3,9 +3,8 @@ module ElasticsearchDslBuilder
     module Search
       module Aggregations
         class Terms < Aggregation
-          def initialize(field = nil)
+          def initialize
             @type = :terms
-            field(field)
             super()
           end
 
@@ -15,6 +14,12 @@ module ElasticsearchDslBuilder
             self
           end
 
+          def script(script)
+            raise ArgumentError, 'script must be a Script' unless script.instance_of?(Script)
+            @script = script.to_hash
+            self
+          end
+
           def size(size)
             raise ArgumentError, 'size must be Numeric' unless size.is_a?(Numeric)
             @size = size
@@ -39,6 +44,7 @@ module ElasticsearchDslBuilder
 
           def to_hash
             @aggregation = { field: @field }
+            @aggregation.update(script: @script) if @script
             @aggregation.update(size: @size) if @size
             @aggregation.update(include: @include) if @include
             @aggregation.update(exclude: @exclude) if @exclude

data/lib/elasticsearch_dsl_builder/dsl/search/queries/exists.rb

@@ -3,7 +3,7 @@ module ElasticsearchDslBuilder
     module Search
       module Queries
         class Exists < Query
-          def initialize(field = nil)
+          def initialize(field)
             @type = :exists
             field(field)
             super()

data/lib/elasticsearch_dsl_builder/dsl/search/queries/geo_bounding_box.rb

@@ -0,0 +1,61 @@
+module ElasticsearchDslBuilder
+  module DSL
+    module Search
+      module Queries
+        class GeoBoundingBox < Query
+          def initialize(field)
+            @type = :geo_bounding_box
+            field(field)
+            super()
+          end
+
+          def field(field)
+            field_valid = field.instance_of?(String) || field.instance_of?(Symbol)
+            raise ArgumentError, 'field must be a String or Symbol' unless field_valid
+            @field = field.to_sym
+            self
+          end
+
+          def top_left(lat, lon)
+            raise ArgumentError, 'lat must be numeric' unless lat.is_a?(Numeric)
+            raise ArgumentError, 'lon must be numeric' unless lon.is_a?(Numeric)
+            @top_left = { lat: lat, lon: lon }
+            self
+          end
+
+          def top_left_geohash(geohash)
+            raise ArgumentError, 'geohash must be a String' unless geohash.instance_of?(String)
+            @top_left = geohash
+            self
+          end
+
+          def bottom_right(lat, lon)
+            raise ArgumentError, 'lat must be numeric' unless lat.is_a?(Numeric)
+            raise ArgumentError, 'lon must be numeric' unless lon.is_a?(Numeric)
+            @bottom_right = { lat: lat, lon: lon }
+            self
+          end
+
+          def bottom_right_geohash(geohash)
+            raise ArgumentError, 'geohash must be a String' unless geohash.instance_of?(String)
+            @bottom_right = geohash
+            self
+          end
+
+          def type(type)
+            raise ArgumentError, 'type must be a String' unless type.instance_of?(String)
+            @geo_type = type
+            self
+          end
+
+          def to_hash
+            raise ArgumentError, 'must have set bounding box' if @top_left.nil? || @bottom_right.nil?
+            @query = { @field => { top_left: @top_left, bottom_right: @bottom_right } }
+            @query.update(type: @geo_type) if @geo_type
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch_dsl_builder/dsl/search/queries/terms.rb

@@ -19,7 +19,7 @@ module ElasticsearchDslBuilder
 
           def field(field)
             field_valid = field.instance_of?(String) || field.instance_of?(Symbol)
-            raise ArgumentError, 'field must be a String' unless field_valid
+            raise ArgumentError, 'field must be a String or Symbol' unless field_valid
             @field = field.to_sym
             self
           end

data/lib/elasticsearch_dsl_builder/dsl/search/script.rb

@@ -0,0 +1,42 @@
+module ElasticsearchDslBuilder
+  module DSL
+    module Search
+      class Script
+        def lang(lang)
+          raise ArgumentError, 'lang must be a String' unless lang.instance_of?(String)
+          @lang = lang
+          self
+        end
+
+        def source(source)
+          raise ArgumentError, 'can be inline or file script. not both' if @file
+          raise ArgumentError, 'source must be a String' unless source.instance_of?(String)
+          @source = source
+          self
+        end
+
+        def file(file)
+          raise ArgumentError, 'can be inline or file script. not both' if @source
+          raise ArgumentError, 'file must be a String' unless file.instance_of?(String)
+          @file = file
+          self
+        end
+
+        def params(params)
+          raise ArgumentError, 'params must be a hash' unless params.instance_of?(Hash)
+          @params = params
+          self
+        end
+
+        def to_hash
+          script = {}
+          @lang ||= 'painless'
+          script.update(lang: @lang, source: @source) if @source
+          script.update(file: @file) if @file
+          script.update(params: @params) if @params
+          script
+        end
+      end
+    end
+  end
+end

data/spec/lib/dsl/search/aggregations/cardinality_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Aggregations::Cardinality do
+  it 'should fail if field not valid' do
+    expect { Aggregations::Cardinality.new.field(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::Cardinality.new.field(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if script is not valid' do
+    expect { Aggregations::Cardinality.new.script(Script.new.source('source').file('file')) }.to raise_error(ArgumentError)
+    expect { Aggregations::Cardinality.new.script(Script.new.source(123)) }.to raise_error(ArgumentError)
+    expect { Aggregations::Cardinality.new.script(Script.new.file(123)) }.to raise_error(ArgumentError)
+    expect { Aggregations::Cardinality.new.script(Script.new.source('source').lang(123)) }.to raise_error(ArgumentError)
+    expect { Aggregations::Cardinality.new.script(Script.new.source('source').params(123)) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES aggregation hash' do
+    cardinality = Aggregations::Cardinality.new.field('field_b').script(Script.new.source('source').params(field: 'value'))
+    expect(cardinality.to_hash).to eq(
+      cardinality: { field: 'field_b', script: { lang: 'painless', source: 'source', params: { field: 'value' } } }
+    )
+
+    cardinality = Aggregations::Cardinality.new.field('field_b').script(Script.new.file('file').params(field: 'value'))
+    expect(cardinality.to_hash).to eq(
+      cardinality: { field: 'field_b', script: { file: 'file', params: { field: 'value' } } }
+    )
+  end
+end

data/spec/lib/dsl/search/aggregations/children_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Aggregations::Children do
+  it 'should fail if type not valid' do
+    expect { Aggregations::Children.new(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::Children.new(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Children.new('valid').type(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES aggregation hash' do
+    children = Aggregations::Children.new('type_a')
+    expect(children.to_hash).to eq(children: { type: 'type_a' })
+  end
+end

data/spec/lib/dsl/search/aggregations/date_histogram_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Aggregations::DateHistogram do
+  it 'should fail if field not valid' do
+    expect { Aggregations::DateHistogram.new(123, 'month') }.to raise_error(ArgumentError)
+    expect { Aggregations::DateHistogram.new(nil, 'month') }.to raise_error(ArgumentError)
+    expect { Aggregations::DateHistogram.new('field_a', 'month').field(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if interval not valid' do
+    expect { Aggregations::DateHistogram.new('field_a', 1) }.to raise_error(ArgumentError)
+    expect { Aggregations::DateHistogram.new('field_a') }.to raise_error(ArgumentError)
+    expect { Aggregations::DateHistogram.new('field_a', nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::DateHistogram.new('field_a', 'month').interval(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if format not valid' do
+    expect { Aggregations::DateHistogram.new('field_a').format(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::DateHistogram.new('field_a').format(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES aggregation hash' do
+    date_histogram = Aggregations::DateHistogram.new('field_a', 'month').format('MM-yyy')
+    expect(date_histogram.to_hash).to eq(date_histogram: { field: 'field_a', interval: 'month', format: 'MM-yyy' })
+  end
+end

data/spec/lib/dsl/search/aggregations/date_range_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Aggregations::DateRange do
+  it 'should fail if field not valid' do
+    expect { Aggregations::DateRange.new(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::DateRange.new(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::DateRange.new('field_a').field(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if format not valid' do
+    expect { Aggregations::DateRange.new('field_a').format(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::DateRange.new('field_a').format(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if keyed not valid' do
+    expect { Aggregations::DateRange.new('field_a').keyed(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::DateRange.new('field_a').keyed(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::DateRange.new('field_a').keyed('fail') }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if range not valid' do
+    expect { Aggregations::DateRange.new('field_a').range(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::DateRange.new('field_a').range('now-10M/M', nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::DateRange.new('field_a').range([1, 2]) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES aggregation hash' do
+    date_range = Aggregations::DateRange.new('field_a').
+      format('MM-yyy').keyed(true).
+      range(from: 'now-10M/M', key: 'first').
+      range(from: 'now-20M/M', to: 'now-10M/M', key: 'second').
+      range(to: 'now-20M/M', key: 'third')
+    expect(date_range.to_hash).to eq(
+      date_range: {
+        field: 'field_a', format: 'MM-yyy', keyed: true,
+        ranges: [
+          { from: 'now-10M/M', key: 'first' },
+          { from: 'now-20M/M', to: 'now-10M/M', key: 'second' },
+          { to: 'now-20M/M', key: 'third' }
+        ]
+      }
+    )
+  end
+end

data/spec/lib/dsl/search/aggregations/filter_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Aggregations::Filter do
+  it 'should fail if filter not valid' do
+    expect { Aggregations::Filter.new(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Filter.new(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::Filter.new(Queries::Exists.new('field')).filter(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES aggregation hash' do
+    filter = Aggregations::Filter.new(Queries::Exists.new('field_a'))
+    expect(filter.to_hash).to eq(filter: { exists: { field: 'field_a' } })
+  end
+end

data/spec/lib/dsl/search/aggregations/filters_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Aggregations::Filters do
+  it 'should fail if filter not valid' do
+    expect { Aggregations::Filters.new.filter(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Filters.new.filter(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::Filters.new.filter(Queries::Exists.new('field'), 123) }.to raise_error(ArgumentError)
+    expect { Aggregations::Filters.new.filter(123, 'name') }.to raise_error(ArgumentError)
+    expect do
+      Aggregations::Filters.new.filter(Queries::Exists.new('field'), 'named').
+        filter(Queries::Exists.new('anon_filter'))
+    end.to raise_error(ArgumentError)
+    expect do
+      Aggregations::Filters.new.filter(Queries::Exists.new('anon_filter')).
+        filter(Queries::Exists.new('field'), 'named')
+    end.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES aggregation hash' do
+    filters = Aggregations::Filters.new.
+      filter(Queries::Exists.new('field_a'), 'named_a').
+      filter(Queries::Exists.new('field_b'), 'named_b')
+    expect(filters.to_hash).to eq(
+      filters: { filters: { named_a: { exists: { field: 'field_a' } }, named_b: { exists: { field: 'field_b' } } } }
+    )
+
+    filters = Aggregations::Filters.new.
+      filter(Queries::Exists.new('field_a')).
+      filter(Queries::Exists.new('field_b'))
+    expect(filters.to_hash).to eq(filters: { filters: [{ exists: { field: 'field_a' } }, { exists: { field: 'field_b' } }] })
+  end
+end

data/spec/lib/dsl/search/aggregations/geohash_grid_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Aggregations::GeohashGrid do
+  it 'should fail if field not valid' do
+    expect { Aggregations::GeohashGrid.new(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::GeohashGrid.new(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::GeohashGrid.new('field').field(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if precision not valid' do
+    expect { Aggregations::GeohashGrid.new('field').precision(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::GeohashGrid.new('field').precision('fail') }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if size not valid' do
+    expect { Aggregations::GeohashGrid.new('field').size(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::GeohashGrid.new('field').size('fail') }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if shard_size not valid' do
+    expect { Aggregations::GeohashGrid.new('field').shard_size(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::GeohashGrid.new('field').shard_size('fail') }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES aggregation hash' do
+    geohash_grid = Aggregations::GeohashGrid.new('field').precision(1).size(2).shard_size(3)
+    expect(geohash_grid.to_hash).to eq(geohash_grid: { field: 'field', precision: 1, size: 2, shard_size: 3 })
+  end
+end

data/spec/lib/dsl/search/aggregations/range_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Aggregations::Range do
+  it 'should fail if field not valid' do
+    expect { Aggregations::Range.new.field(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::Range.new.field(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Range.new.field('field_a').field(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if script not valid' do
+    expect { Aggregations::Range.new.script(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::Range.new.script(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Range.new.script(Script.new.source('source')).script(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if keyed not valid' do
+    expect { Aggregations::Range.new.keyed(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::Range.new.keyed(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if range not valid' do
+    expect { Aggregations::Range.new.range(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Range.new.range(1, nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Range.new.range([1, 2]) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES aggregation hash' do
+    range = Aggregations::Range.new.field('field_a').script(Script.new.source('source')).keyed(true).
+      range(from: 2, key: 'first').
+      range(from: 1, to: 2, key: 'second').
+      range(to: 1, key: 'third')
+    expect(range.to_hash).to eq(
+      range: {
+        field: 'field_a', script: { lang: 'painless', source: 'source' }, keyed: true,
+        ranges: [
+          { from: 2, key: 'first' },
+          { from: 1, to: 2, key: 'second' },
+          { to: 1, key: 'third' }
+        ]
+      }
+    )
+  end
+end

data/spec/lib/dsl/search/aggregations/stats_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Aggregations::Stats do
+  it 'should fail if field not valid' do
+    expect { Aggregations::Stats.new.field(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::Stats.new.field(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Stats.new.field('field_a').field(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if script not valid' do
+    expect { Aggregations::Stats.new.script(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::Stats.new.script(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Stats.new.script(Script.new.source('source')).script(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES aggregation hash' do
+    stats = Aggregations::Stats.new.field('field_a').script(Script.new.source('source')).missing(1)
+    expect(stats.to_hash).to eq(stats: { field: 'field_a', script: { lang: 'painless', source: 'source' }, missing: 1 })
+  end
+end

data/spec/lib/dsl/search/aggregations/sum_bucket_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Aggregations::SumBucket do
+  it 'should fail if buckets_path not valid' do
+    expect { Aggregations::SumBucket.new(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::SumBucket.new(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::SumBucket.new('valid').buckets_path(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if gap_policy not valid' do
+    expect { Aggregations::SumBucket.new('valid').gap_policy(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::SumBucket.new('valid').gap_policy(123) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if format not valid' do
+    expect { Aggregations::SumBucket.new('valid').format(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::SumBucket.new('valid').format(123) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES aggregation hash' do
+    sum_bucket = Aggregations::SumBucket.new('buckets_path').gap_policy('skip').format('fmt')
+    expect(sum_bucket.to_hash).to eq(sum_bucket: { buckets_path: 'buckets_path', gap_policy: 'skip', format: 'fmt' })
+  end
+end

data/spec/lib/dsl/search/aggregations/sum_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Aggregations::Sum do
+  it 'should fail if field not valid' do
+    expect { Aggregations::Sum.new.field(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::Sum.new.field(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Sum.new.field('field_a').field(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if script not valid' do
+    expect { Aggregations::Sum.new.script(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::Sum.new.script(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Sum.new.script(Script.new.source('source')).script(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES aggregation hash' do
+    sum = Aggregations::Sum.new.field('field_a').script(Script.new.source('source')).missing(1)
+    expect(sum.to_hash).to eq(sum: { field: 'field_a', script: { lang: 'painless', source: 'source' }, missing: 1 })
+  end
+end

data/spec/lib/dsl/search/aggregations/terms_spec.rb

@@ -2,35 +2,50 @@ require 'spec_helper'
 
 describe ElasticsearchDslBuilder::DSL::Search::Aggregations::Terms do
   it 'should fail if field not valid' do
-    expect { Aggregations::Terms.new(123) }.to raise_error(ArgumentError)
-    expect { Aggregations::Terms.new(nil) }.to raise_error(ArgumentError)
-    expect { Aggregations::Terms.new('field_a').field(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new.field(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new.field(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if script is not valid' do
+    expect { Aggregations::Terms.new.script(Script.new.source('source').file('file')) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new.script(Script.new.source(123)) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new.script(Script.new.file(123)) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new.script(Script.new.source('source').lang(123)) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new.script(Script.new.source('source').params(123)) }.to raise_error(ArgumentError)
   end
 
   it 'should fail if size not valid' do
-    expect { Aggregations::Terms.new('field_a').size('fail') }.to raise_error(ArgumentError)
-    expect { Aggregations::Terms.new('field_a').size(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new.field('field_a').size('fail') }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new.field('field_a').size(nil) }.to raise_error(ArgumentError)
   end
 
   it 'should fail if include not valid' do
-    expect { Aggregations::Terms.new('field_a').include(nil) }.to raise_error(ArgumentError)
-    expect { Aggregations::Terms.new('field_a').include({}) }.to raise_error(ArgumentError)
-    expect { Aggregations::Terms.new('field_a').include([1, 2]) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new.field('field_a').include(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new.field('field_a').include({}) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new.field('field_a').include([1, 2]) }.to raise_error(ArgumentError)
   end
 
   it 'should fail if exclude not valid' do
-    expect { Aggregations::Terms.new('field_a').exclude(nil) }.to raise_error(ArgumentError)
-    expect { Aggregations::Terms.new('field_a').exclude({}) }.to raise_error(ArgumentError)
-    expect { Aggregations::Terms.new('field_a').exclude([1, 2]) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new.field('field_a').exclude(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new.field('field_a').exclude({}) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new.field('field_a').exclude([1, 2]) }.to raise_error(ArgumentError)
   end
 
   it 'should chain create valid ES aggregation hash' do
-    terms = Aggregations::Terms.new('field_a').
+    terms = Aggregations::Terms.new.
+      field('field_a').
+      script(Script.new.file('file').params(field: 'value')).
       size(5).
       include('*ball').exclude(['baseball', 'racquetball']).
-      aggregation('nested_agg', Aggregations::Terms.new('field_b'))
+      aggregation('nested_agg', Aggregations::Terms.new.field('field_b'))
     expect(terms.to_hash).to eq(
-      terms: { field: 'field_a', size: 5, include: '*ball', exclude: ['baseball', 'racquetball'] },
+      terms: {
+        field: 'field_a',
+        script: { file: 'file', params: { field: 'value' } },
+        size: 5,
+        include: '*ball',
+        exclude: ['baseball', 'racquetball']
+      },
       aggregations: { nested_agg: { terms: { field: 'field_b' } } }
     )
   end

data/spec/lib/dsl/search/queries/geo_bounding_box_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Queries::GeoBoundingBox do
+  it 'should fail if field not a String or Symbol' do
+    expect { Queries::GeoBoundingBox.new(123) }.to raise_error(ArgumentError)
+    expect { Queries::GeoBoundingBox.new(nil) }.to raise_error(ArgumentError)
+    expect { Queries::GeoBoundingBox.new('field').field({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if top_left arguments not Numeric' do
+    expect { Queries::GeoBoundingBox.new('field').top_left({}, nil) }.to raise_error(ArgumentError)
+    expect { Queries::GeoBoundingBox.new('field').top_left(1, nil) }.to raise_error(ArgumentError)
+    expect { Queries::GeoBoundingBox.new('field').top_left({}, 1) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if bottom_right arguments not Numeric' do
+    expect { Queries::GeoBoundingBox.new('field').bottom_right({}, nil) }.to raise_error(ArgumentError)
+    expect { Queries::GeoBoundingBox.new('field').bottom_right(1, nil) }.to raise_error(ArgumentError)
+    expect { Queries::GeoBoundingBox.new('field').bottom_right({}, 1) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if top_left_geohash argument not a String' do
+    expect { Queries::GeoBoundingBox.new('field').top_left_geohash({}) }.to raise_error(ArgumentError)
+    expect { Queries::GeoBoundingBox.new('field').top_left_geohash(nil) }.to raise_error(ArgumentError)
+    expect { Queries::GeoBoundingBox.new('field').top_left_geohash(1) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if bottom_right_geohash argument not a String' do
+    expect { Queries::GeoBoundingBox.new('field').bottom_right_geohash({}) }.to raise_error(ArgumentError)
+    expect { Queries::GeoBoundingBox.new('field').bottom_right_geohash(nil) }.to raise_error(ArgumentError)
+    expect { Queries::GeoBoundingBox.new('field').bottom_right_geohash(1) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if type argument not a String' do
+    expect { Queries::GeoBoundingBox.new('field').type({}) }.to raise_error(ArgumentError)
+    expect { Queries::GeoBoundingBox.new('field').type(nil) }.to raise_error(ArgumentError)
+    expect { Queries::GeoBoundingBox.new('field').type(1) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES query hash' do
+    geo_bounding_box = Queries::GeoBoundingBox.new(:field_a).
+      top_left(1, 2).bottom_right(3, 4).type('indexed')
+    expect(geo_bounding_box.to_hash).to eq(
+      geo_bounding_box: { field_a: { top_left: { lat: 1, lon: 2 }, bottom_right: { lat: 3, lon: 4 } }, type: 'indexed' }
+    )
+
+    geo_bounding_box = Queries::GeoBoundingBox.new(:field_a).
+      top_left_geohash('dr5r9ydj2y73').bottom_right_geohash('dr5r9ydj2y73').type('indexed')
+    expect(geo_bounding_box.to_hash).to eq(
+      geo_bounding_box: { field_a: { top_left: 'dr5r9ydj2y73', bottom_right: 'dr5r9ydj2y73' }, type: 'indexed' }
+    )
+  end
+end

data/spec/lib/dsl/search/script_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Script do
+  it 'should raise error if lang not valid' do
+    expect { Script.new.lang(123) }.to raise_error(ArgumentError)
+    expect { Script.new.lang(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should raise error if source not valid' do
+    expect { Script.new.source(123) }.to raise_error(ArgumentError)
+    expect { Script.new.source(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should raise error if file not valid' do
+    expect { Script.new.file(123) }.to raise_error(ArgumentError)
+    expect { Script.new.file(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should raise error if params not valid' do
+    expect { Script.new.params(123) }.to raise_error(ArgumentError)
+    expect { Script.new.params(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should raise error if both file and source are set' do
+    expect { Script.new.source('source').file('file') }.to raise_error(ArgumentError)
+    expect { Script.new.file('file').source('source') }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain build valid ES script' do
+    script = Script.new.lang('painless').source('source').params(field: 'value')
+    expect(script.to_hash).to eq(lang: 'painless', source: 'source', params: { field: 'value' })
+
+    script = Script.new.lang('painless').file('file').params(field: 'value')
+    expect(script.to_hash).to eq(file: 'file', params: { field: 'value' })
+  end
+end

data/spec/lib/dsl/search_spec.rb

@@ -53,7 +53,7 @@ describe ElasticsearchDslBuilder::DSL::Search::Search do
       search_after(2, 1).
       include_fields('id', 'content').
       exclude_fields('no_show').
-      aggregation('my_agg', Aggregations::Terms.new('field_a'))
+      aggregation('my_agg', Aggregations::Terms.new.field('field_a'))
 
     expect(search.to_hash).to eq(
       query: { bool: {} },

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elasticsearch-dsl-builder
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.15
 platform: ruby
 authors:
 - Marvin Guerra
@@ -85,11 +85,23 @@ files:
 - lib/elasticsearch_dsl_builder/dsl.rb
 - lib/elasticsearch_dsl_builder/dsl/search.rb
 - lib/elasticsearch_dsl_builder/dsl/search/aggregation.rb
+- lib/elasticsearch_dsl_builder/dsl/search/aggregations/cardinality.rb
+- lib/elasticsearch_dsl_builder/dsl/search/aggregations/children.rb
+- lib/elasticsearch_dsl_builder/dsl/search/aggregations/date_histogram.rb
+- lib/elasticsearch_dsl_builder/dsl/search/aggregations/date_range.rb
+- lib/elasticsearch_dsl_builder/dsl/search/aggregations/filter.rb
+- lib/elasticsearch_dsl_builder/dsl/search/aggregations/filters.rb
+- lib/elasticsearch_dsl_builder/dsl/search/aggregations/geohash_grid.rb
 - lib/elasticsearch_dsl_builder/dsl/search/aggregations/nested.rb
+- lib/elasticsearch_dsl_builder/dsl/search/aggregations/range.rb
+- lib/elasticsearch_dsl_builder/dsl/search/aggregations/stats.rb
+- lib/elasticsearch_dsl_builder/dsl/search/aggregations/sum.rb
+- lib/elasticsearch_dsl_builder/dsl/search/aggregations/sum_bucket.rb
 - lib/elasticsearch_dsl_builder/dsl/search/aggregations/terms.rb
 - lib/elasticsearch_dsl_builder/dsl/search/queries/bool.rb
 - lib/elasticsearch_dsl_builder/dsl/search/queries/exists.rb
 - lib/elasticsearch_dsl_builder/dsl/search/queries/function_score.rb
+- lib/elasticsearch_dsl_builder/dsl/search/queries/geo_bounding_box.rb
 - lib/elasticsearch_dsl_builder/dsl/search/queries/has_child.rb
 - lib/elasticsearch_dsl_builder/dsl/search/queries/has_parent.rb
 - lib/elasticsearch_dsl_builder/dsl/search/queries/match.rb
@@ -100,14 +112,27 @@ files:
 - lib/elasticsearch_dsl_builder/dsl/search/queries/terms.rb
 - lib/elasticsearch_dsl_builder/dsl/search/queries/wildcard.rb
 - lib/elasticsearch_dsl_builder/dsl/search/query.rb
+- lib/elasticsearch_dsl_builder/dsl/search/script.rb
 - lib/elasticsearch_dsl_builder/dsl/search/sort.rb
 - lib/elasticsearch_dsl_builder/dsl/version.rb
 - lib/elasticsearch_dsl_builder/exceptions.rb
+- spec/lib/dsl/search/aggregations/cardinality_spec.rb
+- spec/lib/dsl/search/aggregations/children_spec.rb
+- spec/lib/dsl/search/aggregations/date_histogram_spec.rb
+- spec/lib/dsl/search/aggregations/date_range_spec.rb
+- spec/lib/dsl/search/aggregations/filter_spec.rb
+- spec/lib/dsl/search/aggregations/filters_spec.rb
+- spec/lib/dsl/search/aggregations/geohash_grid_spec.rb
 - spec/lib/dsl/search/aggregations/nested_spec.rb
+- spec/lib/dsl/search/aggregations/range_spec.rb
+- spec/lib/dsl/search/aggregations/stats_spec.rb
+- spec/lib/dsl/search/aggregations/sum_bucket_spec.rb
+- spec/lib/dsl/search/aggregations/sum_spec.rb
 - spec/lib/dsl/search/aggregations/terms_spec.rb
 - spec/lib/dsl/search/queries/bool_spec.rb
 - spec/lib/dsl/search/queries/exists_spec.rb
 - spec/lib/dsl/search/queries/function_score_spec.rb
+- spec/lib/dsl/search/queries/geo_bounding_box_spec.rb
 - spec/lib/dsl/search/queries/has_child_spec.rb
 - spec/lib/dsl/search/queries/has_parent_spec.rb
 - spec/lib/dsl/search/queries/match_spec.rb
@@ -117,6 +142,7 @@ files:
 - spec/lib/dsl/search/queries/term_spec.rb
 - spec/lib/dsl/search/queries/terms_spec.rb
 - spec/lib/dsl/search/queries/wildcard_spec.rb
+- spec/lib/dsl/search/script_spec.rb
 - spec/lib/dsl/search/sort_spec.rb
 - spec/lib/dsl/search_spec.rb
 - spec/lib/dsl_spec.rb
@@ -148,11 +174,23 @@ specification_version: 4
 summary: Library utilizing builder pattern providing Ruby API for the Elasticsearch
   Query DSL
 test_files:
+- spec/lib/dsl/search/aggregations/cardinality_spec.rb
+- spec/lib/dsl/search/aggregations/children_spec.rb
+- spec/lib/dsl/search/aggregations/date_histogram_spec.rb
+- spec/lib/dsl/search/aggregations/date_range_spec.rb
+- spec/lib/dsl/search/aggregations/filter_spec.rb
+- spec/lib/dsl/search/aggregations/filters_spec.rb
+- spec/lib/dsl/search/aggregations/geohash_grid_spec.rb
 - spec/lib/dsl/search/aggregations/nested_spec.rb
+- spec/lib/dsl/search/aggregations/range_spec.rb
+- spec/lib/dsl/search/aggregations/stats_spec.rb
+- spec/lib/dsl/search/aggregations/sum_bucket_spec.rb
+- spec/lib/dsl/search/aggregations/sum_spec.rb
 - spec/lib/dsl/search/aggregations/terms_spec.rb
 - spec/lib/dsl/search/queries/bool_spec.rb
 - spec/lib/dsl/search/queries/exists_spec.rb
 - spec/lib/dsl/search/queries/function_score_spec.rb
+- spec/lib/dsl/search/queries/geo_bounding_box_spec.rb
 - spec/lib/dsl/search/queries/has_child_spec.rb
 - spec/lib/dsl/search/queries/has_parent_spec.rb
 - spec/lib/dsl/search/queries/match_spec.rb
@@ -162,6 +200,7 @@ test_files:
 - spec/lib/dsl/search/queries/term_spec.rb
 - spec/lib/dsl/search/queries/terms_spec.rb
 - spec/lib/dsl/search/queries/wildcard_spec.rb
+- spec/lib/dsl/search/script_spec.rb
 - spec/lib/dsl/search/sort_spec.rb
 - spec/lib/dsl/search_spec.rb
 - spec/lib/dsl_spec.rb