elasticsearch-documents 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d5c254c644e1b8f9f4649a463816664305479ce7
-  data.tar.gz: d37eb314977344a51a554bd20799f924c954e4cc
+  metadata.gz: 28646ee3ed70dd2e2522d287d9ce3e1589c60404
+  data.tar.gz: c1ddaf4c1eeed321de410083afb1bbea21797cf1
 SHA512:
-  metadata.gz: 5101e3b59ff7ef130591279d0076c0480eeabe93cff21c19f69fffc5f3ba0bed89f87ba1f92c1ed90000c347d37725cb28098c1dbbd6b338e43318231eeccc9c
-  data.tar.gz: e6a6e3980de1d94f54a4976ef558371e468dd1b126c7260c01ed500a1a2389670ced05b63c96da99e50ce57e0e473710e3175706b57d53a6c365d04315a16cf3
+  metadata.gz: e520e5c94ef8bbd9b75ca79680a4356b8f6aaead55a2f953062fe9beb4d37a289b0c2623fcfb96706db7e575b02ad94f82252f688883428b72a08e9bc430456e
+  data.tar.gz: f18175a7a63a6b4f8a9d14e5efe300370eef15f525de8d0a5c160f3b586196294b9097c9c4a209af4596e8d6349376dbc91fbb7e5a89aca5523e1ef4c262c317

data/Rakefile

@@ -4,3 +4,8 @@ require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec)
 task default: :spec
 
+desc "Opens a pry session configured to use a local elasticsearch server"
+task :console do
+  sh "bundle exec pry -I lib -I spec -r elasticsearch-documents -r test_env"
+end
+

data/elasticsearch-documents.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 2.14"
+  spec.add_development_dependency "pry"
 
   spec.add_runtime_dependency "elasticsearch"
   spec.add_runtime_dependency "hashie"

data/lib/elasticsearch/extensions/documents.rb

@@ -4,8 +4,10 @@ require "ostruct"
 require "elasticsearch/extensions/documents/version"
 require "elasticsearch/extensions/documents/document"
 require "elasticsearch/extensions/documents/index"
-require "elasticsearch/extensions/documents/indexer"
+require "elasticsearch/extensions/documents/aliased_index_store"
+require "elasticsearch/extensions/documents/direct_index_store"
 require "elasticsearch/extensions/documents/queryable"
+require "elasticsearch/extensions/documents/storage"
 require "elasticsearch/extensions/documents/utils"
 
 module Elasticsearch
@@ -31,6 +33,14 @@ module Elasticsearch
         def logger
           self.configuration.client.logger ||= Logger.new(STDERR)
         end
+
+        def index_adapter
+          case self.configuration.index_adapter
+          when :direct then DirectIndexStore.new
+          when :aliased then AliasedIndexStore.new
+          else DirectIndexStore.new end
+        end
+
       end
 
     end

data/lib/elasticsearch/extensions/documents/aliased_index_store.rb

