elastic_search_framework 2.0.0 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab871a0e3beb296aaf8fbebc1c5c558c235fdbfd6a651f68ed74b7ace457da33
-  data.tar.gz: a19a5887d13c308852540302b805243eea991886cb72fe3384a36cc34c4f3ced
+  metadata.gz: 660bab65bf91d16e1788d6f43c47e979ab70d6367b6d964c5db5edb2fd94405e
+  data.tar.gz: 6132de6d0f951d36382e1d5023eb1b22240b66df004192f291434dae80284ff4
 SHA512:
-  metadata.gz: 1f18004a91a131eced9812a7bd1049315c4800ed4afbbe5098bb0848a0b49157337b65da01d201b05524fbf915beb92d3f8d3396b990fb79ad6761c20ed620bb
-  data.tar.gz: 699835d74cf0c4eb6331cf336ab8191e76d0cdd33243a73f9c565647b3b74fd5a7d58c1a1ae914629d700b74a42b5e748e28b62f78cd46f215faeaa2822755a8
+  metadata.gz: 35187a0efc4484e04f90db902db59fe7f599e83986ff16621c8b554bcc35c0d54167fc8663e11bb53d8048088707e31bf3fc191f5dcb970eaa244ebe7daeed7b
+  data.tar.gz: 82da0e555366738552a4bb4c522e0c6a4d31d83e82e3f4774851d2fc0ac72f291bcf351aa0e2012e31cfaf3058be8b9b1d1cacf8750ec85da5b84db72b89e5f9

data/lib/elastic_search_framework.rb

@@ -8,6 +8,7 @@ require_relative 'elastic_search_framework/logger'
 require_relative 'elastic_search_framework/exceptions'
 require_relative 'elastic_search_framework/repository'
 require_relative 'elastic_search_framework/index'
+require_relative 'elastic_search_framework/index_alias'
 require_relative 'elastic_search_framework/query'
 
 module ElasticSearchFramework

data/lib/elastic_search_framework/index.rb

@@ -2,14 +2,19 @@ module ElasticSearchFramework
   module Index
     attr_accessor :index_settings
 
-    def index(name:)
+    def index(name:, version: nil)
       unless instance_variable_defined?(:@elastic_search_index_def)
-        instance_variable_set(:@elastic_search_index_def, name: "#{name}")
+        instance_variable_set(:@elastic_search_index_def, name: "#{name}#{version}")
+        instance_variable_set(:@elastic_search_index_version, version: version) unless version.nil?
       else
         raise ElasticSearchFramework::Exceptions::IndexError.new("[#{self.class}] - Duplicate index description. Name: #{name}.")
       end
     end
 
+    def version
+      instance_variable_defined?(:@elastic_search_index_version) ? instance_variable_get(:@elastic_search_index_version) : 0
+    end
+
     def id(field)
       unless instance_variable_defined?(:@elastic_search_index_id)
         instance_variable_set(:@elastic_search_index_id, field)
@@ -102,11 +107,9 @@ module ElasticSearchFramework
 
     def settings(name:, type: nil, value:)
       self.index_settings = {} if index_settings.nil?
-      index_settings[name] = if type
-                               { type => value }
-                             else
-                               value
-                             end
+      index_settings[name] = {} if index_settings[name].nil?
+      return index_settings[name][type] = value if type
+      index_settings[name] = value
     end
 
     def create_payload
@@ -162,15 +165,15 @@ module ElasticSearchFramework
     end
 
     def repository
-      ElasticSearchFramework::Repository.new
+      @repository ||= ElasticSearchFramework::Repository.new
     end
 
     def get_item(id:, type: 'default')
       repository.get(index: self, id: id, type: type)
     end
 
-    def put_item(type: 'default', item:)
-      repository.set(entity: item, index: self, type: type)
+    def put_item(type: 'default', item:, op_type: 'index')
+      repository.set(entity: item, index: self, type: type, op_type: op_type)
     end
 
     def delete_item(id:, type: 'default')

data/lib/elastic_search_framework/index_alias.rb

