[API] Add percolate back

Author: estolfo

elasticsearch-api/lib/elasticsearch/api/actions/percolate.rb

@@ -0,0 +1,73 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Return names of queries matching a document.
+      #
+      # Percolator allows you to register queries and then evaluate a document against them:
+      # the IDs of matching queries are returned in the response.
+      #
+      # @deprecated The `_percolate` API has been deprecated in favour of a special field mapping and the
+      #             `percolate` query;
+      #             see https://www.elastic.co/guide/en/elasticsearch/reference/5.5/breaking_50_percolator.html
+      #
+      # See full example for Elasticsearch 5.x and higher in <https://github.com/elastic/elasticsearch-ruby/blob/master/examples/percolator/percolator_alerts.rb>
+      #
+      # @option arguments [String] :index The index of the document being percolated. (*Required*)
+      # @option arguments [String] :type The type of the document being percolated. (*Required*)
+      # @option arguments [String] :id Fetch the document specified by index/type/id and
+      #                                use it instead of the passed `doc`
+      # @option arguments [Hash] :body The percolator request definition using the percolate DSL
+      # @option arguments [List] :routing A comma-separated list of specific routing values
+      # @option arguments [String] :preference Specify the node or shard the operation should be performed on
+      #                                        (default: random)
+      # @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when
+      #                                                 unavailable (missing or closed)
+      # @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves into
+      #                                               no concrete indices. (This includes `_all` string or when no
+      #                                               indices have been specified)
+      # @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices that are
+      #                                              open, closed or both. (options: open, closed)
+      # @option arguments [String] :percolate_index The index to percolate the document into. Defaults to passed `index`.
+      # @option arguments [String] :percolate_format Return an array of matching query IDs instead of objects.
+      #                                              (options: ids)
+      # @option arguments [String] :percolate_type The type to percolate document into. Defaults to passed `type`.
+      # @option arguments [Number] :version Explicit version number for concurrency control
+      # @option arguments [String] :version_type Specific version type (options: internal, external, external_gte, force)
+      #
+      # @see http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-percolate.html
+      #
+      def percolate(arguments={})
+        Utils.__report_unsupported_method :percolate
+
+        raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
+        raise ArgumentError, "Required argument 'type' missing"  unless arguments[:type]
+        method = HTTP_GET
+        path   = Utils.__pathify Utils.__escape(arguments[:index]),
+                                 Utils.__escape(arguments[:type]),
+                                 Utils.__escape(arguments[:id]),
+                                 '_percolate'
+
+        params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
+        body   = arguments[:body]
+
+        perform_request(method, path, params, body).body
+      end
+
+      # Register this action with its valid params when the module is loaded.
+      #
+      # @since 6.2.0
+      ParamsRegistry.register(:percolate, [
+          :routing,
+          :preference,
+          :ignore_unavailable,
+          :allow_no_indices,
+          :expand_wildcards,
+          :percolate_index,
+          :percolate_type,
+          :percolate_format,
+          :version,
+          :version_type ].freeze)
+    end
+  end
+end

elasticsearch-api/spec/elasticsearch/api/actions/percolate_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe 'client#percolate' do
+
+  let(:expected_args) do
+    [
+        'GET',
+        url,
+        { },
+        body
+    ]
+  end
+
+  let(:body) do
+    { doc: { foo: 'bar' }}
+  end
+
+  let(:url) do
+    'foo/bar/_percolate'
+  end
+
+  let(:client) do
+    Class.new { include Elasticsearch::API }.new
+  end
+
+  it 'requires the :index argument' do
+    expect {
+      client.percolate(type: 'bar', body: {})
+    }.to raise_exception(ArgumentError)
+  end
+
+  it 'requires the :type argument' do
+    expect {
+      client.percolate(index: 'foo', body: {})
+    }.to raise_exception(ArgumentError)
+  end
+
+  it 'performs the request' do
+    expect(client_double.percolate(index: 'foo', type: 'bar', body: { doc: { foo: 'bar' } })).to eq({})
+  end
+
+  context 'when the request needs to be URL-escaped' do
+
+    let(:url) do
+      'foo%5Ebar/bar%2Fbam/_percolate'
+    end
+
+    it 'URL-escapes the parts' do
+      expect(client_double.percolate(index: 'foo^bar', type: 'bar/bam', body: { doc: { foo: 'bar' } })).to eq({})
+    end
+  end
+
+  context 'when the document id needs to be URL-escaped' do
+
+    let(:url) do
+      'foo%5Ebar/bar%2Fbam/some%2Fid/_percolate'
+    end
+
+    let(:body) do
+      nil
+    end
+
+    it 'URL-escapes the id' do
+      expect(client_double.percolate(index: 'foo^bar', type: 'bar/bam', id: 'some/id')).to eq({})
+    end
+  end
+end