@@ -0,0 +1,112 @@
+module Elasticsearch
+  module Extensions
+    module Documents
+      class AliasedIndexStore
+
+        attr_reader :client, :storage, :read_alias, :write_alias
+
+        def initialize(options = {})
+          @client      = options.fetch(:client)  { Documents.client }
+          @storage     = options.fetch(:storage) { Storage.new }
+          @write_alias = Documents.index_name + "_write"
+          @read_alias  = Documents.index_name + "_read"
+        end
+
+        def index(payload)
+          client.index payload.merge(index: write_alias)
+        end
+
+        def delete(payload)
+          client.delete payload.merge(index: write_alias)
+        end
+
+        def search(payload)
+          client.search payload.merge(index: read_alias)
+        end
+
+        def refresh
+          client.indices.refresh index: read_alias
+        end
+
+        def reindex(options = {}, &block)
+          timestamp      = Time.now.strftime('%Y%m%d-%H%M%S')
+          new_index_name = Documents.index_name + "_#{timestamp}"
+          current_index_name = indices_for_alias(write_alias).first
+
+          storage.create_index new_index_name
+          swap_index_alias(alias: write_alias, old: current_index_name, new: new_index_name)
+
+          block.call(self) if block_given?
+
+          swap_index_alias(alias: read_alias, old: current_index_name, new: new_index_name)
+          storage.drop_index current_index_name
+        end
+
+        def indices_for_alias(alias_name)
+          client.indices.get_alias(name: alias_name).keys
+        end
+
+        def setup
+          reset_aliases
+
+          timestamp      = Time.now.strftime('%Y%m%d-%H%M%S')
+          new_index_name = Documents.index_name + "_#{timestamp}"
+
+          storage.create_index new_index_name
+          client.indices.put_alias index: new_index_name, name: read_alias
+          client.indices.put_alias index: new_index_name, name: write_alias
+        end
+
+        def swap_index_alias(options)
+          change_alias = options.fetch(:alias)
+          new_index = options.fetch(:new)
+          old_index = options.fetch(:old)
+
+          client.indices.update_aliases body: {
+            actions: [
+              { remove: { index: old_index, alias: change_alias } },
+              { add:    { index: new_index, alias: change_alias } },
+            ]
+          }
+        end
+
+        def reset_aliases
+          if client.indices.exists_alias(name: write_alias)
+            indices_for_alias(write_alias).each do |index|
+              client.indices.delete_alias index: index, name: write_alias
+            end
+          end
+
+          if client.indices.exists_alias(name: read_alias)
+            indices_for_alias(read_alias).each do |index|
+              client.indices.delete_alias index: index, name: read_alias
+            end
+          end
+        end
+
+        def bulk_index(documents)
+          client.bulk body: bulk_index_operations(documents)
+        end
+
+        private
+
+        def bulk_index_operations(documents)
+          documents.collect { |document| bulk_index_operation_hash(document) }
+        end
+
+        def bulk_index_operation_hash(document)
+          {
+            index: {
+              _index: write_alias,
+              _type:  document.class.type,
+              _id:    document.id,
+              data:   document.as_hash,
+            }
+          }
+        end
+
+      end
+    end
+  end
+end
+

data/lib/elasticsearch/extensions/documents/direct_index_store.rb

@@ -0,0 +1,65 @@
+module Elasticsearch
+  module Extensions
+    module Documents
+      class DirectIndexStore
+        attr_reader :client, :storage
+
+        def initialize(options = {})
+          @client  = options.fetch(:client)  { Documents.client }
+          @storage = options.fetch(:storage) { Storage.new }
+        end
+
+        def index(payload)
+          client.index payload.merge(index: Documents.index_name)
+        end
+
+        def delete(payload)
+          client.delete payload.merge(index: Documents.index_name)
+        end
+
+        def search(payload)
+          client.search payload.merge(index: Documents.index_name)
+        end
+
+        def refresh
+          client.indices.refresh index: Documents.index_name
+        end
+
+        def reindex(options = {}, &block)
+          force_create = options.fetch(:force_create) { false }
+
+          storage.drop_index(Documents.index_name) if force_create
+          storage.create_index(Documents.index_name)
+
+          block.call(self) if block_given?
+        end
+
+        def setup
+          storage.drop_index(Documents.index_name)
+          storage.create_index(Documents.index_name)
+        end
+
+        def bulk_index(documents)
+          client.bulk body: bulk_index_operations(documents)
+        end
+
+        def bulk_index_operations(documents)
+          documents.collect { |document| bulk_index_operation_hash(document) }
+        end
+
+        def bulk_index_operation_hash(document)
+          {
+            index: {
+              _index: Documents.index_name,
+              _type:  document.class.type,
+              _id:    document.id,
+              data:   document.as_hash,
+            }
+          }
+        end
+
+      end
+    end
+  end
+end
+

data/lib/elasticsearch/extensions/documents/index.rb

@@ -4,40 +4,46 @@ module Elasticsearch
   module Extensions
     module Documents
       class Index
-        attr_reader :client
+        attr_reader :adapter
 
-        def initialize(client = nil)
-          @client = client || Documents.client
+        def initialize(adapter = nil)
+          @adapter = adapter || Documents.index_adapter
         end
 
         def index(document)
           payload = {
-            index:  Documents.index_name,
             type:   document.class.type,
             id:     document.id,
             body:   document.as_hash,
           }
-          client.index payload
+          adapter.index payload
         end
 
         def delete(document)
           payload = {
-            index:  Documents.index_name,
             type:   document.class.type,
             id:     document.id,
           }