@@ -0,0 +1,146 @@
+module ElasticSearchFramework
+  module IndexAlias
+    def index(klass, active:)
+      unless instance_variable_defined?(:@elastic_search_indexes)
+        instance_variable_set(:@elastic_search_indexes, [])
+      end
+      indexes = self.instance_variable_get(:@elastic_search_indexes)
+      indexes << {klass: klass, active: active}
+      instance_variable_set(:@elastic_search_indexes, indexes)
+    end
+
+    def indexes
+      self.instance_variable_get(:@elastic_search_indexes)
+    end
+
+    def name(name)
+      unless instance_variable_defined?(:@elastic_search_index_alias_name)
+        instance_variable_set(:@elastic_search_index_alias_name, "#{name}")
+      else
+        raise ElasticSearchFramework::Exceptions::IndexError.new("[#{self.class}] - Duplicate index alias name: #{name}.")
+      end
+    end
+
+    def valid?
+      indexes.select { |i| i[:active] == true }.length == 1
+    end
+
+    def create
+      if !valid?
+        raise ElasticSearchFramework::Exceptions::IndexError.new("[#{self.class}] - Invalid Index alias.")
+      end
+
+      uri = URI("#{host}/_aliases")
+
+      payload = {
+        actions: [],
+      }
+
+      indexes.each do |index|
+        action = nil
+        if exists?(index: index[:klass])
+          action = "remove" if !index[:active]
+        else
+          action = "add" if index[:active]
+        end
+        next if action.nil?
+
+        payload[:actions] << {action => {index: index[:klass].full_name, alias: self.full_name}}
+      end
+
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request.body = JSON.dump(payload)
+      request.content_type = "application/json"
+
+      response = repository.with_client do |client|
+        client.request(request)
+      end
+
+      is_valid_response?(response.code) || Integer(response.code) == 404
+    end
+
+    def delete
+      uri = URI("#{host}/_all/_aliases/#{full_name}")
+
+      request = Net::HTTP::Delete.new(uri.request_uri)
+
+      response = repository.with_client do |client|
+        client.request(request)
+      end
+
+      is_valid_response?(response.code) || Integer(response.code) == 404
+    end
+
+    def exists?(index:)
+      uri = URI("#{host}/#{index.full_name}/_alias/#{full_name}")
+
+      request = Net::HTTP::Get.new(uri.request_uri)
+
+      response = repository.with_client do |client|
+        client.request(request)
+      end
+
+      return false if response.code == "404"
+
+      result = nil
+      if is_valid_response?(response.code)
+        result = JSON.parse(response.body)
+      end
+
+      return true if !result.nil? && result[index.full_name]["aliases"] != nil
+      return false
+    end
+
+    def is_valid_response?(code)
+      [200, 201, 202].include?(Integer(code))
+    end
+
+    def full_name
+      name = instance_variable_get(:@elastic_search_index_alias_name)
+      if ElasticSearchFramework.namespace != nil
+        "#{ElasticSearchFramework.namespace}#{ElasticSearchFramework.namespace_delimiter}#{name.downcase}"
+      else
+        name.downcase
+      end
+    end
+
+    def description
+      index = indexes.last[:klass]
+      hash = index.instance_variable_get(:@elastic_search_index_def)
+      if index.instance_variable_defined?(:@elastic_search_index_id)
+        hash[:id] = index.instance_variable_get(:@elastic_search_index_id)
+      else
+        hash[:id] = :id
+      end
+      hash
+    end
+
+    def host
+      "#{ElasticSearchFramework.host}:#{ElasticSearchFramework.port}"
+    end
+
+    def repository
+      @repository ||= ElasticSearchFramework::Repository.new
+    end
+
+    def get_item(id:, type: "default")
+      repository.get(index: self, id: id, type: type)
+    end
+
+    def put_item(type: "default", item:, op_type: 'index')
+      indexes.each do |index|
+        repository.set(entity: item, index: index[:klass], type: type, op_type: op_type)
+      end
+    end
+
+    def delete_item(id:, type: "default")
+      indexes.each do |index|
+        repository.drop(index: index[:klass], id: id, type: type)
+      end
+    end
+
+    def query
+      ElasticSearchFramework::Query.new(index: self)
+    end
+  end
+end

data/lib/elastic_search_framework/repository.rb

@@ -1,8 +1,8 @@
 module ElasticSearchFramework
   class Repository
 
-    def set(index:, entity:, type: 'default')
-      uri = URI("#{host}/#{index.full_name}/#{type.downcase}/#{get_id_value(index: index, entity: entity)}")
+    def set(index:, entity:, type: 'default', op_type: 'index')
+      uri = URI("#{host}/#{index.full_name}/#{type.downcase}/#{get_id_value(index: index, entity: entity)}?op_type=#{op_type}")
       hash = hash_helper.to_hash(entity)
 
       request = Net::HTTP::Put.new(uri.request_uri)
