elasticsearch-api 0.0.2

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

@@ -0,0 +1,34 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Create a document.
+      #
+      # Enforce the _create_ operation when indexing a document --
+      # the operation will return an error when the document already exists.
+      #
+      # @example Create a document
+      #
+      #     client.create index: 'myindex',
+      #                   type: 'mytype',
+      #                   id: '1',
+      #                   body: {
+      #                    title: 'Test 1',
+      #                    tags: ['y', 'z'],
+      #                    published: true,
+      #                    published_at: Time.now.utc.iso8601,
+      #                    counter: 1
+      #                   }
+      #
+      # @option (see Actions#index)
+      #
+      # (The `:op_type` argument is ignored.)
+      #
+      # @see http://elasticsearch.org/guide/reference/api/index_/
+      #
+      def create(arguments={})
+        index arguments.update :op_type => 'create'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Delete a single document.
+      #
+      # @example Delete a document
+      #
+      #     client.delete index: 'myindex', type: 'mytype', id: '1'
+      #
+      # @example Delete a document with specific routing
+      #
+      #     client.delete index: 'myindex', type: 'mytype', id: '1', routing: 'abc123'
+      #
+      # @option arguments [String] :id The document ID (*Required*)
+      # @option arguments [Number,List] :ignore The list of HTTP errors to ignore; only `404` supported at the moment
+      # @option arguments [String] :index The name of the index (*Required*)
+      # @option arguments [String] :type The type of the document (*Required*)
+      # @option arguments [String] :consistency Specific write consistency setting for the operation
+      #                                         (options: one, quorum, all)
+      # @option arguments [String] :parent ID of parent document
+      # @option arguments [Boolean] :refresh Refresh the index after performing the operation
+      # @option arguments [String] :replication Specific replication type (options: sync, async)
+      # @option arguments [String] :routing Specific routing value
+      # @option arguments [Time] :timeout Explicit operation timeout
+      # @option arguments [Number] :version Explicit version number for concurrency control
+      # @option arguments [String] :version_type Specific version type (options: internal, external)
+      #
+      # @see http://elasticsearch.org/guide/reference/api/delete/
+      #
+      def delete(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]
+        method = 'DELETE'
+        path   = Utils.__pathify( arguments[:index], arguments[:type], arguments[:id] )
+        params = arguments.select do |k,v|
+          [ :consistency,
+            :parent,
+            :refresh,
+            :replication,
+            :routing,
+            :timeout,
+            :version,
+            :version_type ].include?(k)
+        end
+        # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+        params = Hash[params] unless params.is_a?(Hash)
+        body   = nil
+
+        perform_request(method, path, params, body).body
+
+      rescue Exception => e
+        # NOTE: Use exception name, not full class in Elasticsearch::Client to allow client plugability
+        if arguments[:ignore] == 404 && e.class.to_s =~ /NotFound/; false
+        else raise(e)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Delete documents which match specified query.
+      #
+      # Provide the query either as a "query string" query in the `:q` argument, or using the Elasticsearch's
+      # [Query DSL](http://www.elasticsearch.org/guide/reference/query-dsl/) in the `:body` argument.
+      #
+      # @example Deleting documents with a simple query
+      #
+      #     client.delete_by_query index: 'myindex', q: 'title:test'
+      #
+      # @example Deleting documents using the Query DSL
+      #
+      #     client.delete_by_query index: 'myindex', body: { term: { published: false } }
+      #
+      # @option arguments [List] :index A comma-separated list of indices to restrict the operation;
+      #                                 use `_all`to perform the operation on all indices (*Required*)
+      # @option arguments [List] :type A comma-separated list of types to restrict the operation
+      # @option arguments [Hash] :body A query to restrict the operation
+      # @option arguments [String] :analyzer The analyzer to use for the query string
+      # @option arguments [String] :consistency Specific write consistency setting for the operation
+      #                                         (options: one, quorum, all)
+      # @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 [String] :ignore_indices When performed on multiple indices, allows to ignore `missing` ones
+      #                                            (options: none, missing)
+      # @option arguments [String] :replication Specific replication type (options: sync, async)
+      # @option arguments [String] :q Query in the Lucene query string syntax
+      # @option arguments [String] :routing Specific routing value
+      # @option arguments [String] :source The URL-encoded query definition (instead of using the request body)
+      # @option arguments [Time] :timeout Explicit operation timeout
+      #
+      # @see http://www.elasticsearch.org/guide/reference/api/delete-by-query/
+      #
+      def delete_by_query(arguments={})
+        raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
+        method = 'DELETE'
+        path   = Utils.__pathify( Utils.__listify(arguments[:index]), '/_query' )
+        params = arguments.select do |k,v|
+          [ :analyzer,
+            :consistency,
+            :default_operator,
+            :df,
+            :ignore_indices,
+            :replication,
+            :q,
+            :routing,
+            :source,
+            :timeout ].include?(k)
+        end
+        # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+        params = Hash[params] unless params.is_a?(Hash)
+        body   = arguments[:body]
+
+        perform_request(method, path, params, body).body
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Return true if the specified document exists, false otherwise.
+      #
+      # @example
+      #
+      #     client.exists index: 'myindex', type: 'mytype', id: '1'
+      #
+      # @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 (default: `_all`)
+      # @option arguments [String] :parent The ID of the parent document
+      # @option arguments [String] :preference Specify the node or shard the operation should be performed on
+      #                                        (default: random)
+      # @option arguments [Boolean] :realtime Specify whether to perform the operation in realtime or search mode
+      # @option arguments [Boolean] :refresh Refresh the shard containing the document before performing the operation
+      # @option arguments [String] :routing Specific routing value
+      #
+      # @see http://elasticsearch.org/guide/reference/api/get/
+      #
+      def exists(arguments={})
+        raise ArgumentError, "Required argument 'id' missing" unless arguments[:id]
+        raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
+        arguments[:type] ||= '_all'
+
+        method = 'HEAD'
+        path   = Utils.__pathify( arguments[:index], arguments[:type], arguments[:id] )
+        params = arguments.select do |k,v|
+          [ :parent,
+            :preference,
+            :realtime,
+            :refresh,
+            :routing ].include?(k)
+        end
+        # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+        params = Hash[params] unless params.is_a?(Hash)
+        body   = nil
+
+        perform_request(method, path, params, body).status == 200 ? true : false
+        rescue Exception => e
+          if e.class.to_s =~ /NotFound/ || e.message =~ /Not\s*Found|404/i
+            false
+          else
+            raise e
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Return information if and how well a document matches a query.
+      #
+      # The returned information contains a `_score` and its explanation, if the document matches the query.
+      #
+      # @example Passing the query in the Lucene query syntax as the `:q` URL parameter
+      #
+      #     client.explain index: 'myindex', type: 'mytype', id: '1', q: 'test'
+      #
+      # @example Passing the query in the Query DSL as the request `:body`
+      #
+      #     client.explain index: 'myindex', type: 'mytype', id: '1',
+      #                    body: { query: { match: { title: 'test' } } }
+      #
+      # @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 (*Required*)
+      # @option arguments [Hash] :body The query definition using the Query DSL (*Required*)
+      # @option arguments [Boolean] :analyze_wildcard Specify whether wildcards and prefix queries in the query string
+      #                                               query should be analyzed (default: false)
+      # @option arguments [String] :analyzer The analyzer for the query string query
+      # @option arguments [String] :default_operator The default operator for query string query (AND or OR)
+      #                                              (options: AND, OR)
+      # @option arguments [String] :df The default field for query string query (default: _all)
+      # @option arguments [List] :fields A comma-separated list of fields to return in the response
+      # @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
+      # @option arguments [String] :parent The ID of the parent document
+      # @option arguments [String] :preference Specify the node or shard the operation should be performed on
+      #                                        (default: random)
+      # @option arguments [String] :q Query in the Lucene query string syntax
+      # @option arguments [String] :routing Specific routing value
+      # @option arguments [String] :source The URL-encoded query definition (instead of using the request body)
+      #
+      # @see http://elasticsearch.org/guide/reference/api/explain/
+      #
+      def explain(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]
+        method = 'GET'
+        path   = Utils.__pathify( arguments[:index], arguments[:type], arguments[:id], '_explain' )
+        params = arguments.select do |k,v|
+          [ :analyze_wildcard,
+            :analyzer,
+            :default_operator,
+            :df,
+            :fields,
+            :lenient,
+            :lowercase_expanded_terms,
+            :parent,
+            :preference,
+            :q,
+            :routing,
+            :source ].include?(k)
+        end
+        # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+        params = Hash[params] unless params.is_a?(Hash)
+        body   = arguments[:body]
+
+        params[:fields] = Utils.__listify(params[:fields]) if params[:fields]
+
+        perform_request(method, path, params, body).body
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Return a specified document.
+      #
+      # The response contains full document, as stored in Elasticsearch, incl. `_source`, `_version`, etc.
+      #
+      # @example Get a document
+      #
+      #     client.get index: 'myindex', type: 'mytype', id: '1'
+      #
+      # @option arguments [String] :id The document ID (*Required*)
+      # @option arguments [Number,List] :ignore The list of HTTP errors to ignore; only `404` supported at the moment
+      # @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 [List] :fields A comma-separated list of fields to return in the response
+      # @option arguments [String] :parent The ID of the parent document
+      # @option arguments [String] :preference Specify the node or shard the operation should be performed on
+      #                                        (default: random)
+      # @option arguments [Boolean] :realtime Specify whether to perform the operation in realtime or search mode
+      # @option arguments [Boolean] :refresh Refresh the shard containing the document before performing the operation
+      # @option arguments [String] :routing Specific routing value
+      #
+      # @see http://elasticsearch.org/guide/reference/api/get/
+      #
+      def get(arguments={})
+        raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
+        raise ArgumentError, "Required argument 'id' missing"    unless arguments[:id]
+        arguments[:type] ||= '_all'
+
+        method = 'GET'
+        path   = Utils.__pathify( arguments[:index], arguments[:type], arguments[:id] )
+        params = arguments.select do |k,v|
+          [ :fields,
+            :parent,
+            :preference,
+            :realtime,
+            :refresh,
+            :routing ].include?(k)
+        end
+        # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+        params = Hash[params] unless params.is_a?(Hash)
+        body   = nil
+
+        params[:fields] = Utils.__listify(params[:fields]) if params[:fields]
+
+        perform_request(method, path, params, body).body
+
+      rescue Exception => e
+        # NOTE: Use exception name, not full class in Elasticsearch::Client to allow client plugability
+        if arguments[:ignore] == 404 && e.class.to_s =~ /NotFound/; false
+        else raise(e)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Return a specified document's `_source`.
+      #
+      # The response contains just the original document, as passed to Elasticsearch during indexing.
+      #
+      # @example Get a document `_source`
+      #
+      #     client.get_source index: 'myindex', type: 'mytype', id: '1'
+      #
+      # @option arguments [String] :id The document ID (*Required*)
+      # @option arguments [Number,List] :ignore The list of HTTP errors to ignore; only `404` supported at the moment
+      # @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 [List] :fields A comma-separated list of fields to return in the response
+      # @option arguments [String] :parent The ID of the parent document
+      # @option arguments [String] :preference Specify the node or shard the operation should be performed on
+      #                                        (default: random)
+      # @option arguments [Boolean] :realtime Specify whether to perform the operation in realtime or search mode
+      # @option arguments [Boolean] :refresh Refresh the shard containing the document before performing the operation
+      # @option arguments [String] :routing Specific routing value
+      #
+      # @since 0.90.1
+      #
+      def get_source(arguments={})
+        raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
+        raise ArgumentError, "Required argument 'id' missing"    unless arguments[:id]
+        arguments[:type] ||= '_all'
+
+        method = 'GET'
+        path   = Utils.__pathify( arguments[:index], arguments[:type], arguments[:id], '_source' )
+        params = arguments.select do |k,v|
+          [ :fields,
+            :parent,
+            :preference,
+            :realtime,
+            :refresh,
+            :routing ].include?(k)
+        end
+        # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+        params = Hash[params] unless params.is_a?(Hash)
+        body   = nil
+
+        params[:fields] = Utils.__listify(params[:fields]) if params[:fields]
+
+        perform_request(method, path, params, body).body
+
+      rescue Exception => e
+        # NOTE: Use exception name, not full class in Elasticsearch::Client to allow client plugability
+        if arguments[:ignore] == 404 && e.class.to_s =~ /NotFound/; false
+        else raise(e)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Create or update a document.
+      #
+      # The `index` API will either _create_ a new document, or _update_ an existing one, when a document `:id`
+      # is passed. When creating a document, an ID will be auto-generated, when it's not passed as an argument.
+      #
+      # You can specifically enforce the _create_ operation by settint the `op_type` argument to `create`, or
+      # by using the {Actions#create} method.
+      #
+      # Optimistic concurrency control is performed, when the `version` argument is specified. By default,
+      # no version checks are performed.
+      #
+      # By default, the document will be available for {Actions#get} immediately, for {Actions#search} only
+      # after an index refresh operation has been performed (either automatically or manually).
+      #
+      #
+      # @example Create or update a document `myindex/mytype/1`
+      #
+      #     client.index index: 'myindex',
+      #                  type: 'mytype',
+      #                  id: '1',
+      #                  body: {
+      #                   title: 'Test 1',
+      #                   tags: ['y', 'z'],
+      #                   published: true,
+      #                   published_at: Time.now.utc.iso8601,
+      #                   counter: 1
+      #                 }
+      #
+      # @option arguments [String] :id Document ID (optional, will be auto-generated if missing)
+      # @option arguments [String] :index The name of the index (*Required*)
+      # @option arguments [String] :type The type of the document (*Required*)
+      # @option arguments [Hash] :body The document
+      # @option arguments [String] :consistency Explicit write consistency setting for the operation
+      #                                         (options: one, quorum, all)
+      # @option arguments [String] :op_type Explicit operation type (options: index, create)
+      # @option arguments [String] :parent ID of the parent document
+      # @option arguments [String] :percolate Percolator queries to execute while indexing the document
+      # @option arguments [Boolean] :refresh Refresh the index after performing the operation
+      # @option arguments [String] :replication Specific replication type (options: sync, async)
+      # @option arguments [String] :routing Specific routing value
+      # @option arguments [Time] :timeout Explicit operation timeout
+      # @option arguments [Time] :timestamp Explicit timestamp for the document
+      # @option arguments [Duration] :ttl Expiration time for the document
+      # @option arguments [Number] :version Explicit version number for concurrency control
+      # @option arguments [String] :version_type Specific version type (options: internal, external)
+      #
+      # @see http://elasticsearch.org/guide/reference/api/index_/
+      #
+      def index(arguments={})
+        raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
+        raise ArgumentError, "Required argument 'type' missing" unless arguments[:type]
+        method = arguments[:id] ? 'PUT' : 'POST'
+        path   = Utils.__pathify( arguments[:index], arguments[:type], arguments[:id] )
+        params = arguments.select do |k,v|
+          [ :consistency,
+            :op_type,
+            :parent,
+            :percolate,
+            :refresh,
+            :replication,
+            :routing,
+            :timeout,
+            :timestamp,
+            :ttl,
+            :version,
+            :version_type ].include?(k)
+        end
+        # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+        params = Hash[params] unless params.is_a?(Hash)
+
+        body   = arguments[:body]
+
+        perform_request(method, path, params, body).body
+      end
+    end
+  end
+end