-          client.delete payload
+          adapter.delete payload
         rescue Elasticsearch::Transport::Transport::Errors::NotFound => not_found
           Documents.logger.info "[Documents] Attempted to delete missing document: #{not_found}"
         end
 
         def search(query)
-          response = client.search(query.as_hash)
+          response = adapter.search(query.as_hash)
           Hashie::Mash.new(response)
         end
 
         def refresh
-          client.indices.refresh index: Documents.index_name
+          adapter.refresh
+        end
+
+        def reindex(options = {}, &block)
+          adapter.reindex(options, &block)
+        end
+
+        def bulk_index(documents)
+          adapter.bulk_index(documents)
         end
 
       end

data/lib/elasticsearch/extensions/documents/storage.rb

@@ -0,0 +1,36 @@
+module Elasticsearch
+  module Extensions
+    module Documents
+      class Storage
+
+        attr_reader :client, :config
+
+        def initialize(options = {})
+          @client = options.fetch(:client) { Documents.client }
+          @config = options.fetch(:config) { Documents.configuration }
+        end
+
+        def drop_index(index_name)
+          client.indices.delete(index: index_name) if index_exists?(index_name)
+        end
+
+        def index_exists?(index_name)
+          client.indices.exists(index: index_name)
+        end
+
+        def create_index(index_name)
+          client.indices.create(index: index_name, body: index_definition) unless index_exists?(index_name)
+        end
+
+        def index_definition
+          {}.tap do |body|
+            body[:settings] = config.settings if config.settings
+            body[:mappings] = config.mappings if config.mappings
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/lib/elasticsearch/extensions/documents/version.rb

@@ -1,7 +1,7 @@
 module Elasticsearch
   module Extensions
     module Documents
-      VERSION = "0.1.0"
+      VERSION = "1.0.0"
     end
   end
 end