@@ -13,12 +13,15 @@ module ElasticSearchFramework
         client.request(request)
       end
 
-      unless valid_response?(response.code)
+      if valid_response?(response.code)
+        return true
+      elsif op_type == 'create' && Integer(response.code) == 409
+        return true
+      else
         raise ElasticSearchFramework::Exceptions::IndexError.new(
             "An error occurred setting an index document. Response: #{response.body} | Code: #{response.code}"
         )
       end
-      return true
     end
 
     def get(index:, id:, type: 'default')
@@ -114,15 +117,15 @@ module ElasticSearchFramework
     end
 
     def idle_timeout
-      @idle_timeout ||= Integer(ENV['CONNECTION_IDLE_TIMEOUT'] ||  5)
+      @idle_timeout ||= Integer(ENV['CONNECTION_IDLE_TIMEOUT'] || 5)
     end
 
     def read_timeout
-      @read_timeout ||= Integer(ENV['CONNECTION_READ_TIMEOUT'] ||  5)
+      @read_timeout ||= Integer(ENV['CONNECTION_READ_TIMEOUT'] || 5)
     end
 
     def open_timeout
-      @read_timeout ||= Integer(ENV['CONNECTION_OPEN_TIMEOUT'] ||  1)
+      @open_timeout ||= Integer(ENV['CONNECTION_OPEN_TIMEOUT'] || 1)
     end
 
     def valid_response?(status)

data/lib/elastic_search_framework/version.rb

@@ -1,3 +1,3 @@
 module ElasticSearchFramework
-  VERSION = '2.0.0'
+  VERSION = '2.3.1'
 end

data/spec/elastic_search_framework/index_alias_spec.rb

