elastomer-client 0.4.1 → 0.5.0

data/docs/scan_scroll.md

@@ -0,0 +1,3 @@
+# Elastomer Scan/Scroll Component
+
+![constructocat](https://octodex.github.com/images/constructocat2.jpg)

data/docs/snapshots.md

@@ -0,0 +1,3 @@
+# Elastomer Snapshot Component
+
+![constructocat](https://octodex.github.com/images/constructocat2.jpg)

data/docs/templates.md

@@ -0,0 +1,3 @@
+# Elastomer Templates Component
+
+![constructocat](https://octodex.github.com/images/constructocat2.jpg)

data/docs/warmers.md

@@ -0,0 +1,3 @@
+# Elastomer Warmers Component
+
+![constructocat](https://octodex.github.com/images/constructocat2.jpg)

data/elastomer-client.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = Elastomer::VERSION
   spec.authors       = ["Tim Pease", "Grant Rodgers"]
   spec.email         = ["tim.pease@github.com", "grant.rodgers@github.com"]
-  spec.summary       = %q{A library for interacting with the GitHub Search infrastructure}
+  spec.summary       = %q{A library for interacting with Elasticsearch}
   spec.description   = %q{Elastomer is a low level API client for the
                           Elasticsearch HTTP interface.}
   spec.homepage      = "https://github.com/github/elastomer-client"
@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "semantic",    "~> 1.3"
 
   spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "activesupport", ">= 3.0"
   spec.add_development_dependency "minitest","~> 4.7"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "debugger", "~> 1.6.8"
 end

data/lib/elastomer/client.rb

@@ -40,12 +40,13 @@ module Elastomer
     attr_reader :read_timeout, :open_timeout
 
     # Returns true if the server is available; returns false otherwise.
-    def available?
-      response = head '/', :action => 'cluster.available'
+    def ping
+      response = head '/', :action => 'cluster.ping'
       response.success?
     rescue StandardError
       false
     end
+    alias_method :available?, :ping
 
     # Returns the version String of the attached ElasticSearch instance.
     def version
@@ -74,7 +75,7 @@ module Elastomer
         conn.response :parse_json
         conn.request  :opaque_id if @opaque_id
 
-        Array === @adapter ?
+        @adapter.is_a?(Array) ?
           conn.adapter(*@adapter) :
           conn.adapter(@adapter)
 
@@ -150,52 +151,78 @@ module Elastomer
     # Returns a Faraday::Response
     # Raises an Elastomer::Client::Error on 4XX and 5XX responses
     def request( method, path, params )
-      body = params.delete :body
-      body = MultiJson.dump body if Hash === body
-
       read_timeout = params.delete :read_timeout
-
+      body = extract_body params
       path = expand_path path, params
 
-      response = instrument(path, body, params) do
-        case method
-        when :head
-          connection.head(path) { |req| req.options[:timeout] = read_timeout if read_timeout }
-
-        when :get
-          connection.get(path) { |req|
-            req.body = body if body
-            req.options[:timeout] = read_timeout if read_timeout
-          }
-
-        when :put
-          connection.put(path, body) { |req| req.options[:timeout] = read_timeout if read_timeout }
-
-        when :post
-          connection.post(path, body) { |req| req.options[:timeout] = read_timeout if read_timeout }
-
-        when :delete
-          connection.delete(path) { |req|
-            req.body = body if body
-            req.options[:timeout] = read_timeout if read_timeout
-          }
-
-        else
-          raise ArgumentError, "unknown HTTP request method: #{method.inspect}"
+      instrument(path, body, params) do
+        begin
+          response = case method
+          when :head
+            connection.head(path) { |req| req.options[:timeout] = read_timeout if read_timeout }
+
+          when :get
+            connection.get(path) { |req|
+              req.body = body if body
+              req.options[:timeout] = read_timeout if read_timeout
+            }
+
+          when :put
+            connection.put(path, body) { |req| req.options[:timeout] = read_timeout if read_timeout }
+
+          when :post
+            connection.post(path, body) { |req| req.options[:timeout] = read_timeout if read_timeout }
+
+          when :delete
+            connection.delete(path) { |req|
+              req.body = body if body
+              req.options[:timeout] = read_timeout if read_timeout
+            }
+
+          else
+            raise ArgumentError, "unknown HTTP request method: #{method.inspect}"
+          end
+
+          handle_errors response
+
+        # wrap Faraday errors with appropriate Elastomer::Client error classes
+        rescue Faraday::Error::ClientError => boom
+          error_name = boom.class.name.split('::').last
+          error_class = Elastomer::Client.const_get(error_name) rescue Elastomer::Client::Error
+          raise error_class.new(boom, method.upcase, path)
         end
       end
+    end
 
-      handle_errors response
-
-    # wrap Faraday errors with appropriate Elastomer::Client error classes
-    rescue Faraday::Error::ClientError => boom
-      error_name = boom.class.name.split('::').last
-      error_class = Elastomer::Client.const_get(error_name) rescue Elastomer::Client::Error
-      raise error_class.new(boom, method.upcase, path)
+    # Internal: Extract the :body from the params Hash and convert it to a
+    # JSON String format. If the params Hash does not contain a :body then no
+    # action is taken and `nil` is returned.
+    #
+    # If a :body is present and is a String then it is assumed to a JSON String
+    # and returned "as is".
+    #
+    # If a :body is present and is an Array then we join the values together
+    # with newlines and append a trailing newline. This is a special case for
+    # dealing with ES `bulk` imports and `multi_search` methods.
+    #
+    # Otherwise we convert the :body to a JSON string and return.
+    #
+    # params - Parameters Hash
+    #
+    # Returns the request body as a String or `nil` if no :body is present
+    def extract_body( params )
+      body = params.delete :body
+      return if body.nil?
 
-    # ensure
-    #   # FIXME: this is here until we get a real logger in place
-    #   STDERR.puts "[#{response.status.inspect}] curl -X#{method.to_s.upcase} '#{url}#{path}'" unless response.nil?
+      case body
+      when String
+        body
+      when Array
+        body << nil unless body.last.nil?
+        body.join "\n"
+      else
+        MultiJson.dump body
+      end
     end
 
     # Internal: Apply path expansions to the `path` and append query
@@ -263,7 +290,7 @@ module Elastomer
     # containing and 'error' field.
     def handle_errors( response )
       raise ServerError, response if response.status >= 500
-      raise RequestError, response if Hash === response.body && response.body['error']
+      raise RequestError, response if response.body.is_a?(Hash) && response.body['error']
 
       response
     end

data/lib/elastomer/client/bulk.rb

@@ -206,14 +206,14 @@ module Elastomer
         @actions.clear
       end
 
-      SPECIAL_KEYS = %w[id type index version version_type routing parent percolator timestamp ttl retry_on_conflict]
+      SPECIAL_KEYS = %w[id type index version version_type routing parent timestamp ttl consistency refresh retry_on_conflict]
       SPECIAL_KEYS_HASH = SPECIAL_KEYS.inject({}) { |h, k| h[k] = "_#{k}"; h }
 
       # Internal: convert special key parameters to their wire representation
       # and apply any override document parameters.
       def prepare_params(document, params)
         params = convert_special_keys(params)
-        unless document.nil? || String === document
+        if document.is_a? Hash
           params = from_document(document).merge(params)
         end
         params.delete(:_id) if params[:_id].nil? || params[:_id].to_s.empty?

data/lib/elastomer/client/cluster.rb

@@ -95,7 +95,7 @@ module Elastomer
         response = client.get '/_cluster/settings', params.merge(:action => 'cluster.get_settings')
         response.body
       end
-      alias :settings :get_settings
+      alias_method :settings, :get_settings
 
       # Update cluster wide specific settings. Settings updated can either be
       # persistent (applied cross restarts) or transient (will not survive a
@@ -185,7 +185,7 @@ module Elastomer
         response = client.get '{/index}/_aliases', params.merge(:action => 'cluster.get_aliases')
         response.body
       end
-      alias :aliases :get_aliases
+      alias_method :aliases, :get_aliases
 
       # Perform an aliases action on the cluster. We are just a teensy bit
       # clever here in that a single action can be given or an array of

data/lib/elastomer/client/docs.rb

@@ -2,13 +2,16 @@
 module Elastomer
   class Client
 
-    # Provides access to document-level API commands.
+    # Provides access to document-level API commands. Indexing documents and
+    # searching documents are both handled by this module.
     #
-    # name - The name of the index as a String
-    # type - The document type as a String
+    # name - The name of the index as a String (optional)
+    # type - The document type as a String (optional)
+    #
+    # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs.html
     #
     # Returns a Docs instance.
-    def docs( name, type = nil )
+    def docs( name = nil, type = nil )
       Docs.new self, name, type
     end
 
@@ -23,21 +26,47 @@ module Elastomer
       #
       def initialize( client, name, type = nil )
         @client = client
-        @name   = @client.assert_param_presence(name, 'index name')
+        @name   = @client.assert_param_presence(name, 'index name') unless name.nil?
         @type   = @client.assert_param_presence(type, 'document type') unless type.nil?
       end
 
       attr_reader :client, :name, :type
 
-      # Adds or updates a document in the index, making it searchable.
-      # See http://www.elasticsearch.org/guide/reference/api/index_/
+      # Adds or updates a document in the index, making it searchable. If the
+      # document contains an `:_id` attribute then PUT semantics will be used to
+      # create (or update) a document with that ID. If no ID is provided then a
+      # new document will be created using POST semantics.
+      #
+      # There are several other document attributes that control how
+      # ElasticSearch will index the document. They are listed below. Please
+      # refer to the ElasticSearch documentation for a full explanation of each
+      # and how it affects the indexing process.
+      #
+      #   :_id
+      #   :_type
+      #   :_version
+      #   :_version_type
+      #   :_op_type
+      #   :_routing
+      #   :_parent
+      #   :_timestamp
+      #   :_ttl
+      #   :_consistency
+      #   :_replication
+      #   :_refresh
+      #
+      # If any of these attributes are present in the document they will be
+      # removed from the document before it is indexed. This means that the
+      # document will be modified by this method.
       #
       # document - The document (as a Hash or JSON encoded String) to add to the index
       # params   - Parameters Hash
       #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-index_.html
+      #
       # Returns the response body as a Hash
       def index( document, params = {} )
-        overrides = from_document(document)
+        overrides = from_document document
         params = update_params(params, overrides)
         params[:action] = 'docs.index'
 
@@ -56,9 +85,10 @@ module Elastomer
       # Delete a document from the index based on the document ID. The :id is
       # provided as part of the params hash.
       #
-      # See http://www.elasticsearch.org/guide/reference/api/delete/
-      #
       # params - Parameters Hash
+      #   :id - the ID of the document to delete
+      #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-delete.html
       #
       # Returns the response body as a Hash
       def delete( params = {} )
@@ -69,9 +99,10 @@ module Elastomer
       # Retrieve a document from the index based on its ID. The :id is
       # provided as part of the params hash.
       #
-      # See http://www.elasticsearch.org/guide/reference/api/get/
-      #
       # params - Parameters Hash
+      #   :id - the ID of the document to get
+      #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-get.html#docs-get
       #
       # Returns the response body as a Hash
       def get( params = {} )
@@ -79,12 +110,28 @@ module Elastomer
         response.body
       end
 
+      # Check to see if a document exists. The :id is provided as part of the
+      # params hash.
+      #
+      # params - Parameters Hash
+      #   :id - the ID of the document to check
+      #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-get.html#docs-get
+      #
+      # Returns true if the document exists
+      def exists?( params = {} )
+        response = client.head '/{index}/{type}/{id}', update_params(params, :action => 'docs.exists')
+        response.success?
+      end
+      alias_method :exist?, :exists?
+
       # Retrieve the document source from the index based on the ID and type.
       # The :id is provided as part of the params hash.
       #
-      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-get.html#_source
-      #
       # params - Parameters Hash
+      #   :id - the ID of the document
+      #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-get.html#_source
       #
       # Returns the response body as a Hash
       def source( params = {} )
@@ -93,29 +140,32 @@ module Elastomer
       end
 
       # Allows to get multiple documents based on an index, type, and id (and possibly routing).
-      # See http://www.elasticsearch.org/guide/reference/api/multi-get/
       #
-      # docs   - The Hash describing the documents to get
+      # body   - The request body as a Hash or a JSON encoded String
       # params - Parameters Hash
       #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-multi-get.html
+      #
       # Returns the response body as a Hash
-      def multi_get( docs, params = {} )
-        overrides = from_document(docs)
+      def multi_get( body, params = {} )
+        overrides = from_document body
         overrides[:action] = 'docs.multi_get'
 
-        response = client.get '{/index}{/type}{/id}/_mget', update_params(params, overrides)
+        response = client.get '{/index}{/type}/_mget', update_params(params, overrides)
         response.body
       end
+      alias_method :mget, :multi_get
 
       # Update a document based on a script provided.
-      # See http://www.elasticsearch.org/guide/reference/api/update/
       #
       # script - The script (as a Hash) used to update the document in place
       # params - Parameters Hash
       #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-update.html
+      #
       # Returns the response body as a Hash
       def update( script, params = {} )
-        overrides = from_document(script)
+        overrides = from_document script
         overrides[:action] = 'docs.update'
 
         response = client.post '/{index}/{type}/{id}/_update', update_params(params, overrides)
@@ -128,8 +178,6 @@ module Elastomer
       # the query hash must contain the :query key. Otherwise we assume a URI
       # request is being made.
       #
-      # See http://www.elasticsearch.org/guide/reference/api/search/
-      #
       # query  - The query body as a Hash
       # params - Parameters Hash
       #
@@ -141,6 +189,10 @@ module Elastomer
       #   # same thing but using the URI request method
       #   search(:q => '*:*', :type => 'tweet')
       #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-search.html
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-uri-request.html
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-body.html
+      #
       # Returns the response body as a hash
       def search( query, params = nil )
         query, params = extract_params(query) if params.nil?
@@ -149,14 +201,30 @@ module Elastomer
         response.body
       end
 
+      # The search shards API returns the indices and shards that a search
+      # request would be executed against. This can give useful feedback for
+      # working out issues or planning optimizations with routing and shard
+      # preferences.
+      #
+      # params - Parameters Hash
+      #   :routing    - routing values
+      #   :preference - which shard replicas to execute the search request on
+      #   :local      - boolean value to use local cluster state
+      #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-shards.html
+      #
+      # Returns the response body as a hash
+      def search_shards( params = {} )
+        response = client.get '/{index}{/type}/_search_shards', update_params(params, :action => 'docs.search_shards')
+        response.body
+      end
+
       # Executes a search query, but instead of returning results, returns
       # the number of documents matched. This method supports both the
       # "request body" query and the "URI request" query. When using the
       # request body semantics, the query hash must contain the :query key.
       # Otherwise we assume a URI request is being made.
       #
-      # See http://www.elasticsearch.org/guide/reference/api/count/
-      #
       # query  - The query body as a Hash
       # params - Parameters Hash
       #
@@ -168,11 +236,13 @@ module Elastomer
       #   # same thing but using the URI request method
       #   count(:q => '*:*', :type => 'tweet')
       #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-count.html
+      #
       # Returns the response body as a Hash
-      def count(query, params = nil)
+      def count( query, params = nil )
         query, params = extract_params(query) if params.nil?
 
-        response = client.get '/{index}{/type}/_count', update_params(params, :body => query)
+        response = client.get '/{index}{/type}/_count', update_params(params, :body => query, :action => 'docs.count')
         response.body
       end
 
@@ -182,8 +252,6 @@ module Elastomer
       # hash must contain the :query key. Otherwise we assume a URI request is
       # being made.
       #
-      # See http://www.elasticsearch.org/guide/reference/api/delete-by-query/
-      #
       # query  - The query body as a Hash
       # params - Parameters Hash
       #
@@ -195,6 +263,8 @@ module Elastomer
       #   # same thing but using the URI request method
       #   delete_by_query(:q => '*:*', :type => 'tweet')
       #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-delete-by-query.html
+      #
       # Returns the response body as a hash
       def delete_by_query( query, params = nil )
         query, params = extract_params(query) if params.nil?
@@ -203,6 +273,40 @@ module Elastomer
         response.body
       end
 
+      # Returns information and statistics on terms in the fields of a
+      # particular document as stored in the index. The :id is provided as part
+      # of the params hash.
+      #
+      # params - Parameters Hash
+      #   :id - the ID of the document to get
+      #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-termvectors.html
+      #
+      # Returns the response body as a hash
+      def termvector( params = {} )
+        response = client.get '/{index}/{type}/{id}/_termvector', update_params(params, :action => 'docs.termvector')
+        response.body
+      end
+      alias_method :termvectors, :termvector
+      alias_method :term_vector, :termvector
+      alias_method :term_vectors, :termvector
+
+      # Multi termvectors API allows  you to get multiple termvectors based on
+      # an index, type and id. The response includes a docs array with all the
+      # fetched termvectors, each element having the structure provided by the
+      # `termvector` API.
+      #
+      # params - Parameters Hash
+      #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-multi-termvectors.html
+      #
+      # Returns the response body as a hash
+      def multi_termvectors( body, params = {} )
+        response = client.get '{/index}{/type}/_mtermvectors', update_params(params, :body => body, :action => 'docs.multi_termvectors')
+        response.body
+      end
+      alias_method :multi_term_vectors, :multi_termvectors
+
 =begin
 Percolate
 =end
@@ -213,9 +317,8 @@ Percolate
       # in the query body, but other fields like :size and :facets are
       # allowed.
       #
-      # See http://www.elasticsearch.org/guide/reference/api/more-like-this/
-      #
       # params - Parameters Hash
+      #   :id - the ID of the document
       #
       # Examples
       #
@@ -225,8 +328,10 @@ Percolate
       #   more_like_this({:from => 5, :size => 10}, :mlt_fields => "title",
       #                   :min_term_freq => 1, :type => "doc1", :id => 1)
       #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-more-like-this.html
+      #
       # Returns the response body as a hash
-      def more_like_this(query, params = nil)
+      def more_like_this( query, params = nil )
         query, params = extract_params(query) if params.nil?
 
         response = client.get '/{index}/{type}/{id}/_mlt', update_params(params, :body => query, :action => 'docs.more_like_this')
@@ -237,10 +342,9 @@ Percolate
       # can give useful feedback about why a document matched or didn't match
       # a query. The document :id is provided as part of the params hash.
       #
-      # See http://www.elasticsearch.org/guide/reference/api/explain/
-      #
       # query  - The query body as a Hash
       # params - Parameters Hash
+      #   :id - the ID of the document
       #
       # Examples
       #
@@ -248,8 +352,10 @@ Percolate
       #
       #   explain(:q => "message:search", :id => 1)
       #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-explain.html
+      #
       # Returns the response body as a hash
-      def explain(query, params = nil)
+      def explain( query, params = nil )
         query, params = extract_params(query) if params.nil?
 
         response = client.get '/{index}/{type}/{id}/_explain', update_params(params, :body => query, :action => 'docs.explain')
@@ -260,21 +366,21 @@ Percolate
       # :explain parameter can be used to get detailed information about
       # why a query failed.
       #
-      # See http://www.elasticsearch.org/guide/reference/api/validate/
-      #
       # query  - The query body as a Hash
       # params - Parameters Hash
       #
       # Examples
       #
       #   # request body query
-      #   validate(:query_string => {:query => "*:*"})
+      #   validate({:query => {:query_string => {:query => "*:*"}}}, :explain => true)
       #
       #   # same thing but using the URI query parameter
-      #   validate({:q => "post_date:foo"}, :explain => true)
+      #   validate(:q => "post_date:foo", :explain => true)
+      #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-validate.html
       #
       # Returns the response body as a hash
-      def validate(query, params = nil)
+      def validate( query, params = nil )
         query, params = extract_params(query) if params.nil?
 
         response = client.get '/{index}{/type}/_validate/query', update_params(params, :body => query, :action => 'docs.validate')
@@ -309,8 +415,37 @@ Percolate
         client.bulk params, &block
       end
 
-      # Create a new Scan instance for scrolling all results from a `query`.
-      # The Scan will be scoped to the current index and document type.
+      # Create a new Scroller instance for scrolling all results from a `query`.
+      # The Scroller will be scoped to the current index and document type.
+      #
+      # query  - The query to scroll as a Hash or a JSON encoded String
+      # opts   - Options Hash
+      #   :index  - the name of the index to search
+      #   :type   - the document type to search
+      #   :scroll - the keep alive time of the scrolling request (5 minutes by default)
+      #   :size   - the number of documents per shard to fetch per scroll
+      #
+      # Examples
+      #
+      #   scroll = index.scroll('{"query":{"match_all":{}},"sort":{"date":"desc"}}')
+      #   scroll.each_document do |document|
+      #     document['_id']
+      #     document['_source']
+      #   end
+      #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/guide/current/scan-scroll.html
+      #
+      # Returns a new Scroller instance
+      def scroll( query, opts = {} )
+        opts = {:index => name, :type => type}.merge opts
+        client.scroll query, opts
+      end
+
+      # Create a new Scroller instance for scanning all results from a `query`.
+      # The Scroller will be scoped to the current index and document type. The
+      # Scroller is configured to use `scan` semantics which are more efficient
+      # than a standard scroll query; the caveat is that the returned documents
+      # cannot be sorted.
       #
       # query  - The query to scan as a Hash or a JSON encoded String
       # opts   - Options Hash
@@ -327,7 +462,7 @@ Percolate
       #     document['_source']
       #   end
       #
-      # Returns a new Scan instance
+      # Returns a new Scroller instance
       def scan( query, opts = {} )
         opts = {:index => name, :type => type}.merge opts
         client.scan query, opts
@@ -338,8 +473,6 @@ Percolate
       # and document type will be passed to the multi_search API call as
       # part of the request parameters.
       #
-      # See http://www.elasticsearch.org/guide/reference/api/multi-search/
-      #
       # params - Parameters Hash that will be passed to the API call.
       # block  - Required block that is used to accumulate searches.
       #          All the operations will be passed to the search cluster
@@ -356,14 +489,19 @@ Percolate
       #     ...
       #   end
       #
+      # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-multi-search.html
+      #
       # Returns the response body as a Hash
-      def multi_search(params = {}, &block)
+      def multi_search( params = {}, &block )
         raise 'a block is required' if block.nil?
 
         params = {:index => self.name, :type => self.type}.merge params
         client.multi_search params, &block
       end
 
+      SPECIAL_KEYS = %w[index type id version version_type op_type routing parent timestamp ttl consistency replication refresh].freeze
+      SPECIAL_KEYS_HASH = SPECIAL_KEYS.inject({}) { |h, k| h[k.to_sym] = "_#{k}"; h }.freeze
+
       # Internal: Given a `document` generate an options hash that will
       # override parameters based on the content of the document. The document
       # will be returned as the value of the :body key.
@@ -377,10 +515,8 @@ Percolate
       def from_document( document )
         opts = {:body => document}
 
-        unless String === document
-          %w[_id _type _routing _parent _ttl _timestamp _retry_on_conflict].each do |field|
-            key = field.sub(/^_/, '').to_sym
-
+        if document.is_a? Hash
+          SPECIAL_KEYS_HASH.each do |key, field|
             opts[key] = document.delete field if document.key? field
             opts[key] = document.delete field.to_sym if document.key? field.to_sym
           end
@@ -415,7 +551,7 @@ Percolate
       # params - params hash OR nil if no query
       #
       # Returns an array of the query (possibly nil) and params Hash.
-      def extract_params(query, params=nil)
+      def extract_params( query, params = nil )
         if params.nil?
           if query.key? :query
             params = {}
@@ -426,6 +562,6 @@ Percolate
         [query, params]
       end
 
-    end  # Docs
-  end  # Client
-end  # Elastomer
+    end
+  end
+end