data/spec/elasticsearch/extensions/documents/aliased_index_store_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+module Elasticsearch
+  module Extensions
+    module Documents
+      describe AliasedIndexStore do
+
+        let(:client) { double(:client) }
+        let(:storage) { double(:storage) }
+        subject(:store) { described_class.new(client: client, storage: storage) }
+
+        describe "#index" do
+          it "tells the client to index using a write alias" do
+            expect(client).to receive(:index).with({ foo: :bar, index: "test_index_write" })
+            store.index(foo: :bar)
+          end
+        end
+
+        describe "#delete" do
+          it "tells the client to delete a document using the write alias" do
+            expect(client).to receive(:delete).with({ id: 42, index: "test_index_write"})
+            store.delete(id: 42)
+          end
+        end
+
+        describe "#search" do
+          it "tells the client to search from the read alias" do
+            expect(client).to receive(:search).with({ foo: :bar,  index: "test_index_read"})
+            store.search(foo: :bar)
+          end
+        end
+
+        describe "#refresh" do
+          it "tells the client indices to refresh the read alias" do
+            indices = double(:indices)
+            client.stub(:indices).and_return(indices)
+            expect(indices).to receive(:refresh).with(index: "test_index_read")
+            store.refresh
+          end
+        end
+
+        describe "#reindex" do
+          let(:indices) { double(:indices) }
+          before(:each) do
+            allow(store).to receive(:indices_for_alias).and_return(["test_index_old"])
+            allow(indices).to receive(:update_aliases)
+            allow(storage).to receive(:create_index)
+            allow(storage).to receive(:drop_index)
+            client.stub(:indices).and_return(indices)
+            time = double(:time, now: self, strftime: "timestamp")
+            Time.stub(:now).and_return(time)
+          end
+
+          it "creates a new index with a timestamp appended to the name" do
+            expect(storage).to receive(:create_index).with("test_index_timestamp")
+            store.reindex
+          end
+
+          it "points the write alias to the newly created index" do
+            swap_args = {
+              alias: "test_index_write",
+              old:   "test_index_old",
+              new:   "test_index_timestamp",
+            }
+
+            expect(store).to receive(:swap_index_alias).with(swap_args)
+            expect(store).to receive(:swap_index_alias)
+
+            store.reindex
+          end
+
+          it "points the read alias to the newly created index" do
+            swap_args = {
+              alias: "test_index_read",
+              old:   "test_index_old",
+              new:   "test_index_timestamp",
+            }
+
+            expect(store).to receive(:swap_index_alias).with(swap_args)
+            expect(store).to receive(:swap_index_alias)
+
+            store.reindex
+          end
+
+          it "calls a given block to index the documents" do
+            documents = double(:documents)
+            expect(store).to receive(:bulk_index).with(documents)
+            store.reindex { |store| store.bulk_index(documents) }
+          end
+        end
+
+        describe "#bulk_index" do
+          let(:models) { [double(:model, id: 1, a: 1, b: 2), double(:model, id: 2, a: 3, b: 4)] }
+          let(:documents) { models.map { |m| TestDocumentsDocument.new(m) } }
+
+          it 'passes operations to the client bulk action' do
+            expected_body = {
+              body: [
+                {
+                  index: {
+                    _index: 'test_index_write',
+                    _type:  'documents_test',
+                    _id:    1,
+                    data:   { a: 1, b: 2 },
+                  }
+                },
+                {
+                  index: {
+                    _index: 'test_index_write',
+                    _type:  'documents_test',
+                    _id:    2,
+                    data:   { a: 3, b: 4 },
+                  },
+                }
+              ]
+            }
+            expect(client).to receive(:bulk).with(expected_body)
+            store.bulk_index(documents)
+          end
+        end
+
+        describe "#setup" do
+          let(:indices) { double(:indices) }
+          before(:each) do
+            time = double(:time, now: self, strftime: "1234")
+            allow(Time).to receive(:now).and_return(time)
+            allow(client).to receive(:indices).and_return(indices)
+            allow(store).to receive(:indices_for_alias).and_return(["test_index_1234"])
+            allow(indices).to receive(:put_alias)
+            allow(indices).to receive(:delete_alias)
+            allow(indices).to receive(:exists_alias).and_return(true)
+            allow(storage).to receive(:create_index)
+          end
+
+          it "resets the aliases to start clean" do
+            expect(indices).to receive(:delete_alias).with(index: "test_index_1234", name: "test_index_write")
+            expect(indices).to receive(:delete_alias).with(index: "test_index_1234", name: "test_index_read")
+            store.setup
+          end
+
+          it "creates a new timestamped index" do
+            timestamped_index = "test_index_1234"
+            expect(storage).to receive(:create_index).with(timestamped_index)
+            store.setup
+          end
+
+          it "sets the read and write aliases to the new index" do
+            expect(indices).to receive(:put_alias).with(index: "test_index_1234", name: "test_index_write")
+            expect(indices).to receive(:put_alias).with(index: "test_index_1234", name: "test_index_read")
+            store.setup
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/spec/elasticsearch/extensions/documents/direct_index_store_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+module Elasticsearch
+  module Extensions
+    module Documents
+      describe DirectIndexStore do
+
+        let(:client) { double(:client) }
+        let(:storage) { double(:storage) }
+        subject(:store) { described_class.new(client: client, storage: storage) }
+
+        describe '#reindex' do
+          before(:each) do
+            storage.stub(:create_index)
+            storage.stub(:drop_index)
+          end
+
+          context 'with the :force_create option' do
+            it 'drops the index if exists' do
+              expect(storage).to receive(:drop_index)
+              store.reindex(force_create: true)
+            end
+          end
+
+          context 'without the :force_create option' do
+            it 'does not drop the index if exists' do
+              expect(storage).not_to receive(:drop_index)
+              store.reindex
+            end
+          end
+
+          it 'creates a new index' do
+            expect(storage).to receive(:create_index)
+            store.reindex
+          end
+
+          it 'calls a given block to batch index the documents' do
+            documents = double(:documents)
+            expect(store).to receive(:bulk_index).with(documents)
+            store.reindex { |store| store.bulk_index(documents) }
+          end
+
+        end
+
+        describe "#bulk_index" do
+          let(:models) { [double(:model, id: 1, a: 1, b: 2), double(:model, id: 2, a: 3, b: 4)] }
+          let(:documents) { models.map { |m| TestDocumentsDocument.new(m) } }
+
+          it 'passes operations to the client bulk action' do
+            expected_body = {
+              body: [
+                {
+                  index: {
+                    _index: 'test_index',
+                    _type:  'documents_test',
+                    _id:    1,
+                    data:   { a: 1, b: 2 },
+                  }
+                },
+                {
+                  index: {
+                    _index: 'test_index',
+                    _type:  'documents_test',
+                    _id:    2,
+                    data:   { a: 3, b: 4 },
+                  },
+                }
+              ]
+            }
+            expect(client).to receive(:bulk).with(expected_body)
+            store.bulk_index(documents)
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/elasticsearch/extensions/documents/index_spec.rb