@@ -0,0 +1,160 @@
+RSpec.describe ElasticSearchFramework::Index do
+  describe '#full_name' do
+    let(:namespace) { 'uat' }
+    let(:namespace_delimiter) { '.' }
+    before do
+      ElasticSearchFramework.namespace = namespace
+      ElasticSearchFramework.namespace_delimiter = namespace_delimiter
+    end
+    it 'should return the full index name including namespace and delimiter' do
+      expect(ExampleIndexAlias.full_name).to eq "#{ElasticSearchFramework.namespace}#{ElasticSearchFramework.namespace_delimiter}example"
+    end
+
+    context 'when the namespace is nil' do
+      before { ElasticSearchFramework.namespace = nil }
+
+      it 'returns the description name downcased' do
+        expect(ExampleIndexAlias.full_name).to eq 'example'
+      end
+    end
+  end
+
+  describe '#valid?' do
+    context 'for a valid index definition' do
+      it 'should return true' do
+        expect(ExampleIndexAlias.valid?).to be true
+      end
+    end
+    context 'for an invalid index definition' do
+      it 'should return true' do
+        expect(InvalidIndexAlias.valid?).to be false
+      end
+    end
+  end
+
+  describe '#create' do
+    context 'when alias is valid and does not exist' do
+      before do
+        ExampleIndexAlias.delete
+        ExampleIndex.delete if ExampleIndex.exists?
+        ExampleIndex.create
+      end
+
+      it 'creates an alias for the active index' do
+        expect(ExampleIndexAlias.exists?(index: ExampleIndex)).to be false
+        ExampleIndexAlias.create
+        expect(ExampleIndexAlias.exists?(index: ExampleIndex)).to be true
+      end
+
+      after do
+        ExampleIndexAlias.delete
+        ExampleIndex.delete
+      end
+    end
+
+    context 'when alias is not valid' do
+      before { allow(ExampleIndexAlias).to receive(:valid?).and_return(false) }
+
+      it 'raises an error' do
+        expect(ExampleIndexAlias.exists?(index: ExampleIndex)).to be false
+        expect { ExampleIndexAlias.create }.to raise_error(
+          ElasticSearchFramework::Exceptions::IndexError
+        )
+      end
+    end
+
+    context 'when alias is valid but already exists' do
+      before do
+        ExampleIndex.delete if ExampleIndex.exists?
+        ExampleIndex.create
+        ExampleIndexAlias.create
+      end
+
+      it 'does not try to create a new alias' do
+        ExampleIndexAlias.create
+      end
+
+      after do
+        ExampleIndexAlias.delete
+        ExampleIndex.delete
+      end
+    end
+
+    context 'when alias is valid and does not exist and requires updating' do
+      before do
+        ExampleIndexAlias.delete
+        ExampleIndex.delete if ExampleIndex.exists?
+        ExampleIndex2.delete if ExampleIndex2.exists?
+        ExampleIndex.create
+        ExampleIndex2.create
+        ExampleIndexAlias.create
+      end
+
+      it 'modifies the alias to the active index' do
+        expect(ExampleIndexAlias.exists?(index: ExampleIndex)).to be true
+        ExampleIndexAlias2.create
+        expect(ExampleIndexAlias.exists?(index: ExampleIndex)).to be false
+        expect(ExampleIndexAlias2.exists?(index: ExampleIndex2)).to be true
+      end
+
+      after do
+        ExampleIndexAlias.delete
+        ExampleIndex.delete
+        ExampleIndex2.delete
+      end
+    end
+  end
+
+  describe '#get_item' do
+    let(:id) { 10 }
+    let(:type) { 'default' }
+    it 'should call get on the repository' do
+      expect(ExampleIndexAlias.repository).to receive(:get).with(index: ExampleIndexAlias, id: id, type: type).once
+      ExampleIndexAlias.get_item(id: id, type: type)
+    end
+  end
+
+  describe '#put_item' do
+    let(:id) { 10 }
+    let(:type) { 'default' }
+    let(:item) do
+      TestItem.new.tap do |i|
+        i.id = id
+        i.name = 'abc'
+        i.timestamp = Time.now.to_i
+        i.number = 5
+      end
+    end
+    context 'without specifying op_type' do
+      it 'should call set on the repository for each index of the alias with default op_type (index)' do
+        expect(ExampleIndexAlias.repository).to receive(:set).with(entity: item, index: ExampleIndex, type: type, op_type: 'index').once
+        expect(ExampleIndexAlias.repository).to receive(:set).with(entity: item, index: ExampleIndex2, type: type, op_type: 'index').once
+        ExampleIndexAlias.put_item(type: type, item: item)
+      end
+    end
+
+    context 'with specified op_type' do
+      it 'should call set on the repository for each index of the alias with supplied op_type (index)' do
+        expect(ExampleIndexAlias.repository).to receive(:set).with(entity: item, index: ExampleIndex, type: type, op_type: 'index').once
+        expect(ExampleIndexAlias.repository).to receive(:set).with(entity: item, index: ExampleIndex2, type: type, op_type: 'index').once
+        ExampleIndexAlias.put_item(type: type, item: item, op_type: 'index')
+      end
+
+      it 'should call set on the repository for each index of the alias with supplied op_type (create)' do
+        expect(ExampleIndexAlias.repository).to receive(:set).with(entity: item, index: ExampleIndex, type: type, op_type: 'create').once
+        expect(ExampleIndexAlias.repository).to receive(:set).with(entity: item, index: ExampleIndex2, type: type, op_type: 'create').once
+        ExampleIndexAlias.put_item(type: type, item: item, op_type: 'create')
+      end
+    end
+  end
+
+  describe '#delete_item' do
+    let(:id) { 10 }
+    let(:type) { 'default' }
+    it 'should call drop on the repository for each index of the alias' do
+      expect(ExampleIndexAlias.repository).to receive(:drop).with(index: ExampleIndex, id: id, type: type).once
+      expect(ExampleIndexAlias.repository).to receive(:drop).with(index: ExampleIndex2, id: id, type: type).once
+      ExampleIndexAlias.delete_item(id: id, type: type)
+    end
+  end
+end

data/spec/elastic_search_framework/index_spec.rb

@@ -82,6 +82,13 @@ RSpec.describe ElasticSearchFramework::Index do
               'filter' => ['lowercase'],
               'type' => 'custom'
             }
+          },
+          'analyzer' => {
+            'custom_analyzer' => {
+              'filter' => ['lowercase'],
+              'type' => 'custom',
+              'tokenizer' => 'standard'
+            }
           }
         }
       end
@@ -269,8 +276,8 @@ RSpec.describe ElasticSearchFramework::Index do
     it 'should return a ElasticSearchFramework::Repository instance' do
       expect(ExampleIndex.repository).to be_a(ElasticSearchFramework::Repository)
     end
