elastomer-client 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9539ab968e233a1329b616dfd377bf7fe9c73905
-  data.tar.gz: e7cdb14136521443f70f6eb7f7d7f5d747dcd521
+  metadata.gz: 4f92a7cb69e266a5d7d085d3ac4c2cb71689c30d
+  data.tar.gz: a87d3c6dd12b5b243061c9641c1baedb5ff3ae95
 SHA512:
-  metadata.gz: 1346de81716c760aa851e323617cd7318941a41636a32351ac498975c7a7714e283c2d0fcaaaf14d5f0ba4bd6dadbcd2913c4a590d30f558cd3d657f37c274d3
-  data.tar.gz: 0610f7decbac4ba346017093fccd95b75bfb429ec885a6412995fb3367fee06fc075acdd738d50bff54f417dce133681f62390dcc798526d7d10757a66907f19
+  metadata.gz: 483643b29967808319ce67e5b6b58458dc6034f9e6df78601a6f9264ad666205648c3117bb940b6f8b58a73086e1589302bf98c12575922c5ef434856b003fa6
+  data.tar.gz: 8e3b0f7bbf2c399d10efd7892d1d216ef6d64c41247c040eb246957162428c2324cbb5e68dcb167ede04a2618a5ab0ddb0584a53be63aad0bc14e968e6ec7886

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.9.0 (2016-02-26)
+- Adding support for the `/_suggest` API endpoint
+- Documentation cleanup - thank you Matt Wagner @wags
+
 ## 0.8.1 (2015-11-04)
 - Replace yanked 0.8.0
 - Fix code style based on Rubocop recommendations

data/README.md

@@ -1,6 +1,6 @@
 # Elastomer Client [![Build Status](https://travis-ci.org/github/elastomer-client.svg)](https://travis-ci.org/github/elastomer-client)
 
-Making a stupid simple ElasticSearch client so your project can be smarter!
+Making a stupid simple Elasticsearch client so your project can be smarter!
 
 ## Getting Started
 
@@ -15,10 +15,10 @@ $ script/test
 
 ## Client
 