@@ -11,20 +11,19 @@ module Elasticsearch
       end
 
       describe Index do
-        let(:client) { double(:client) }
+        let(:adapter) { double(:adapter) }
         let(:model) { double(:model, id: 1) }
         let(:document) { TestDocument.new(model) }
-        subject(:index) { Index.new(client) }
+        subject(:index) { Index.new(adapter) }
 
         describe '#index' do
           it 'adds or replaces a document in the search index' do
             payload = {
-              index: 'test_index',
               type: 'test_doc',
               id: 1,
               body: {valueA: :a, valueB: :b}
             }
-            expect(client).to receive(:index).with(payload)
+            expect(adapter).to receive(:index).with(payload)
             index.index document
           end
         end
@@ -32,11 +31,10 @@ module Elasticsearch
         describe '#delete' do
           it 'removes a document from the search index' do
             payload = {
-              index: 'test_index',
               type: 'test_doc',
               id: 1,
             }
-            expect(client).to receive(:delete).with(payload)
+            expect(adapter).to receive(:delete).with(payload)
             index.delete document
           end
         end
@@ -44,7 +42,6 @@ module Elasticsearch
         describe '#search' do
           let(:query_params) do
             {
-              index: 'test_index',
               query: {
                 query_string: "search term",
                 analyzer:     "snowball",
@@ -58,7 +55,7 @@ module Elasticsearch
                 "total" => 4000,
                 "max_score" => 4.222,
                 "hits" => [
-                  {"_index" => "test_index",
+                  {
                     "_type"  => "user",
                     "_id"    => 42,
                     "_score" => 4.222,
@@ -71,23 +68,21 @@ module Elasticsearch
 
           let(:query) { double(:query, as_hash: query_params) }
 
-          it 'passes on the query request body to the client' do
-            expect(client).to receive(:search).with(query_params)
+          it 'passes on the query request body to the adapter' do
+            expect(adapter).to receive(:search).with(query_params)
             index.search query
           end
 
           it 'returns a Hashie::Mash instance' do
-            expect(client).to receive(:search).with(query_params).and_return(response)
+            adapter.stub(:search).and_return(response)
             response = index.search(query)
             response.should be_kind_of Hashie::Mash
           end
         end
 
         describe '#refresh' do
-          it 'delegates to the client#indices' do
-            indices = double(:indices, refresh: true)
-            client.stub(:indices).and_return(indices)
-            expect(indices).to receive(:refresh).with(index: 'test_index')
+          it 'delegates to the adapter' do
+            expect(adapter).to receive(:refresh)
             index.refresh
           end
         end

data/spec/elasticsearch/extensions/documents/storage_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module Elasticsearch
+  module Extensions
+    module Documents
+      describe Storage do
+
+        let(:indices) { double(:indices) }
+        let(:client) { double(:client, indices: indices) }
+        subject(:storage) { described_class.new(client: client) }
+
+        describe '#create_index' do
+          it 'creates the index if it does not exist' do
+            expected_client_params = {
+              index: 'test_index',
+              body:  {
+                settings: :fake_settings,
+                mappings: :fake_mappings,
+              }
+            }
+            indices.stub(:exists).and_return(false)
+            expect(indices).to receive(:create).with(expected_client_params)
+            storage.create_index('test_index')
+          end
+
+          it 'does not create the index if it exists' do
+            indices.stub(:exists).and_return(true)
+            expect(indices).not_to receive(:create)
+            storage.create_index('test_index')
+          end
+        end
+
+        describe '#drop_index' do
+          it 'drops the index if it exists' do
+            indices.stub(:exists).and_return(true)
+            expect(indices).to receive(:delete)
+            storage.drop_index('test_index')
+          end
+
+          it 'does not drop the index if it does not exist' do
+            indices.stub(:exists).and_return(false)
+            expect(indices).not_to receive(:delete)
+            storage.drop_index('test_index')
+          end
+        end
+
+        describe '#index_exists?' do
+          it 'delegates to the client indices' do
+            expect(indices).to receive(:exists).with(index: 'test_index')
+            storage.index_exists?('test_index')
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/spec/test_env.rb

@@ -0,0 +1,19 @@
+Elasticsearch::Extensions::Documents.configure do |config|
+  config.index_name = 'documents_test'
+  config.settings   = {}
+  config.mappings   = {}
+  config.client.url = 'http://localhost:9200'
+end
+
+class TestDocumentsDocument < Elasticsearch::Extensions::Documents::Document
+  indexes_as_type :documents_test
+
+  def as_hash
+    {
+      a: object.a,
+      b: object.b,
+    }
+  end
+end
+
+

metadata

@@ -1,83 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: elasticsearch-documents
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Ryan Houston
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-15 00:00:00.000000000 Z
+date: 2015-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: elasticsearch
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: hashie
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Define mappings to turn model instances into indexable search documents
@@ -87,9 +101,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -97,19 +111,24 @@ files:
 - elasticsearch-documents.gemspec
 - lib/elasticsearch-documents.rb
 - lib/elasticsearch/extensions/documents.rb
+- lib/elasticsearch/extensions/documents/aliased_index_store.rb
+- lib/elasticsearch/extensions/documents/direct_index_store.rb
 - lib/elasticsearch/extensions/documents/document.rb
 - lib/elasticsearch/extensions/documents/index.rb
-- lib/elasticsearch/extensions/documents/indexer.rb
 - lib/elasticsearch/extensions/documents/queryable.rb
+- lib/elasticsearch/extensions/documents/storage.rb
 - lib/elasticsearch/extensions/documents/utils.rb
 - lib/elasticsearch/extensions/documents/version.rb
+- spec/elasticsearch/extensions/documents/aliased_index_store_spec.rb
+- spec/elasticsearch/extensions/documents/direct_index_store_spec.rb
 - spec/elasticsearch/extensions/documents/document_spec.rb
 - spec/elasticsearch/extensions/documents/index_spec.rb
-- spec/elasticsearch/extensions/documents/indexer_spec.rb
 - spec/elasticsearch/extensions/documents/queryable_spec.rb
+- spec/elasticsearch/extensions/documents/storage_spec.rb
 - spec/elasticsearch/extensions/documents/utils_spec.rb
 - spec/elasticsearch/extensions/documents_spec.rb
 - spec/spec_helper.rb
+- spec/test_env.rb
 homepage: http://github.com/RyanHouston/elasticsearch-documents
 licenses:
 - MIT
@@ -120,25 +139,28 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A service wrapper to manage elasticsearch index documents
 test_files:
+- spec/elasticsearch/extensions/documents/aliased_index_store_spec.rb
+- spec/elasticsearch/extensions/documents/direct_index_store_spec.rb
 - spec/elasticsearch/extensions/documents/document_spec.rb
 - spec/elasticsearch/extensions/documents/index_spec.rb
-- spec/elasticsearch/extensions/documents/indexer_spec.rb
 - spec/elasticsearch/extensions/documents/queryable_spec.rb
+- spec/elasticsearch/extensions/documents/storage_spec.rb
 - spec/elasticsearch/extensions/documents/utils_spec.rb
 - spec/elasticsearch/extensions/documents_spec.rb
 - spec/spec_helper.rb
+- spec/test_env.rb

data/lib/elasticsearch/extensions/documents/indexer.rb

@@ -1,63 +0,0 @@
-module Elasticsearch
-  module Extensions
-    module Documents
-      class Indexer
-        attr_reader :client, :config
-
-        def initialize(options = {})
-          @client = options.fetch(:client) { Documents.client }
-          @config = options.fetch(:config) { Documents.configuration }
-        end
-
-        def drop_index
-          client.indices.delete(index: config.index_name) if index_exists?
-        end
-
-        def index_exists?
-          client.indices.exists(index: config.index_name)
-        end
-
-        def create_index
-          client.indices.create(index: config.index_name, body: create_index_body) unless index_exists?
-        end
-
-        def create_index_body
-          {}.tap do |body|
-            body[:settings] = config.settings if config.settings
-            body[:mappings] = config.mappings if config.mappings
-          end
-        end
-
-        def reindex(options = {}, &block)
-          force_create = options.fetch(:force_create) { false }
-
-          drop_index if force_create
-          create_index
-
-          block.call(self) if block_given?
-        end
-
-        def bulk_index(documents)
-          client.bulk body: bulk_index_operations(documents)
-        end
-
-        def bulk_index_operations(documents)
-          documents.collect { |document| bulk_index_operation_hash(document) }
-        end
-
-        def bulk_index_operation_hash(document)
-          {
-            index: {
-              _index: config.index_name,
-              _type:  document.class.type,
-              _id:    document.id,
-              data:   document.as_hash,
-            }
-          }
-        end
-
-      end
-    end
-  end
-end
-

data/spec/elasticsearch/extensions/documents/indexer_spec.rb

@@ -1,122 +0,0 @@
-require 'spec_helper'
-
-module Elasticsearch
-  module Extensions
-    module Documents
-      describe Indexer do
-
-        let(:indices) { double(:indices) }
-        let(:client) { double(:client, indices: indices) }
-        subject(:indexer) { Indexer.new(client: client) }
-
-        describe '#create_index' do
-          it 'creates the index if it does not exist' do
-            expected_client_params = {
-              index: 'test_index',
-              body:  {
-                settings: :fake_settings,
-                mappings: :fake_mappings,
-              }
-            }
-            indices.stub(:exists).and_return(false)
-            expect(indices).to receive(:create).with(expected_client_params)
-            indexer.create_index
-          end
-
-          it 'does not create the index if it exists' do
-            indices.stub(:exists).and_return(true)
-            expect(indices).not_to receive(:create)
-            indexer.create_index
-          end
-        end
-
-        describe '#drop_index' do
-          it 'drops the index if it exists' do
-            indices.stub(:exists).and_return(true)
-            expect(indices).to receive(:delete)
-            indexer.drop_index
-          end
-
-          it 'does not drop the index if it does not exist' do
-            indices.stub(:exists).and_return(false)
-            expect(indices).not_to receive(:delete)
-            indexer.drop_index
-          end
-        end
-
-        describe '#index_exists?' do
-          it 'delegates to the client indices' do
-            expect(indices).to receive(:exists).with(index: 'test_index')
-            indexer.index_exists?
-          end
-        end
-
-        describe '#bulk_index' do
-          let(:models) { [double(:model, id: 1, a: 1, b: 2), double(:model, id: 2, a: 3, b: 4)] }
-          let(:documents) { models.map { |m| TestDocumentsDocument.new(m) } }
-
-          it 'passes operations to the client bulk action' do
-            expected_body = {
-              body: [
-                {
-                  index: {
-                    _index: 'test_index',
-                    _type:  'documents_test',
-                    _id:    1,
-                    data:   { a: 1, b: 2 },
-                  }
-                },
-                {
-                  index: {
-                    _index: 'test_index',
-                    _type:  'documents_test',
-                    _id:    2,
-                    data:   { a: 3, b: 4 },
-                  },
-                }
-              ]
-            }
-            expect(client).to receive(:bulk).with(expected_body)
-            indexer.bulk_index(documents)
-          end
-        end
-
-        describe '#reindex' do
-
-          context 'with the :force_create option' do
-            it 'drops the index if exists' do
-              indices.stub(:exists).and_return(true)
-              expect(indexer).to receive(:drop_index)
-              indexer.reindex(force_create: true)
-            end
-          end
-
-          context 'without the :force_create option' do
-            it 'does not drop the index if exists' do
-              indices.stub(:exists).and_return(true)
-              expect(indexer).not_to receive(:drop_index)
-              indexer.reindex
-            end
-          end
-
-          it 'creates a new index' do
-            indices.stub(:exists).and_return(false)
-            expect(indexer).to receive(:create_index)
-            indexer.reindex
-          end
-
-          it 'calls a given block to batch index the documents' do
-            indexer.stub(:drop_index)
-            indexer.stub(:create_index)
-            documents = double(:documents)
-            expect(indexer).to receive(:bulk_index).with(documents)
-            indexer.reindex { |indexer| indexer.bulk_index(documents) }
-          end
-
-        end
-
-      end
-    end
-  end
-end
-