elastics 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 39da83ca0918ecd5e5bced988a20a0f43c4a0651
-  data.tar.gz: 1b71e46b7873678e169586cf4f16204c3f01d01c
+  metadata.gz: c5c6528a83756461e3f88a64c932e6f6cd4a572e
+  data.tar.gz: 329c63ad74333cee9dc57581ca8ac626973dea3b
 SHA512:
-  metadata.gz: fc66215c7c93d9209828494f50aa2ed7a39ec4477924728955641ee6d8ed4cfa0fe09ed7388e7d6c599923c3eef28b729c1c3fd92f0c370a9f02b88bf16d2240
-  data.tar.gz: b03818b919cb671ec17c259f30527d18d994a5dc3c05377b1fbacd87bcbb73b68f4de5bdff16af9f43500f465f950d795be53a82562b7ec0eec86f03b7defe6c
+  metadata.gz: aba73c791bb368035b51ed5d93994fa27648c442f77ed7992749b5bb5ee5ee823a17e33d5449d0d8a1f293dd830ff01501405287ca1dc563df644c3bb3da68ba
+  data.tar.gz: d687176c8013f6196d0ebc0340aaa6e194e5719b700fdbb688159ca2ca6ffda3694e144e0b55c064fcb63b629299288121b9dbd25ba61876318092089360cafa

data/.travis.yml

@@ -3,5 +3,7 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.4
+services:
+  - elasticsearch
 notifications:
   email: false

data/README.md