-    it 'should return a unique ElasticSearchFramework::Repository instance' do
-      expect(ExampleIndex.repository).not_to eq ExampleIndex.repository
+    it 'should return the same ElasticSearchFramework::Repository instance for multiple calls' do
+      expect(ExampleIndex.repository).to eq ExampleIndex.repository
     end
   end
 
@@ -294,9 +301,24 @@ RSpec.describe ElasticSearchFramework::Index do
         i.number = 5
       end
     end
-    it 'should call set on the repository' do
-      expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:set).with(entity: item, index: ExampleIndex, type: type)
-      ExampleIndex.put_item(type: type, item: item)
+
+    context 'without specifying op_type' do
+      it 'should call set on the repository with default op_type (index)' do
+        expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:set).with(entity: item, index: ExampleIndex, op_type: 'index', type: type)
+        ExampleIndex.put_item(type: type, item: item)
+      end
+    end
+
+    context 'with specified op_type' do
+      it 'should call set on the repository with supplied op_type (index)' do
+        expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:set).with(entity: item, index: ExampleIndex, op_type: 'index', type: type)
+        ExampleIndex.put_item(type: type, item: item, op_type: 'index')
+      end
+
+      it 'should call set on the repository with supplied op_type (create)' do
+        expect_any_instance_of(ElasticSearchFramework::Repository).to receive(:set).with(entity: item, index: ExampleIndex, op_type: 'create', type: type)
+        ExampleIndex.put_item(type: type, item: item, op_type: 'create')
+      end
     end
   end
 

data/spec/elastic_search_framework/repository_spec.rb

@@ -63,22 +63,40 @@ RSpec.describe ElasticSearchFramework::Repository do
       ExampleIndexWithId.create
     end
 
-    it 'should create, read and delete an index document' do
-      subject.set(index: ExampleIndex, entity: item1)
-      subject.set(index: ExampleIndex, entity: item2)
-      subject.set(index: ExampleIndex, entity: item5)
-      index_item1 = subject.get(index: ExampleIndex, id: item1.id)
-      expect(index_item1[:id]).to eq item1.id
-      expect(index_item1[:name]).to eq item1.name
-      expect(index_item1[:timestamp]).to eq item1.timestamp
-      expect(index_item1[:number]).to eq item1.number
-      index_item2 = subject.get(index: ExampleIndex, id: item2.id)
-      expect(index_item2[:id]).to eq item2.id
-      expect(index_item2[:name]).to eq item2.name
-      expect(index_item2[:timestamp]).to eq item2.timestamp
-      expect(index_item2[:number]).to eq item2.number
-      subject.drop(index: ExampleIndex, id: item1.id)
-      expect(subject.get(index: ExampleIndex, id: item1.id)).to be_nil
+    context 'PUT with op_type: index' do
+      it 'should create, read and delete an index document' do
+        subject.set(index: ExampleIndex, entity: item1)
+        subject.set(index: ExampleIndex, entity: item1.tap { |i| i.timestamp += 100 })
+        subject.set(index: ExampleIndex, entity: item1.tap { |i| i.timestamp += 100 }, op_type: 'index')
+        subject.set(index: ExampleIndex, entity: item2)
+        subject.set(index: ExampleIndex, entity: item5)
+        index_item1 = subject.get(index: ExampleIndex, id: item1.id)
+        expect(index_item1[:id]).to eq item1.id
+        expect(index_item1[:name]).to eq item1.name
+        expect(index_item1[:timestamp]).to eq item1.timestamp
+        expect(index_item1[:number]).to eq item1.number
+        index_item2 = subject.get(index: ExampleIndex, id: item2.id)
+        expect(index_item2[:id]).to eq item2.id
+        expect(index_item2[:name]).to eq item2.name
+        expect(index_item2[:timestamp]).to eq item2.timestamp
+        expect(index_item2[:number]).to eq item2.number
+        subject.drop(index: ExampleIndex, id: item1.id)
+        expect(subject.get(index: ExampleIndex, id: item1.id)).to be_nil
+      end
+    end
+
+    context 'PUT with op_type: create' do
+      let!(:original_timestamp) { item1.timestamp }
+
+      it 'should not update item' do
+        subject.set(index: ExampleIndex, entity: item1)
+        subject.set(index: ExampleIndex, entity: item1.tap { |i| i.timestamp += 100 }, op_type: 'create')
+        index_item1 = subject.get(index: ExampleIndex, id: item1.id)
+        expect(index_item1[:id]).to eq item1.id
+        expect(index_item1[:name]).to eq item1.name
+        expect(index_item1[:timestamp]).to eq original_timestamp
+        expect(index_item1[:number]).to eq item1.number
+      end
     end
 
     after do

