elasticsearch-api 6.0.1 → 7.0.0

data/lib/elasticsearch/api/actions/mlt.rb

@@ -1,128 +0,0 @@
-module Elasticsearch
-  module API
-    module Actions
-
-      # Return documents similar to the specified one.
-      #
-      # Performs a `more_like_this` query with the specified document as the input.
-      #
-      # @example Search for similar documents using the `title` property of document `myindex/mytype/1`
-      #
-      #     # First, let's setup a synonym-aware analyzer ("quick" <=> "fast")
-      #     client.indices.create index: 'myindex', body: {
-      #       settings: {
-      #         analysis: {
-      #           filter: {
-      #             synonyms: {
-      #               type: 'synonym',
-      #               synonyms: [ "quick,fast" ]
-      #             }
-      #           },
-      #           analyzer: {
-      #             title_synonym: {
-      #               type: 'custom',
-      #               tokenizer: 'whitespace',
-      #               filter: ['lowercase', 'stop', 'snowball', 'synonyms']
-      #             }
-      #           }
-      #         }
-      #       },
-      #       mappings: {
-      #         mytype: {
-      #           properties: {
-      #             title: {
-      #               type: 'string',
-      #               analyzer: 'title_synonym'
-      #             }
-      #           }
-      #         }
-      #       }
-      #     }
-      #
-      #     # Index three documents
-      #     client.index index: 'myindex', type: 'mytype', id: 1, body: { title: 'Quick Brown Fox'   }
-      #     client.index index: 'myindex', type: 'mytype', id: 2, body: { title: 'Slow Black Dog'    }
-      #     client.index index: 'myindex', type: 'mytype', id: 3, body: { title: 'Fast White Rabbit' }
-      #     client.indices.refresh index: 'myindex'
-      #
-      #     client.mlt index: 'myindex', type: 'mytype', id: 1, mlt_fields: 'title', min_doc_freq: 1, min_term_freq: 1
-      #     # => { ... {"title"=>"Fast White Rabbit"}}]}}
-      #
-      # @option arguments [String] :id The document ID (*Required*)
-      # @option arguments [String] :index The name of the index (*Required*)
-      # @option arguments [String] :type The type of the document (use `_all` to fetch
-      #                                  the first document matching the ID across all types) (*Required*)
-      # @option arguments [Hash] :body A specific search request definition
-      # @option arguments [Number] :boost_terms The boost factor
-      # @option arguments [Number] :max_doc_freq The word occurrence frequency as count: words with higher occurrence
-      #                                          in the corpus will be ignored
-      # @option arguments [Number] :max_query_terms The maximum query terms to be included in the generated query
-      # @option arguments [Number] :max_word_len The minimum length of the word: longer words will be ignored
-      # @option arguments [Number] :min_doc_freq The word occurrence frequency as count: words with lower occurrence
-      #                                          in the corpus will be ignored
-      # @option arguments [Number] :min_term_freq The term frequency as percent: terms with lower occurence
-      #                                           in the source document will be ignored
-      # @option arguments [Number] :min_word_len The minimum length of the word: shorter words will be ignored
-      # @option arguments [List] :mlt_fields Specific fields to perform the query against
-      # @option arguments [Number] :percent_terms_to_match How many terms have to match in order to consider
-      #                                                    the document a match (default: 0.3)
-      # @option arguments [String] :routing Specific routing value
-      # @option arguments [Number] :search_from The offset from which to return results
-      # @option arguments [List] :search_indices A comma-separated list of indices to perform the query against
-      #                                          (default: the index containing the document)
-      # @option arguments [String] :search_query_hint The search query hint
-      # @option arguments [String] :search_scroll A scroll search request definition
-      # @option arguments [Number] :search_size The number of documents to return (default: 10)
-      # @option arguments [String] :search_source A specific search request definition (instead of using the request body)
-      # @option arguments [String] :search_type Specific search type (eg. `dfs_then_fetch`, `count`, etc)
-      # @option arguments [List] :search_types A comma-separated list of types to perform the query against
-      #                                        (default: the same type as the document)
-      # @option arguments [List] :stop_words A list of stop words to be ignored
-      #
-      # @see http://elasticsearch.org/guide/reference/api/more-like-this/
-      #
-      def mlt(arguments={})
-        raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
-        raise ArgumentError, "Required argument 'type' missing"  unless arguments[:type]
-        raise ArgumentError, "Required argument 'id' missing"    unless arguments[:id]
-
-        valid_params = [
-          :boost_terms,
-          :max_doc_freq,
-          :max_query_terms,
-          :max_word_len,
-          :min_doc_freq,
-          :min_term_freq,
-          :min_word_len,
-          :mlt_fields,
-          :percent_terms_to_match,
-          :routing,
-          :search_from,
-          :search_indices,
-          :search_query_hint,
-          :search_scroll,
-          :search_size,
-          :search_source,
-          :search_type,
-          :search_types,
-          :stop_words ]
-
-        method = HTTP_GET
-        path   = Utils.__pathify Utils.__escape(arguments[:index]),
-                                 Utils.__escape(arguments[:type]),
-                                 Utils.__escape(arguments[:id]),
-                                 '_mlt'
-
-        params = Utils.__validate_and_extract_params arguments, valid_params
-
-        [:mlt_fields, :search_indices, :search_types, :stop_words].each do |name|
-          params[name] = Utils.__listify(params[name]) if params[name]
-        end
-
-        body   = arguments[:body]
-
-        perform_request(method, path, params, body).body
-      end
-    end
-  end
-end