-The client provides a one-to-one mapping to the ElasticSearch [API
-endpoints](http://www.elasticsearch.org/guide/reference/api/). The API is
-decomposed into logical sections and accessed according to what you are trying
-to accomplish. Each logical section is represented as a [client
+The client provides a one-to-one mapping to the Elasticsearch [API
+endpoints](https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html).
+The API is decomposed into logical sections and accessed according to what you
+are trying to accomplish. Each logical section is represented as a [client
 class](lib/elastomer/client) and a top-level accessor is provided for each.
 
 #### Cluster
@@ -89,7 +89,7 @@ docs.index({
   :_id    => 1,
   :_type  => 'tweet',
   :author => '@pea53',
-  :tweet  => 'announcing Elastomer, the stupid simple ElasticSearch client'
+  :tweet  => 'announcing Elastomer, the stupid simple Elasticsearch client'
 })
 
 docs.search({:query => {:match_all => {}}}, :search_type => 'count')
@@ -98,7 +98,7 @@ docs.search({:query => {:match_all => {}}}, :search_type => 'count')
 #### Performance
 
 By default Elastomer uses Net::HTTP (via Faraday) to communicate with
-ElasticSearch. You may find that Excon performs better for your use. To enable
+Elasticsearch. You may find that Excon performs better for your use. To enable
 Excon, add it to your bundle and then change your Elastomer initialization
 thusly:
 

data/docs/README.md

@@ -2,20 +2,20 @@
 
 We first started building the Elastomer Client gem when an
 [official client](https://github.com/elasticsearch/elasticsearch-ruby)
-was not yet available from ElasticSearch. We were looking for a client that
-provided a one-to-one mapping of the ElasticSearch APIs and avoided higher level
+was not yet available from Elasticsearch. We were looking for a client that
+provided a one-to-one mapping of the Elasticsearch APIs and avoided higher level
 complexity such as connection pooling, round-robin connections, thrift support,
-and the like. We think these things these things are bettered handled at
-different layers and by other software libraries.
+and the like. We think these things are better handled at different layers and
+by other software libraries.
 
-Our goal is to keep our ElasticSearch client simple and then compose
+Our goal is to keep our Elasticsearch client simple and then compose
 higher level functionality from smaller components. This is the UNIX philosophy
 in action.
 
-To that end we have tried to be as faithful as possible to the ElasticSearch API
+To that end we have tried to be as faithful as possible to the Elasticsearch API
 with our implementation. There are a few places where it made sense to wrap the
-ElasticSearch API inside Ruby idioms. One notable location is the
-[scan-scroll](http://www.elasticsearch.org/guide/en/elasticsearch/guide/current/scan-scroll.html)
+Elasticsearch API inside Ruby idioms. One notable location is the
+[scan-scroll](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-scroll.html)
 search type; the Elastomer Client provides a Ruby iterator to work with these
 types of queries.
 

data/docs/client.md

@@ -1,8 +1,8 @@
 # Elastomer Client Component
 
 All methods in the Elastomer Client gem eventually make an HTTP request to
-ElasticSearch. The [`Elastomer::Client`](https://github.com/github/elastomer-client/blob/master/lib/elastomer/client.rb)
-class is responsible for connecting to an ElasticSearch instance, making HTTP
+Elasticsearch. The [`Elastomer::Client`](https://github.com/github/elastomer-client/blob/master/lib/elastomer/client.rb)
+class is responsible for connecting to an Elasticsearch instance, making HTTP
 requests, processing the response, and handling errors. Let's look at the
 details of how `Elastomer::Client` handles HTTP communication.
 
@@ -13,10 +13,10 @@ communication. Faraday provides a uniform wrapper around several different HTTP
 clients allowing any of these clients to be used at runtime. Faraday also has
 the concept of *middlewares* that operate on the HTTP request and response. We
 use Faraday middleware to encode and decode JSON messages exchanged with
-ElasticSearch.
+Elasticsearch.
 
 Without any options the `Elastomer::Client` will connect to the default
-ElasticSearch URL `http://localhost:9200`. The `Net:HTTP` client from the Ruby
+Elasticsearch URL `http://localhost:9200`. The `Net:HTTP` client from the Ruby
 standard library will be used.
 
 ```ruby
@@ -26,9 +26,9 @@ client.port  #=> 9200
 client.url   #=> 'http://localhost:9200'
 ```
 
-[Boxen](https://boxen.github.com) configures ElasticSearch to listen on port
+[Boxen](https://boxen.github.com) configures Elasticsearch to listen on port
 `19200` instead of the standard port. We can provide either the full URL or just
-a different port number if ElasticSearch is running on `localhost`.
+a different port number if Elasticsearch is running on `localhost`.
 
 ```ruby
 client = Elastomer::Client.new :port => 19200
@@ -39,7 +39,7 @@ client.url   #=> 'http://localhost:19200'
 client = Elastomer::Client.new :url => "http://localhost:19200"
 ```
 
-ElasticSearch works best with persistent connections. We can use the
+Elasticsearch works best with persistent connections. We can use the
 `Net::HTTP::Persistent` adapter with Faraday.
 
 ```ruby
@@ -49,7 +49,7 @@ client = Elastomer::Client.new \
 ```
 
 We also want to configure the `:open_timeout` (for making the initial connection
-to ElasticSearch) and the `:read_timeout` (used to limit each request). The open
+to Elasticsearch) and the `:read_timeout` (used to limit each request). The open
 timeout should be short - it defaults to 2 seconds. The read timeout should be
 longer, but it can vary depending upon the type of request you are making. Large
 bulk requests will take longer than a quick count query.
@@ -59,7 +59,7 @@ timeout can be set for each request.
 
 ```ruby
 client = Elastomer::Client.new \
-  :url          => "http:/localhost:19200",
+  :url          => "http://localhost:19200",
   :adapter      => :net_http_persistent,
   :open_timeout => 1,
   :read_timeout => 5
@@ -73,9 +73,9 @@ read timeout is reached. If the connection is left open and reused, then the
 returned data might actually be from a previous request. This can lead to all
 kinds of horrible data leaks.
 
-ElasticSearch provides an `X-Opaque-Id` request header. Any value set in this
+Elasticsearch provides an `X-Opaque-Id` request header. Any value set in this
 request header will be returned in the corresponding response header. This
-allows the client to correlate the response from ElasticSearch with the request
+allows the client to correlate the response from Elasticsearch with the request
 that was submitted. We have written an
 [OpaqueId](https://github.com/github/elastomer-client/blob/master/lib/elastomer/middleware/opaque_id.rb)
 middleware that will abort any request if the `X-Opaque-Id` headers disagree
@@ -109,12 +109,12 @@ HTTP request. The HTTP `head` method does not support a request body and ignores
 this parameter. The other HTTP methods all support request bodies.
 
 The `:body` value will be converted into JSON format before being sent to
-ElasticSearch unless the body is a String or an Array. If the body is a String
-it is assumed to already be JSON formatted, and it is sent to ElasticSearch as
+Elasticsearch unless the body is a String or an Array. If the body is a String
+it is assumed to already be JSON formatted, and it is sent to Elasticsearch as
 is without any modifications. When the body is an Array then all the items are
 joined with a newline character `\n` and a trailing newline is appended; this
-supports [bulk](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-bulk.html)
-indexing and [multi-search](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-multi-search.html)
+supports [bulk](https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-bulk.html)
+indexing and [multi-search](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-multi-search.html)
 requests.
 
 **:read_timeout**
@@ -133,10 +133,10 @@ client.cluster.health \
 ```
 
 In the example above we are waiting for the named index to reach a green state.
-The `:timeout` of 5 seconds is passed to ElasticSearch. This call will return
+The `:timeout` of 5 seconds is passed to Elasticsearch. This call will return
 after 5 seconds even if the index has not yet reached green status. So we set
 our network call timeout to 7 seconds to ensure we don't kill the request before
-ElasticSearch has responded.
+Elasticsearch has responded.
 
 **:action** and **:context**
 
@@ -228,9 +228,9 @@ fatal, then the request is fundamentally flawed and should not be retried.
 Passing a malformed search query or trying to search an index that does not
 exist are both examples of fatal errors - the request will never succeed.
 
-If an error is not fatal then it can be retried. If the ElasticSearch cluster
+If an error is not fatal then it can be retried. If the Elasticsearch cluster
 has a full search queue then any query will fail. It not the fault of the user
-or the query itself - ElasticSearch just needs more capacity. The query can be
+or the query itself - Elasticsearch just needs more capacity. The query can be
 safely retried.
 
 Therein lies the rub, though. Retrying a search or any operation will continue

data/docs/cluster.md

@@ -2,8 +2,8 @@
 
 The cluster component deals with commands for managing cluster state and
 monitoring cluster health. All the commands found under the
-[cluster API](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/cluster.html)
-section of the ElasticSearch documentation are implemented by the
+[cluster API](https://www.elastic.co/guide/en/elasticsearch/reference/current/cluster.html)
+section of the Elasticsearch documentation are implemented by the
 [`cluster.rb`](https://github.com/github/elastomer-client/blob/master/lib/elastomer/client/cluster.rb)
 module and the [`nodes.rb`](https://github.com/github/elastomer-client/blob/master/lib/elastomer/client/nodes.rb)
 module.
@@ -12,13 +12,13 @@ module.
 
 API endpoints dealing with cluster level information and settings are found in
 the [`Cluster`](lib/elastomer/client/cluster.rb) class. Each of these methods
-corresponds to an API endpoint described in the ElasticSearch documentation
+corresponds to an API endpoint described in the Elasticsearch documentation
 (linked to above). The params listed in the documentation can be passed to these
 methods, so we do not take too much trouble to enumerate them all.
 
 #### health
 
-The cluster [health API](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/cluster-health.html)
+The cluster [health API](https://www.elastic.co/guide/en/elasticsearch/reference/current/cluster-health.html)
 returns a very simple cluster health status report.
 
 ```ruby
@@ -50,8 +50,8 @@ client.cluster.health \
 #### state & stats
 
 If you need something more than basic health information, then the
-[`state`](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/cluster-state.html)
-and [`stats`](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/cluster-stats.html)
+[`state`](https://www.elastic.co/guide/en/elasticsearch/reference/current/cluster-state.html)
+and [`stats`](https://www.elastic.co/guide/en/elasticsearch/reference/current/cluster-stats.html)
 endpoints are the next methods to call. Please look through the API
 documentation linked to above for all the details. And you can play with these
 endpoints via an IRB session.
@@ -67,10 +67,10 @@ client.cluster.stats
 #### settings
 
 Cluster behavior is controlled via the
-[settings API](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/cluster-update-settings.html).
+[settings API](https://www.elastic.co/guide/en/elasticsearch/reference/current/cluster-update-settings.html).
 The settings can be retrieved, and some settings can be modified at runtime to
 control shard allocations, routing, index replicas, and so forth. For example,
-when performing a [rolling restart](http://www.elasticsearch.org/guide/en/elasticsearch/guide/current/_rolling_restarts.html)
+when performing a [rolling restart](https://www.elastic.co/guide/en/elasticsearch/guide/current/_rolling_restarts.html)
 of a cluster, disabling shard allocation between restarts can reduce the
 cluster recovery time.
 

data/docs/docs.md

@@ -1,8 +1,8 @@
 # Elastomer Documents Component
 
 The documents components handles all API calls related to
-[indexing documents](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs.html)
-and [searching documents](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search.html).
+[indexing documents](https://www.elastic.co/guide/en/elasticsearch/reference/current/docs.html)
+and [searching documents](https://www.elastic.co/guide/en/elasticsearch/reference/current/search.html).
 
 Access to the documents component is provided via the `docs` method on the index
 component or the `docs` method on the client. The `docs` method on the index
@@ -68,7 +68,7 @@ This will create a new document in the search index. But what do we do if there
 is a misspelling in the body of our blog post? We'll need to re-index the
 document.
 
-ElasticSearch assigned our document a unique identifier when we first added it
+Elasticsearch assigned our document a unique identifier when we first added it
 to the index. In order to change this document, we need to supply the unique
 identifier along with our modified document.
 
@@ -86,13 +86,13 @@ docs.index(
 *The `post_body` above is a variable representing the real body of the blog
 post. I don't want to type it over and over again.*
 
-You do not have to relay on the auto-generated IDs from ElasticSearch. You can
+You do not have to relay on the auto-generated IDs from Elasticsearch. You can
 always provide your own IDs; this is recommended if your documents are also
 stored in a database that provides unique IDs. Using the same IDs in both
 locations enables you to reconcile documents between the two.
 
 The `:_id` field is only one of several special fields that control document
-indexing in ElasticSearch. The full list of supported fields are enumerated in
+indexing in Elasticsearch. The full list of supported fields are enumerated in
 the `index`
 [method documentation](https://github.com/github/elastomer-client/blob/master/lib/elastomer/client/docs.rb#L45-56).
 
@@ -160,7 +160,7 @@ client.docs.search \
   :type  => "post"
 ```
 
-The `search` method returns the query response from ElasticSearch as a ruby
+The `search` method returns the query response from Elasticsearch as a ruby
 Hash. All the keys are represented as Strings. The [hashie](https://github.com/intridea/hashie)
 project has some useful transforms and wrappers for working with these result
 sets, but that is left to the user to implement if they so desire. Elastomer
@@ -198,7 +198,7 @@ results["hits"]["total"]  #=> 1
 The search results always contain the total number of matched documents; even if
 the `:size` is set to zero or some other number. However this is very inefficient.
 
-ElasticSearch provides specific methods for obtaining the number of documents
+Elasticsearch provides specific methods for obtaining the number of documents
 that match a search. Instead we can specify a `:search_type` tailored for
 counting.
 
@@ -212,9 +212,9 @@ results["hits"]["total"]  #=> 1
 
 The `"count"` search type is much more efficient then setting the size to zero.
 These count queries will return more quickly and consume less memory inside
-ElasticSearch.
+Elasticsearch.
 
-There is also a `count` API method, but the `:serach_type` approach is even more
+There is also a `count` API method, but the `:search_type` approach is even more
 efficient than the count API.
 
 #### Deleting

data/docs/index.md

@@ -1,7 +1,7 @@
 # Elastomer Index Component
 
 The index component provides access to the
-[indices API](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices.html)
+[indices API](https://www.elastic.co/guide/en/elasticsearch/reference/current/indices.html)
 used for index management, settings, mappings, and aliases. Index
 [warmers](warmers.md) and [templates](templates.md) are handled via their own
 components. Methods for adding documents to the index and searching those
@@ -25,7 +25,6 @@ index.status
 index = client.index
 index.status :index => "blog"
 index.status :index => "users"
-
 ```
 
 You can operate on more than one index, too, by providing a list of index names.
@@ -96,19 +95,19 @@ index.update_mapping :post,
 ```
 
 The `:post` type is given twice - once as a method argument, and once in the
-request body. This is an artifact of the ElasticSearch API. We could hide this
+request body. This is an artifact of the Elasticsearch API. We could hide this
 wart, but the philosophy of the elastomer-client is to be as faithful to the API
 as possible.
 
 #### Analysis
 
-The [analysis](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/analysis.html)
+The [analysis](https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis.html)
 process has the greatest impact on the relevancy of your search results. It is
 the process of decomposing text into searchable tokens. Understanding this
 process is important, and creating your own analyzers is as much an art form as
 it is science.
 
-ElasticSearch provides an [analyze](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-analyze.html)
+Elasticsearch provides an [analyze](https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-analyze.html)
 API for exploring the analysis process and return tokens. We can see how
 individual fields will analyze text.
 
@@ -118,7 +117,7 @@ index.analyze "The Role of Morphology in Phoneme Prediction",
   :field => "post.title"
 ```
 
-And we can explore the default analyzers provided by ElasticSearch.
+And we can explore the default analyzers provided by Elasticsearch.
 
 ```ruby
 client.index.analyze "The Role of Morphology in Phoneme Prediction",
@@ -129,13 +128,13 @@ client.index.analyze "The Role of Morphology in Phoneme Prediction",
 
 A common practice when dealing with non-changing data sets (event logs) is to
 create a new index for each week or month. Only the current index is written to,
-and the older indices can be made read only. Eventually, when it is time to
+and the older indices can be made read-only. Eventually, when it is time to
 expire the data, the older indices can be deleted from the cluster.
 
 Let's take a look at some simple event log maintenance using elastomer-client.
 
 ```ruby
-# the previous months event log
+# the previous month's event log
 index = client.index "event-log-2014-09"
 
 # optimize the index to have only 1 segment file (expunges deleted documents)
@@ -153,7 +152,7 @@ index.update_settings \
 ```
 
 Now we have a nicely optimized event log index that can be searched but cannot
-be written to. Some time in the future we can delete this index (but we should
+be written to. Sometime in the future we can delete this index (but we should
 take a [snapshot](snapshots.md) first).
 
 ```ruby

data/lib/elastomer/client.rb

@@ -10,7 +10,7 @@ module Elastomer
   class Client
 
     # Create a new client that can be used to make HTTP requests to the
-    # ElasticSearch server.
+    # Elasticsearch server.
     #
     # opts - The options Hash
     #   :host - the host as a String
@@ -48,18 +48,18 @@ module Elastomer
     end
     alias_method :available?, :ping
 
-    # Returns the version String of the attached ElasticSearch instance.
+    # Returns the version String of the attached Elasticsearch instance.
     def version
       @version ||= info["version"]["number"]
     end
 
-    # Returns a Semantic::Version for the attached ElasticSearch instance.
+    # Returns a Semantic::Version for the attached Elasticsearch instance.
     # See https://rubygems.org/gems/semantic
     def semantic_version
       Semantic::Version.new(version)
     end
 
-    # Returns the information Hash from the attached ElasticSearch instance.
+    # Returns the information Hash from the attached Elasticsearch instance.
     def info
       response = get "/", :action => "cluster.info"
       response.body

data/lib/elastomer/client/bulk.rb

@@ -7,7 +7,7 @@ module Elastomer
     # Bulk instance to assemble the operations called in the block into a
     # bulk request and dispatch it at the end of the block.
     #
-    # See http://www.elasticsearch.org/guide/reference/api/bulk/
+    # See https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-bulk.html
     #
     # body   - Request body as a String (required if a block is _not_ given)
     # params - Optional request parameters as a Hash
@@ -142,9 +142,9 @@ module Elastomer
     end
 
     # The Bulk class provides some abstractions and helper methods for working
-    # with the ElasticSearch bulk API command. Instances of the Bulk class
+    # with the Elasticsearch bulk API command. Instances of the Bulk class
     # accumulate indexing and delete operations and then issue a single bulk
-    # API request to ElasticSearch. Those operations are then executed by the
+    # API request to Elasticsearch. Those operations are then executed by the
     # cluster.
     #
     # A maximum request size can be set. As soon as the size of the request
@@ -183,12 +183,12 @@ module Elastomer
       # Set the request size in bytes. If the value is nil, then request size
       # limiting will not be used and a request will only be made when the call
       # method is called. It is up to the user to ensure that the request does
-      # not exceed ElasticSearch request size limits.
+      # not exceed Elasticsearch request size limits.
       #
       # If the value is a number greater than zero, then actions will be
       # buffered until the request size is met or exceeded. When this happens a
       # bulk request is issued, queued actions are cleared, and the response
-      # from ElasticSearch is returned.
+      # from Elasticsearch is returned.
       def request_size=( value )
         if value.nil?
           @request_size = nil
@@ -200,12 +200,12 @@ module Elastomer
       # Set the action count. If the value is nil, then action count limiting
       # will not be used and a request will only be made when the call method
       # is called. It is up to the user to ensure that the request does not
-      # exceed ElasticSearch request size limits.
+      # exceed Elasticsearch request size limits.
       #
       # If the value is a number greater than zero, then actions will be
       # buffered until the action count is met. When this happens a bulk
       # request is issued, queued actions are cleared, and the response from
-      # ElasticSearch is returned.
+      # Elasticsearch is returned.
       def action_count=(value)
         if value.nil?
           @action_count = nil