data/spec/example_index.rb

@@ -22,9 +22,11 @@ class ExampleIndexWithSettings
   index name: 'example_index'
 
   normalizer_value = { custom_normalizer: { type: 'custom', char_filter: [], filter: ['lowercase'] } }
+  analyzer_value = { custom_analyzer: { type: 'custom', tokenizer: 'standard', filter: %w(lowercase) } }
 
   settings name: :number_of_shards, value: 1
   settings name: :analysis, type: :normalizer, value: normalizer_value
+  settings name: :analysis, type: :analyzer, value: analyzer_value
   mapping name: 'default', field: :name, type: :keyword, index: true
 end
 

data/spec/example_index_2.rb

@@ -0,0 +1,31 @@
+class ExampleIndex2
+  extend ElasticSearchFramework::Index
+
+  index name: 'example_index', version: 2
+
+  mapping name: 'default', field: :name, type: :keyword, index: true
+end
+
+class ExampleIndexWithId2
+  extend ElasticSearchFramework::Index
+
+  index name: 'example_index', version: 2
+
+  id :number
+
+  mapping name: 'default', field: :name, type: :keyword, index: true
+end
+
+class ExampleIndexWithSettings2
+  extend ElasticSearchFramework::Index
+
+  index name: 'example_index', version: 2
+
+  normalizer_value = { custom_normalizer: { type: 'custom', char_filter: [], filter: ['lowercase'] } }
+  analyzer_value = { custom_analyzer: { type: 'custom', tokenizer: 'standard', filter: %w(lowercase) } }
+
+  settings name: :number_of_shards, value: 1
+  settings name: :analysis, type: :normalizer, value: normalizer_value
+  settings name: :analysis, type: :analyzer, value: analyzer_value
+  mapping name: 'default', field: :name, type: :keyword, index: true
+end

data/spec/example_index_alias.rb

@@ -0,0 +1,17 @@
+class ExampleIndexAlias
+  extend ElasticSearchFramework::IndexAlias
+
+  index ExampleIndex, active: true
+  index ExampleIndex2, active: false
+
+  name :example
+end
+
+class InvalidIndexAlias
+  extend ElasticSearchFramework::IndexAlias
+
+  index ExampleIndex, active: false
+  index ExampleIndex2, active: false
+
+  name :example
+end

data/spec/example_index_alias_2.rb

@@ -0,0 +1,8 @@
+class ExampleIndexAlias2
+  extend ElasticSearchFramework::IndexAlias
+
+  index ExampleIndex, active: false
+  index ExampleIndex2, active: true
+
+  name :example
+end

data/spec/spec_helper.rb

@@ -9,6 +9,9 @@ end
 require 'elastic_search_framework'
 require_relative '../spec/test_item.rb'
 require_relative '../spec/example_index'
+require_relative '../spec/example_index_2'
+require_relative '../spec/example_index_alias'
+require_relative '../spec/example_index_alias_2'
 require 'pry'
 
 RSpec.configure do |config|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elastic_search_framework
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.3.1
 platform: ruby
 authors:
 - vaughanbrittonsage
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-31 00:00:00.000000000 Z
+date: 2021-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -119,14 +119,19 @@ files:
 - lib/elastic_search_framework/exceptions.rb
 - lib/elastic_search_framework/exceptions/index_error.rb
 - lib/elastic_search_framework/index.rb
+- lib/elastic_search_framework/index_alias.rb
 - lib/elastic_search_framework/logger.rb
 - lib/elastic_search_framework/query.rb
 - lib/elastic_search_framework/repository.rb
 - lib/elastic_search_framework/version.rb
+- spec/elastic_search_framework/index_alias_spec.rb
 - spec/elastic_search_framework/index_spec.rb
 - spec/elastic_search_framework/query_spec.rb
 - spec/elastic_search_framework/repository_spec.rb
 - spec/example_index.rb
+- spec/example_index_2.rb
+- spec/example_index_alias.rb
+- spec/example_index_alias_2.rb
 - spec/spec_helper.rb
 - spec/test_item.rb
 homepage: https://github.com/sage/elastic_search_framework
@@ -148,8 +153,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: A lightweight framework to for working with elastic search.