@@ -3,10 +3,12 @@
 [![Code Climate](https://codeclimate.com/github/printercu/elastics-rb/badges/gpa.svg)](https://codeclimate.com/github/printercu/elastics-rb)
 [![Build Status](https://travis-ci.org/printercu/elastics-rb.svg)](https://travis-ci.org/printercu/elastics-rb)
 
-Simple ElasticSearch client.
-- basic API only
-- transparent aliases management & zero-downtime migrations
-- capistrano integration
+Simple ElasticSearch client. Everything for deployment & maintaince included.
+- Basic API only
+- Transparent aliases management & zero-downtime migrations
+- Capistrano integration
+- Auto refresh in tests
+- Instrumentation
 
 Fast and thread-safe [httpclient](https://github.com/nahi/httpclient) is under the hood.
 
@@ -14,7 +16,7 @@ Fast and thread-safe [httpclient](https://github.com/nahi/httpclient) is under t
 
 ```ruby
 # Gemfile
-gem 'elastics', '~> 0.2' # use version from the badge above
+gem 'elastics', '~> 0.3' # use version from the badge above
 # or
 gem 'elastics', github: 'printercu/elastics-rb'
 ```
@@ -34,10 +36,10 @@ client = Elastics::Client.new(options)
 #   :resurrect_timeout  - timeout to mark dead host as alive in cluster-mode (default 10)
 
 # basic request
-client.request(options)
-# options is hash with
+client.request(params)
+# params is hash with
 #   :method - default :get
-#   :data   - post body
+#   :body   - post body
 #   :query  - query string params
 #   :index, :type, :id - query path params to override defaults
 
@@ -50,12 +52,22 @@ client.get(id)
 client.get(params) # as usual
 
 # other shortcuts (set method & id)
-client.put_mapping(index: index, type: type, data: mapping)
+client.put_mapping(index: index, type: type, body: mapping)
 client.search(params)
 client.index(params) # PUT if :id is set, otherwise POST
 
 # utils
 client.index_exists?(name)
+
+# bulk
+client.bulk(params) do |bulk|
+  # if first param is not a Hash it's converted to {_id: param}
+  bulk.index override_params, data
+  bulk.create id, data
+  bulk.update id, script
+  bulk.update_doc id, fields
+  bulk.delete id
+end
 ```
 
 When using cluster-mode you should also install `gem 'thread_safe'`.
@@ -65,6 +77,7 @@ When using cluster-mode you should also install `gem 'thread_safe'`.
 ```ruby
 class User < ActiveRecord::Base
   indexed_with_elastics
+  # it'll set after_commit callbacks and add helper methods
   # optionally pass :index, :type
 
   # optionally override to export only selected fields
@@ -73,9 +86,14 @@ class User < ActiveRecord::Base
   end
 end
 
+User.elastics # Elastics::Client instance
+User.elastics_params # hash with index & type values for the model
+User.request_elastics(params) # performs request merging params with elastics_params
 User.search_elastics(data)
 # Returns Elastics::ActiveRecord::SearchResult object with some useful methods
 ```
+Check out [HelperMethods](https://github.com/printercu/elastics-rb/blob/master/lib/elastics/active_record/helper_methods.rb)
+for more information.
 
 #### Configure
 ```yml
@@ -156,6 +174,21 @@ end
 Also you need to install `active_support` & require
 `active_support/core_ext/object` to be able to run tasks.
 
+### Auto refresh index
+Add `Elastics::AutoRefresh.enable!` to your test helper,
+this will run `POST /:index/_refresh` request after each modifying request.
+You can also use it for a block or skip auto refresh after it was enabled:
+
+```ruby
+# enable test mode in rspec's around filter
+around { |ex| Elastics::AutoRefresh.enable! { ex.run } }
+
+# disable auto refresh for block & perform single refresh
+# assume test mode is enabled here
+Elastics::AutoRefresh.disable! { Model.reindex_elastics }
+Model.refresh_elastics
+```
+
 ### Use with capistrano
 Add following lines to your `deploy.rb` and all rake tasks will be available in cap.
 
@@ -170,5 +203,8 @@ Indices & rake options can be passed like this:
 cap --dry-run elastics:migrate INDICES=index1,index2 ES_OPTIONS='full=true no_drop=true'
 ```
 
+## Other versions
+[elastics for node.js](https://github.com/printercu/elastics)
+
 ## License
 MIT

data/lib/elastics/active_record/helper_methods.rb

@@ -8,19 +8,26 @@ module Elastics
       end
 
       module ClassMethods
-        def request_elastics(params)
-          request = {
+        def elastics_params
+          {
             index:  elastics_index_name,
             type:   elastics_type_name,
             model:  self,
-          }.merge!(params)
-          elastics.request(request)
+          }
+        end
+
+        def request_elastics(params)
+          elastics.request(elastics_params.merge!(params))
+        end
+
+        def bulk_elastics(params = {}, &block)
+          elastics.bulk(elastics_params.merge!(params), &block)
         end
 
         def search_elastics(data = {}, options = {})
           request = {
             id:   :_search,
-            data: data,
+            body: data,
           }
           if routing = options[:routing]
             request[:query] = {routing: routing}
@@ -37,23 +44,54 @@ module Elastics
           request_elastics(method: :get, id: :_mapping)
         end
 
-        def reindex_elastics(*args)
-          find_each(*args, &:index_elastics)
+        def index_all_elastics(*args)
+          find_in_batches(*args) do |batch|
+            bulk_elastics do |bulk|
+              batch.each do |record|
+                bulk.index record.id, record.to_elastics
+              end
+            end
+          end
+        end
+
+        # Reindexes records with `#index_all_elastics`. If model has scope
+        # named `reindex_scope`, this method will apply it.
+        #
+        # Also supports `:updated_after` option to reindex only updated records.
+        # Nothing is performed when `:updated_after` is set but model
+        # has not `updated_at` column.
+        def reindex_elastics(options = {})
+          scope = respond_to?(:reindex_scope) ? reindex_scope : all
+          if after = options.delete(:updated_after)
+            if updated_at = arel_table[:updated_at]
+              scope = scope.where(updated_at.gt(after))
+            else
+              return
+            end
+          end
+          scope.index_all_elastics(options)
+        end
+
+        def refresh_elastics
+          request_elastics(method: :post, type: nil, id: :_refresh)
         end
       end
 
       def index_elastics
-        self.class.request_elastics(method: :post, id: id, data: to_elastics)
+        self.class.request_elastics(method: :post, id: id, body: to_elastics)
+      end
+
+      def update_elastics(data)
+        self.class.request_elastics(method: :post, id: "#{id}/_update", body: data)
       end
 
-      def update_elastics(fields)
-        self.class.request_elastics(method: :post, id: "#{id}/_update", data: {
-          doc: fields
-        })
+      def update_elastics_doc(fields)
+        update_elastics(doc: fields)
       end
 
       def delete_elastics
         self.class.request_elastics(method: :delete, id: id)
+      rescue NotFound
       end
     end
   end

data/lib/elastics/active_record/instrumentation.rb

@@ -7,7 +7,7 @@ module Elastics
           if Client.respond_to?(:prepend)
             Client.prepend self
           else
-            Client.include Fallback
+            Client.send :include, Fallback
           end
           unless ::ActiveRecord::LogSubscriber < LogSubscriber
             ::ActiveRecord::LogSubscriber.send :include, LogSubscriber

data/lib/elastics/active_record/search_result.rb

@@ -1,48 +1,22 @@
 module Elastics
   module ActiveRecord
-    class SearchResult
-      attr_reader :result
-
-      def initialize(model, result, options = {})
+    class SearchResult < Result::Search
+      def initialize(model, response, options = {})
         @model = model
-        @result = result
-        @options = options
-      end
-
-      def hits
-        @hits ||= @result['hits'.freeze]
+        super response, options
       end
 
+      # super.map(&:to_i)
       def ids
         @ids ||= hits['hits'.freeze].map { |x| x['_id'.freeze].to_i }
       end
 
-      def ids_to_find
-        @ids_to_find ||= begin
-          limit = @options[:limit]
-          limit ? ids[0...limit] : ids
-        end
-      end
-
-      def rest_ids
-        limit = @options[:limit]
-        limit ? ids[limit..-1] : []
-      end
-
       def collection
         @collection ||= @model.find_all_ordered ids_to_find
       end
 
       def relation
-        @model.where id: ids_to_find
-      end
-
-      def aggregations
-        @aggregations ||= @result['aggregations'.freeze]
-      end
-
-      def total
-        hits['total'.freeze]
+        @model.where(id: ids_to_find)
       end
     end
   end

data/lib/elastics/auto_refresh.rb

@@ -0,0 +1,48 @@
+module Elastics
+  module AutoRefresh
+    METHODS = %w(put post patch delete)
+    SKIP_IDS = %w(_refresh _search)
+
+    class << self
+      def enabled?
+        Thread.current[:elastics_test_mode]
+      end
+
+      def enabled=(value)
+        value = !!value
+        Client.send(:include, self) if value && !Client.include?(self)
+        Thread.current[:elastics_test_mode] = value
+      end
+
+      def use(value)
+        old_value = enabled?
+        self.enabled = value
+        block_given? ? yield : value
+      ensure
+        self.enabled = old_value if block_given?
+      end
+
+      def enable!(&block)
+        use(true, &block)
+      end
+
+      def disable!(&block)
+        use(false, &block)
+      end
+
+      def included(base)
+        base.send :alias_method, :request_without_auto_refresh, :request
+        base.send :alias_method, :request, :request_with_auto_refresh
+      end
+    end
+
+    def request_with_auto_refresh(params)
+      request_without_auto_refresh(params).tap do
+        next unless AutoRefresh.enabled?
+        next if SKIP_IDS.include?(params[:id].to_s.downcase)
+        next unless METHODS.include?(params[:method].to_s.downcase)
+        refresh(params[:index])
+      end
+    end
+  end
+end

data/lib/elastics/client/bulk.rb

@@ -0,0 +1,49 @@
+module Elastics
+  class Client
+    module Bulk
+      def bulk(params = {})
+        builder = Builder.new
+        yield builder
+        if builder.any?
+          request({body: builder.body, method: :post, id: :_bulk}.merge! params)
+        end
+      end
+
+      class Builder
+        attr_reader :actions
+
+        def initialize
+          @actions = []
+        end
+
+        def any?
+          @actions.any?
+        end
+
+        def body
+          @actions.map(&:to_json).join("\n".freeze) + "\n"
+        end
+
+        def add_action(action, params, data = nil)
+          params = {_id: params} unless params.is_a?(Hash)
+          @actions << {action => params}
+          @actions << data if data
+        end
+
+        [:index, :create, :update].each do |action|
+          define_method(action) do |params, data|
+            add_action(action, params, data)
+          end
+        end
+
+        def update_doc(params, fields)
+          update(params, doc: fields)
+        end
+
+        def delete(params)
+          add_action(:delete, params)
+        end
+      end
+    end
+  end
+end

data/lib/elastics/client.rb

@@ -1,3 +1,4 @@
+require 'json'
 require 'httpclient'
 
 module Elastics
@@ -6,6 +7,9 @@ module Elastics
 
     autoload :Cluster, 'elastics/client/cluster'
 
+    require 'elastics/client/bulk'
+    include Bulk
+
     attr_writer :index, :type
     attr_reader :client
 
@@ -46,9 +50,10 @@ module Elastics
       str
     end
 
-    def request(params)
+    def request(params = {})
       method = params[:method] || :get
-      body = params[:data].try!(:to_json)
+      body = params[:body]
+      body = body.to_json if body && !body.is_a?(String)
       res = http_request(method, request_path(params), params[:query], body, params)
       status = res.status
       return JSON.parse(res.body) if 300 > status
@@ -68,6 +73,7 @@ module Elastics
     end
 
     def delete!(params)
+      params = {id: params} unless params.is_a?(Hash)
       params[:method] = :delete
       request params
     end
@@ -89,7 +95,7 @@ module Elastics
     end
 
     def set(id, data)
-      request(id: id, data: data, method: :put)
+      request(id: id, body: data, method: :put)
     end
 
     def put_mapping(params)
@@ -98,10 +104,10 @@ module Elastics
       request(params)
     end
 
-    def search(params)
+    def search(params, *args)
       params[:id] = :_search
       params[:method] = :post
-      request(params)
+      Result::Search.new(request(params), *args)
     end
 
     def index(params)
@@ -112,6 +118,15 @@ module Elastics
       !!get(index: index, type: nil, id: :_mapping)
     end
 
+    def refresh!(index = nil)
+      request(method: :post, index: index, type: nil, id: :_refresh)
+    end
+
+    def refresh(*args)
+      refresh!(*args)
+    rescue NotFound
+    end
+
     private
       # Endpoint for low-level request. For easy host highjacking & instrumentation.
       # Params are not used directly but kept for instrumentation purpose.

data/lib/elastics/result/search.rb

@@ -0,0 +1,43 @@
+module Elastics
+  module Result
+    class Search
+      attr_reader :response
+
+      def initialize(response, options = {})
+        @response = response
+        @options = options
+      end
+
+      def hits
+        @hits ||= @response['hits'.freeze]
+      end
+
+      def ids
+        @ids ||= hits['hits'.freeze].map { |x| x['_id'.freeze] }
+      end
+
+      # Allows to split ids into two parts, if you want to fetch from primary DB
+      # less then was found. This method returns the first part,
+      # `rest_ids` - the second.
+      def ids_to_find
+        @ids_to_find ||= begin
+          limit = @options[:limit]
+          limit ? ids[0...limit] : ids
+        end
+      end
+
+      def rest_ids
+        limit = @options[:limit]
+        limit ? ids[limit..-1] : []
+      end
+
+      def aggregations
+        @aggregations ||= @response['aggregations'.freeze]
+      end
+
+      def total
+        hits['total'.freeze]
+      end
+    end
+  end
+end

data/lib/elastics/result.rb

@@ -0,0 +1,5 @@
+module Elastics
+  module Result
+    autoload :Search, 'elastics/result/search'
+  end
+end

data/lib/elastics/tasks/indices.rb

@@ -58,7 +58,7 @@ module Elastics
           log_msg << ' - Skipping: exists' if exists
           log log_msg
           unless exists
-            client.put(index: versioned_index, data: indices_settings[index])
+            client.put(index: versioned_index, body: indices_settings[index])
           end
         end
         manage_aliases :add, options if version.to_s == 'current'
@@ -97,7 +97,7 @@ module Elastics
       def post_aliases(options = {}, &block)
         actions = each_filtered(indices, options[:indices]).map(&block).flatten
         log "Posting aliases: #{actions.inspect}"
-        client.post id: :_aliases, data: {actions: actions} if actions.any?
+        client.post id: :_aliases, body: {actions: actions} if actions.any?
       end
     end
   end

data/lib/elastics/tasks/mappings.rb

@@ -17,7 +17,7 @@ module Elastics
           versioned_index = versioned_index_name(index, version)
           log "Putting mapping #{index}/#{type} (#{versioned_index}/#{type})"
           client.put_mapping index: versioned_index, type: type,
-            data: mappings[type]
+            body: mappings[type]
         end
       end
 

data/lib/elastics/tasks/migrations.rb

@@ -8,22 +8,33 @@ module Elastics
 
       def migrate!(options = {})
         options_next = options.merge version: :next
+        need_reindex = options.fetch(:reindex, true)
         drop_indices(options_next)
         create_indices(options_next)
         put_mappings(options_next)
-        reindex(options_next) if options.fetch(:reindex, true)
+        started_at = reindex(options_next) if need_reindex
         forward_aliases(options)
+        if need_reindex
+          reindex(options.merge(version: :current, updated_after: started_at))
+        end
       end
 
+      # Runs `#reindex_elastics` on matching models.
+      # Returns hash with timestamps with reindex start time for each model.
+      # Supports this kind of hash as `:updated_after` option, to reindex
+      # only updated records.
       def reindex(options = {})
         version = options.fetch(:version, :current)
+        updated_after = options.fetch(:updated_after, {})
         Rails.application.eager_load! if defined?(Rails)
         VersionManager.use_version version do
-          models_to_reindex(options).each do |model|
+          Hash[models_to_reindex(options).map do |model|
+            started_at = Time.now
             log "Reindexing #{model.elastics_index_base} into " \
               "#{model.elastics_index_name}/#{model.elastics_type_name}"
-            model.reindex_elastics
-          end
+            model.reindex_elastics(updated_after: updated_after[model])
+            [model, started_at]
+          end]
         end
       end
 

data/lib/elastics/version.rb

@@ -1,5 +1,5 @@
 module Elastics
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 
   def self.gem_version
     Gem::Version.new VERSION

data/lib/elastics/version_manager.rb

@@ -39,7 +39,7 @@ module Elastics
 
     def set(index, data)
       @client.post index: @service_index, type: :mapping_versions,
-        id: prefixed_index(index), data: data
+        id: prefixed_index(index), body: data
       @versions[index] = data.with_indifferent_access
     end
 

data/lib/elastics.rb

@@ -3,12 +3,12 @@ module Elastics
   class NotFound < Error; end
 
   require 'elastics/client'
-  require 'elastics/version_manager'
-  require 'elastics/query_helper'
 
-  autoload :Tasks, 'elastics/tasks'
-
-  extend QueryHelper
+  autoload :AutoRefresh,    'elastics/auto_refresh'
+  autoload :Tasks,          'elastics/tasks'
+  autoload :QueryHelper,    'elastics/query_helper'
+  autoload :Result,         'elastics/result'
+  autoload :VersionManager, 'elastics/version_manager'
 
   class << self
     attr_reader :models

data/spec/lib/elastics/auto_refresh_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Elastics::AutoRefresh do
+  let(:client) { Elastics::Client.new }
+  let(:response) { OpenStruct.new(body: '{}', status: 200) }
+  before { allow(client).to receive(:http_request) { response } }
+
+  describe '.enable!' do
+    around { |ex| described_class.enable! { ex.run } }
+
+    context 'for GET & search request' do
+      it 'doesn`t invoke refresh' do
+        expect(client).to_not receive(:refresh)
+        client.get 1
+        client.search query: {match_all: {}}
+        client.request method: :get, id: :_mapping
+      end
+    end
+
+    context 'for POST, PUT & DELETE requests' do
+      it 'invokes refresh after each request' do
+        expect(client).to receive(:refresh).exactly(3).times
+        client.post id: 1
+        client.put_mapping type: {fields: {}}
+        client.delete id: 2
+      end
+
+      it 'invokes refresh after each request, not wrapped in .disable! block' do
+        expect(client).to receive(:refresh).exactly(2).times
+        client.post id: 1
+        described_class.disable! { client.put_mapping type: {fields: {}} }
+        client.delete id: 2
+      end
+    end
+  end
+end

data/spec/lib/elastics/client/bulk_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Elastics::Client::Bulk::Builder do
+  let(:instance) { described_class.new }
+
+  describe '#add_action' do
+    context 'if params is hash' do
+      it 'add param as is' do
+        expect { instance.add_action :action, {test: 1} }.
+          to change { instance.actions }.
+          from([]).
+          to([{action: {test: 1}}])
+      end
+    end
+
+    context 'if params is not a hash' do
+      it 'treats params as id' do
+        expect { instance.add_action :action, 1 }.
+          to change { instance.actions }.
+          from([]).
+          to([{action: {_id: 1}}])
+      end
+    end
+
+    it 'adds data as is' do
+      expect { instance.add_action :action, {test: 1}, :data }.
+        to change { instance.actions }.
+        from([]).
+        to([{action: {test: 1}}, :data])
+    end
+  end
+end
+
+describe Elastics::Client do
+  let(:client) { Elastics::Client.new }
+
+  describe '#bulk' do
+    context 'when no actions added' do
+      it 'should not invoke #request' do
+        expect(client).to_not receive(:request)
+        client.bulk {}
+      end
+    end
+
+    context 'when some actions added' do
+      it 'should invoke request' do
+        expect(client).to receive(:request).with(
+          id:     :_bulk,
+          method: :post,
+          index:  :index1,
+          body:   "{\"delete\":{\"_id\":1}}\n",
+        )
+        client.bulk(index: :index1) { |x| x.delete 1 }
+      end
+    end
+  end
+end

data/spec/lib/elastics/client_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Elastics::Client do
+  let(:instance) { described_class.new }
+  let(:index_name) { 'elastics_test' }
+
+  describe '#refresh!' do
+    subject { instance.refresh!(index_name) }
+
+    context 'when index exists' do
+      before { instance.post(index: index_name) }
+      after { instance.delete(index: index_name) }
+      it { should be }
+    end
+
+    context 'when index does not exist' do
+      it { expect { subject }.to raise_error(Elastics::NotFound) }
+    end
+  end
+
+  describe '#refresh' do
+    subject { instance.refresh(index_name) }
+
+    context 'when index exists' do
+      before { instance.post(index: index_name) }
+      after { instance.delete(index: index_name) }
+      it { should be }
+    end
+
+    context 'when index does not exist' do
+      it { should be_nil }
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elastics
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Max Melentiev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-01 00:00:00.000000000 Z
+date: 2014-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient
@@ -115,11 +115,15 @@ files:
 - lib/elastics/active_record/model_schema.rb
 - lib/elastics/active_record/search_result.rb
 - lib/elastics/active_record/tasks_config.rb
+- lib/elastics/auto_refresh.rb
 - lib/elastics/capistrano.rb
 - lib/elastics/client.rb
+- lib/elastics/client/bulk.rb
 - lib/elastics/client/cluster.rb
 - lib/elastics/query_helper.rb
 - lib/elastics/railtie.rb
+- lib/elastics/result.rb
+- lib/elastics/result/search.rb
 - lib/elastics/tasks.rb
 - lib/elastics/tasks/config.rb
 - lib/elastics/tasks/indices.rb
@@ -128,7 +132,10 @@ files:
 - lib/elastics/version.rb
 - lib/elastics/version_manager.rb
 - lib/tasks/elastics.rake
+- spec/lib/elastics/auto_refresh_spec.rb
+- spec/lib/elastics/client/bulk_spec.rb
 - spec/lib/elastics/client/cluster_spec.rb
+- spec/lib/elastics/client_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/printercu/elastics-rb
 licenses:
@@ -155,6 +162,8 @@ signing_key:
 specification_version: 4
 summary: ElasticSearch client with ActiveRecord integration
 test_files:
+- spec/lib/elastics/auto_refresh_spec.rb
+- spec/lib/elastics/client/bulk_spec.rb
 - spec/lib/elastics/client/cluster_spec.rb
+- spec/lib/elastics/client_spec.rb
 - spec/spec_helper.rb
-has_rdoc: