elasticsearch-dsl 0.1.3 → 0.1.4

data/lib/elasticsearch/dsl/search/aggregations/pipeline/serial_diff.rb

@@ -0,0 +1,36 @@
+module Elasticsearch
+  module DSL
+    module Search
+      module Aggregations
+
+        # Serial differencing is a technique where values in a time series are subtracted from itself at different time lags or periods.
+        #
+        # @example Passing the options as a Hash
+        #
+        #     aggregation :thirtieth_difference do
+        #       serial_diff buckets_path: 'the_sum'
+        #     end
+        #
+        # @example Passing the options as a block
+        #
+        #     aggregation :thirtieth_difference do
+        #       serial_diff do
+        #         buckets_path 'the_sum'
+        #         lag 30
+        #       end
+        #     end
+        #
+        # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-pipeline-serialdiff-aggregation.html
+        #
+        class SerialDiff
+          include BaseAggregationComponent
+
+          option_method :buckets_path
+          option_method :lag
+          option_method :gap_policy
+          option_method :format
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/dsl/search/aggregations/pipeline/stats_bucket.rb

@@ -0,0 +1,34 @@
+module Elasticsearch
+  module DSL
+    module Search
+      module Aggregations
+
+        # A sibling pipeline aggregation which calculates a variety of stats across all bucket of a specified metric in a sibling aggregation.
+        #
+        # @example Passing the options as a Hash
+        #
+        #     aggregation :stats_monthly_sales do
+        #       stats_bucket buckets_path: 'sales_per_month>sales'
+        #     end
+        #
+        # @example Passing the options as a block
+        #
+        #     aggregation :stats_monthly_sales do
+        #       stats_bucket do
+        #         buckets_path 'sales_per_month>sales'
+        #       end
+        #     end
+        #
+        # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-pipeline-stats-bucket-aggregation.html
+        #
+        class StatsBucket
+          include BaseAggregationComponent
+
+          option_method :buckets_path
+          option_method :gap_policy
+          option_method :format
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/dsl/search/aggregations/pipeline/sum_bucket.rb

@@ -0,0 +1,34 @@
+module Elasticsearch
+  module DSL
+    module Search
+      module Aggregations
+
+        # A sibling pipeline aggregation which calculates the sum across all bucket of a specified metric in a sibling aggregation.
+        #
+        # @example Passing the options as a Hash
+        #
+        #     aggregation :sum_monthly_sales do
+        #       sum_bucket buckets_path: 'sales_per_month>sales'
+        #     end
+        #
+        # @example Passing the options as a block
+        #
+        #     aggregation :sum_monthly_sales do
+        #       sum_bucket do
+        #         buckets_path 'sales_per_month>sales'
+        #       end
+        #     end
+        #
+        # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-pipeline-sum-bucket-aggregation.html
+        #
+        class SumBucket
+          include BaseAggregationComponent
+
+          option_method :buckets_path
+          option_method :gap_policy
+          option_method :format
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/dsl/search/queries/bool.rb

@@ -57,6 +57,11 @@ module Elasticsearch
             self
           end
 
+          def filter(*args, &block)
+            @filter = block ? Filter.new(*args, &block) : args.first
+            self
+          end
+
           def to_hash
             @hash[name].update(@args.to_hash) if @args.respond_to?(:to_hash)
 
@@ -66,6 +71,11 @@ module Elasticsearch
               @hash[name] = @args unless @args.nil? || @args.empty?
             end
 
+            if @filter
+              _filter = @filter.respond_to?(:to_hash) ? @filter.to_hash : @filter
+              @hash[name].update(filter: _filter)
+            end
+
             @hash
           end
         end

data/lib/elasticsearch/dsl/search/sort.rb

@@ -36,14 +36,23 @@ module Elasticsearch
         #
         def to_hash
           if @block
-            call
+            call unless @block_called
+            @block_called = true
           else
-            @value << @args if @args
+            @value << @args if @args && !@args.empty? && ! @value.include?(@args)
           end
 
           @hash = @value.flatten
           @hash
         end
+
+        # Return whether the definition is empty
+        #
+        # @return [Boolean]
+        #
+        def empty?
+          to_hash.empty?
+        end
       end
     end
   end

data/lib/elasticsearch/dsl/version.rb

@@ -1,5 +1,5 @@
 module Elasticsearch
   module DSL
-    VERSION = "0.1.3"
+    VERSION = "0.1.4"
   end
 end

data/test/integration/search_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class SearchIntegrationTest < ::Elasticsearch::Test::IntegrationTestCase
+      include Elasticsearch::DSL::Search
+
+      class MySearch
+        include Elasticsearch::DSL::Search
+
+        def initialize(q)
+          @q = q
+        end
+
+        def tags
+          %w[ one two ]
+        end
+
+        def search_definition
+          search do |q|
+            q.query do |q|
+              q.bool do |q|
+                q.must do |q|
+                  q.match title: @q
+                end
+                q.must do |q|
+                  q.terms tags: tags
+                end
+              end
+            end
+          end
+        end
+      end
+
+      context "The Search class" do
+        startup do
+          Elasticsearch::Extensions::Test::Cluster.start(nodes: 1) if ENV['SERVER'] and not Elasticsearch::Extensions::Test::Cluster.running?
+        end
+
+        setup do
+          @client.indices.create index: 'test'
+          @client.index index: 'test', type: 'd', id: '1', body: { title: 'Test', tags: ['one'] }
+          @client.index index: 'test', type: 'd', id: '2', body: { title: 'Test', tags: ['one', 'two'] }
+          @client.index index: 'test', type: 'd', id: '3', body: { title: 'Test', tags: ['three'] }
+          @client.indices.refresh index: 'test'
+        end
+
+
+        should "have access to the calling context" do
+          s = MySearch.new('test')
+          response = @client.search index: 'test', body: s.search_definition.to_hash
+
+          assert_equal 2, response['hits']['total']
+          assert_equal 'Test', response['hits']['hits'][0]['_source']['title']
+          assert_same_elements ['1', '2'], response['hits']['hits'].map { |d| d['_id'] }
+        end
+      end
+    end
+  end
+end