data/lib/elasticsearch/api/actions/mpercolate.rb

@@ -1,59 +0,0 @@
-module Elasticsearch
-  module API
-    module Actions
-
-      # Perform multiple percolate operations in a single request, similar to the {#msearch} API
-      #
-      # Pass the percolate definitions as header-body pairs in the `:body` argument, as an Array of Hashes.
-      #
-      # @example Perform two different percolations in a single request
-      #
-      #     client.mpercolate \
-      #         body: [
-      #           { percolate: { index: "my-index", type: "my-type" } },
-      #           { doc: { message: "foo bar" } },
-      #           { percolate: { index: "my-other-index", type: "my-other-type", id: "1" } },
-      #           { }
-      #         ]
-      #
-      # @option arguments [String] :index The index of the document being count percolated to use as default
-      # @option arguments [String] :type The type of the document being percolated to use as default.
-      # @option arguments [Array<Hash>]  The percolate request definitions (header & body pairs) (*Required*)
-      # @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)
-      #
-      # @see http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-percolate.html
-      #
-      def mpercolate(arguments={})
-        raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
-        valid_params = [
-          :ignore_unavailable,
-          :allow_no_indices,
-          :expand_wildcards,
-          :percolate_format ]
-
-        method = HTTP_GET
-        path   = "_mpercolate"
-
-        params = Utils.__validate_and_extract_params arguments, valid_params
-        body   = arguments[:body]
-
-        case
-        when body.is_a?(Array)
-          payload = body.map { |d| d.is_a?(String) ? d : Elasticsearch::API.serializer.dump(d) }
-          payload << "" unless payload.empty?
-          payload = payload.join("\n")
-        else
-          payload = body
-        end
-
-        perform_request(method, path, params, payload).body
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-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]
-
-        valid_params = [
-          :routing,
-          :preference,
-          :ignore_unavailable,
-          :allow_no_indices,
-          :expand_wildcards,
-          :percolate_index,
-          :percolate_type,
-          :percolate_format,
-          :version,
-          :version_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, valid_params
-        body   = arguments[:body]
-
-        perform_request(method, path, params, body).body
-      end
-    end
-  end
-end

data/lib/elasticsearch/api/actions/put_template.rb

@@ -1,25 +0,0 @@
-module Elasticsearch
-  module API
-    module Actions
-
-      # Store a template for the search definition in Elasticsearch,
-      # to be later used with the `search_template` method
-      #
-      # @option arguments [String] :id Template ID (*Required*)
-      # @option arguments [Hash] :body The document (*Required*)
-      #
-      # @see http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html
-      #
-      def put_template(arguments={})
-        raise ArgumentError, "Required argument 'id' missing"   unless arguments[:id]
-        raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
-        method = HTTP_PUT
-        path   = "_search/template/#{arguments[:id]}"
-        params = {}
-        body   = arguments[:body]
-
-        perform_request(method, path, params, body).body
-      end
-    end
-  end
-end

data/lib/elasticsearch/api/actions/search_exists.rb

@@ -1,59 +0,0 @@
-module Elasticsearch
-  module API
-    module Actions
-
-      # Return whether documents exists for a particular query
-      #
-      # @option arguments [List] :index A comma-separated list of indices to restrict the results
-      # @option arguments [List] :type A comma-separated list of types to restrict the results
-      # @option arguments [Hash] :body A query to restrict the results specified with the Query DSL (optional)
-      # @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.
-      # @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices
-      #                                              that are open, closed or both.
-      #                                              (options: open, closed, none, all)
-      # @option arguments [Number] :min_score Include only documents with a specific `_score` value in the result
-      # @option arguments [String] :preference Specify the node or shard the operation should be performed on
-      #                                        (default: random)
-      # @option arguments [String] :routing Specific routing value
-      # @option arguments [String] :q Query in the Lucene query string syntax
-      # @option arguments [String] :analyzer The analyzer to use for the query string
-      # @option arguments [Boolean] :analyze_wildcard Specify whether wildcard and prefix queries should be
-      #                                               analyzed (default: false)
-      # @option arguments [String] :default_operator The default operator for query string query (AND or OR)
-      #                                              (options: AND, OR)
-      # @option arguments [String] :df The field to use as default where no field prefix is given
-      #                                in the query string
-      # @option arguments [Boolean] :lenient Specify whether format-based query failures
-      #                                      (such as providing text to a numeric field) should be ignored
-      # @option arguments [Boolean] :lowercase_expanded_terms Specify whether query terms should be lowercased
-      #
-      # @see http://www.elastic.co/guide/en/elasticsearch/reference/master/search-exists.html
-      #
-      def search_exists(arguments={})
-        valid_params = [
-          :ignore_unavailable,
-          :allow_no_indices,
-          :expand_wildcards,
-          :min_score,
-          :preference,
-          :routing,
-          :q,
-          :analyzer,
-          :analyze_wildcard,
-          :default_operator,
-          :df,
-          :lenient,
-          :lowercase_expanded_terms ]
-        method = 'POST'
-        path   = "_search/exists"
-        params = Utils.__validate_and_extract_params arguments, valid_params
-        body   = arguments[:body]
-
-        perform_request(method, path, params, body).body
-      end
-    end
-  end
-end

data/lib/elasticsearch/api/actions/suggest.rb

@@ -1,46 +0,0 @@
-module Elasticsearch
-  module API
-    module Actions
-
-      # Return query terms suggestions based on provided text and configuration.
-      #
-      # Pass the request definition in the `:body` argument.
-      #
-      # @example Return query terms suggestions ("auto-correction")
-      #
-      #     client.suggest index: 'myindex',
-      #                    body: { my_suggest: { text: 'tset', term: { field: 'title' } } }
-      #     # => { ... "my_suggest"=>[ {"text"=>"tset", ... "options"=>[{"text"=>"test", "score"=>0.75, "freq"=>5}] }]}
-      #
-      # @option arguments [List] :index A comma-separated list of index names to restrict the operation;
-      #                                 use `_all` or empty string to perform the operation on all indices
-      # @option arguments [Hash] :body The request definition
-      # @option arguments [String] :ignore_indices When performed on multiple indices, allows to ignore `missing` ones
-      #                                            (options: none, missing)
-      # @option arguments [String] :preference Specify the node or shard the operation should be performed on
-      #                                        (default: random)
-      # @option arguments [String] :routing Specific routing value
-      # @option arguments [String] :source The URL-encoded request definition (instead of using request body)
-      #
-      # @since 0.90
-      #
-      # @see http://elasticsearch.org/guide/reference/api/search/suggest/
-      #
-      def suggest(arguments={})
-        valid_params = [
-          :ignore_indices,
-          :preference,
-          :routing,
-          :source ]
-
-        method = HTTP_POST
-        path   = Utils.__pathify( Utils.__listify(arguments[:index]), '_suggest' )
-
-        params = Utils.__validate_and_extract_params arguments, valid_params
-        body   = arguments[:body]
-
-        perform_request(method, path, params, body).body
-      end
-    end
-  end
-end

data/test/unit/abort_benchmark_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class AbortBenchmarkTest < ::Test::Unit::TestCase
-
-      context "Abort benchmark" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'POST', method
-            assert_equal '_bench/abort/foo', url
-            assert_equal nil, params[:name]
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.abort_benchmark :name => 'foo'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/api_test.rb

@@ -1,28 +0,0 @@
-# encoding: UTF-8
-
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class APITest < ::Test::Unit::TestCase
-
-      context "The API module" do
-
-        should "access the settings" do
-          assert_not_nil Elasticsearch::API.settings
-        end
-
-        should "allow to set settings" do
-          assert_nothing_raised { Elasticsearch::API.settings[:foo] = 'bar' }
-          assert_equal 'bar', Elasticsearch::API.settings[:foo]
-        end
-
-        should "have default serializer" do
-          assert_equal MultiJson, Elasticsearch::API.serializer
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/benchmark_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class BenchmarkTest < ::Test::Unit::TestCase
-
-      context "Benchmark" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'PUT', method
-            assert_equal '_bench', url
-            assert_equal Hash.new, params
-            assert_equal 'foo', body[:name]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.benchmark :body => { :name => 'foo' }
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/bulk_test.rb

@@ -1,133 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class BulkTest < ::Test::Unit::TestCase
-
-      context "Bulk" do
-        subject { FakeClient.new }
-
-        should "post correct payload to the endpoint" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'POST', method
-            assert_equal '_bulk', url
-            assert_equal Hash.new, params
-
-            if RUBY_1_8
-              lines = body.split("\n")
-
-              assert_equal 7, lines.size
-              assert_match /\{"index"\:\{/, lines[0]
-              assert_match /\{"title"\:"Test"/, lines[1]
-              assert_match /\{"update"\:\{/, lines[2]
-              assert_match /\{"doc"\:\{"title"/, lines[3]
-            else
-              assert_equal <<-PAYLOAD.gsub(/^\s+/, ''), body
-                {"index":{"_index":"myindexA","_type":"mytype","_id":"1"}}
-                {"title":"Test"}
-                {"update":{"_index":"myindexB","_type":"mytype","_id":"2"}}
-                {"doc":{"title":"Update"}}
-                {"delete":{"_index":"myindexC","_type":"mytypeC","_id":"3"}}
-                {"index":{"_index":"myindexD","_type":"mytype","_id":"1"}}
-                {"data":"MYDATA"}
-              PAYLOAD
-            end
-            true
-          end.returns(FakeResponse.new)
-
-          subject.bulk :body => [
-            { :index =>  { :_index => 'myindexA', :_type => 'mytype', :_id => '1', :data => { :title => 'Test' } } },
-            { :update => { :_index => 'myindexB', :_type => 'mytype', :_id => '2', :data => { :doc => { :title => 'Update' } } } },
-            { :delete => { :_index => 'myindexC', :_type => 'mytypeC', :_id => '3' } },
-            { :index =>  { :_index => 'myindexD', :_type => 'mytype', :_id => '1', :data => { :data => 'MYDATA' } } },
-          ]
-        end
-
-        should "post payload to the correct endpoint" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'POST', method
-            assert_equal 'myindex/_bulk', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.bulk :index => 'myindex', :body => []
-        end
-
-        should "handle `:data` keys correctly in header/data payloads" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            lines = body.split("\n")
-            assert_equal 2, lines.size
-
-            header = MultiJson.load(lines.first)
-            data   = MultiJson.load(lines.last)
-
-            assert_equal 'myindex', header['update']['_index']
-            assert_equal 'mytype',  header['update']['_type']
-            assert_equal '1',       header['update']['_id']
-
-            assert_equal({'data' => { 'title' => 'Update' }}, data['doc'])
-            # assert_equal <<-PAYLOAD.gsub(/^\s+/, ''), body
-            #   {"update":{"_index":"myindex","_type":"mytype","_id":"1"}}
-            #   {"doc":{"data":{"title":"Update"}}}
-            # PAYLOAD
-            true
-          end.returns(FakeResponse.new)
-
-          subject.bulk :body => [
-            { :update => { :_index => 'myindex', :_type => 'mytype', :_id => '1' } },
-            { :doc => { :data => { :title => 'Update' } } }
-          ]
-        end
-
-        should "post a string payload" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal "foo\nbar", body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.bulk :body => "foo\nbar"
-        end
-
-        should "post an array of strings payload" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal "foo\nbar\n", body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.bulk :body => ["foo", "bar"]
-        end
-
-        should "encode URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_bulk', url
-            assert_equal({:refresh => true}, params)
-            true
-          end.returns(FakeResponse.new)
-
-          subject.bulk :refresh => true, :body => []
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/_bulk', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.bulk :index => 'foo^bar', :body => []
-        end
-
-        should "not duplicate the type" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'myindex/mytype/_bulk', url
-            assert_empty params
-            true
-          end.returns(FakeResponse.new)
-
-          subject.bulk :index => 'myindex', :type => 'mytype', :body => []
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/cat/aliases_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class CatAliasesTest < ::Test::Unit::TestCase
-
-      context "Cat: Aliases" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal '_cat/aliases', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.cat.aliases
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/cat/allocation_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class CatAllocationTest < ::Test::Unit::TestCase
-
-      context "Cat: Allocation" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal '_cat/allocation', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.cat.allocation
-        end
-
-      end
-
-    end
-  end
-end