data/test/unit/aggregations/missing_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class MissingTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Aggregations
+
+        context "Missing aggregation" do
+          subject { Missing.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ missing: {} }, subject.to_hash)
+          end
+
+          should "take a Hash" do
+            subject = Missing.new( { field: 'foo' } )
+            assert_equal({ missing: { field: "foo" } }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject.field 'foo'
+
+            assert_equal %w[ field ], subject.to_hash[:missing].keys.map(&:to_s).sort
+            assert_equal 'foo', subject.to_hash[:missing][:field]
+          end
+
+          should "take a block" do
+            subject = Missing.new do
+              field 'bar'
+            end
+
+            assert_equal({missing: { field: 'bar' } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/aggregations/pipeline/avg_bucket_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class AvgBucketTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Aggregations
+
+        context "Avg Bucket agg" do
+          subject { AvgBucket.new }
+
+          should "be converted to a hash" do
+            assert_equal({ avg_bucket: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = AvgBucket.new :foo
+
+            subject.buckets_path 'bar'
+            subject.gap_policy 'bar'
+            subject.format 'bar'
+
+            assert_equal %w[ buckets_path format gap_policy ],
+              subject.to_hash[:avg_bucket][:foo].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:avg_bucket][:foo][:buckets_path]
+          end
+
+          should "take a block" do
+            subject = AvgBucket.new :foo do
+              format 'bar'
+            end
+            assert_equal({avg_bucket: { foo: { format: 'bar' } } }, subject.to_hash)
+          end
+
+        end
+      end
+    end
+  end
+end

data/test/unit/aggregations/pipeline/bucket_script_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class BucketScriptTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Aggregations
+
+        context "Bucket Script agg" do
+          subject { BucketScript.new }
+
+          should "be converted to a hash" do
+            assert_equal({ bucket_script: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = BucketScript.new :foo
+
+            subject.buckets_path foo: 'foo', bar: 'bar'
+            subject.script 'bar'
+            subject.gap_policy 'skip'
+            subject.format 'bar'
+
+            assert_equal %w[ buckets_path format gap_policy script ],
+              subject.to_hash[:bucket_script][:foo].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:bucket_script][:foo][:buckets_path][:bar]
+          end
+
+          should "take a block" do
+            subject = BucketScript.new :foo do
+              format 'bar'
+            end
+            assert_equal({bucket_script: { foo: { format: 'bar' } } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/aggregations/pipeline/bucket_selector_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class BucketSelectorTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Aggregations
+
+        context "Bucket Selector agg" do
+          subject { BucketSelector.new }
+
+          should "be converted to a hash" do
+            assert_equal({ bucket_selector: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = BucketSelector.new :foo
+
+            subject.buckets_path foo: 'foo', bar: 'bar'
+            subject.script 'bar'
+            subject.gap_policy 'skip'
+
+            assert_equal %w[ buckets_path gap_policy script ],
+              subject.to_hash[:bucket_selector][:foo].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:bucket_selector][:foo][:buckets_path][:bar]
+          end
+
+          should "take a block" do
+            subject = BucketSelector.new :foo do
+              gap_policy 'skip'
+            end
+            assert_equal({bucket_selector: { foo: { gap_policy: 'skip' } } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/aggregations/pipeline/cumulative_sum_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class CumulativeSumTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Aggregations
+
+        context "Cumulative Sum Bucket agg" do
+          subject { CumulativeSum.new }
+
+          should "be converted to a hash" do
+            assert_equal({ cumulative_sum: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = CumulativeSum.new :foo
+
+            subject.buckets_path 'bar'
+            subject.format 'bar'
+
+            assert_equal %w[ buckets_path format ],
+              subject.to_hash[:cumulative_sum][:foo].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:cumulative_sum][:foo][:buckets_path]
+          end
+
+          should "take a block" do
+            subject = CumulativeSum.new :foo do
+              format 'bar'
+            end
+            assert_equal({cumulative_sum: { foo: { format: 'bar' } } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/aggregations/pipeline/derivative_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class DerivativeTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Aggregations
+
+        context "Derivative agg" do
+          subject { Derivative.new }
+
+          should "be converted to a hash" do
+            assert_equal({ derivative: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = Derivative.new :foo
+
+            subject.buckets_path 'bar'
+            subject.gap_policy 'bar'
+            subject.format 'bar'
+
+            assert_equal %w[ buckets_path format gap_policy ],
+              subject.to_hash[:derivative][:foo].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:derivative][:foo][:buckets_path]
+          end
+
+          should "take a block" do
+            subject = Derivative.new :foo do
+              format 'bar'
+            end
+            assert_equal({derivative: { foo: { format: 'bar' } } }, subject.to_hash)
+          end
+
+        end
+      end
+    end
+  end
+end