elastic_search_framework 1.4.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39f01fc19a6b4b23c55c54b9c59441ebc4f565db4365096c00031b8e0d28bd46
-  data.tar.gz: 9a050c4f8a88f6faf6348e01c987999e6fe20cac33058c07b66e11b267641d21
+  metadata.gz: 3cb32d84eb11d74afb4b32b129fc7b6fb3654714ffc8cc68a22837641437c92a
+  data.tar.gz: bddf4744857f12fcb44272813c6c644b373c32029c46ae470f17b239e3279762
 SHA512:
-  metadata.gz: 70dc6b3b99fb07405ecf51256393e5dc5534793960197a19f701f85eb28af5ad8fe53723089f009b3e6eecc26b0b26295a37c970c280463188dfdec5d478a23a
-  data.tar.gz: 1c356af13948e1d11e3011075bd4095eb9fa6c410558708278aabf89c0d3c42e90403eb5a94fcb8d8801570b6cd94e6a3663fc42f15817c716270784482722c0
+  metadata.gz: a7606703ced3bd3bf8e47312e408a687c45fdee2362a19d92cd007782b2748d9b1fc5bfa8d998d67040884697236c976d7c128eb4021173a758a713b9b2e725d
+  data.tar.gz: 721beafb796c691392c037b4651f3f51ea29ab24ce4d1b047fb8ade55887356c15cd4fb85af807125364382c5c387467ef466c23526f037ae06b6378354b287b

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

@@ -1,15 +1,20 @@
 module ElasticSearchFramework
   module Index
-    def index(name:, shards: nil)
+    attr_accessor :index_settings
+
+    def index(name:, version: nil)
       unless instance_variable_defined?(:@elastic_search_index_def)
-        instance_variable_set(:@elastic_search_index_def, {
-            name: "#{name}", shards: shards
-        })
+        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} | Shards: #{shards}.")
+        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)
@@ -41,8 +46,7 @@ module ElasticSearchFramework
         ElasticSearchFramework.logger.debug { "[#{self.class}] - Index already exists."}
         return
       end
-
-      payload = create_payload(description: description, mappings: mappings)
+      payload = create_payload
 
       put(payload: payload)
     end
@@ -101,27 +105,26 @@ module ElasticSearchFramework
       is_valid_response?(response.code) || Integer(response.code) == 404
     end
 
-    def create_payload(description:, mappings:)
-      payload = {}
+    def settings(name:, type: nil, value:)
+      self.index_settings = {} if index_settings.nil?
+      index_settings[name] = {} if index_settings[name].nil?
+      return index_settings[name][type] = value if type
+      index_settings[name] = value
+    end
 
-      if description[:shards] != nil
-        payload[:settings] = {
-          number_of_shards: Integer(description[:shards])
-        }
-      end
+    def create_payload
+      payload = { }
+      payload[:settings] = index_settings unless index_settings.nil?
 
-      if mappings.keys.length > 0
+      unless mappings.keys.empty?
         payload[:mappings] = {}
 
         mappings.keys.each do |name|
-          payload[:mappings][name] = {
-              properties: {}
-          }
+          payload[:mappings][name] = { properties: {} }
           mappings[name].keys.each do |field|
             payload[:mappings][name][:properties][field] = mappings[name][field]
           end
         end
-
       end
 
       payload
@@ -162,7 +165,7 @@ module ElasticSearchFramework
     end
 
     def repository
-      ElasticSearchFramework::Repository.new
+      @repository ||= ElasticSearchFramework::Repository.new
     end
 
     def get_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:)
+      indexes.each do |index|
+        repository.set(entity: item, index: index[:klass], type: 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 = '1.4.0'
+  VERSION = '2.3.0'
 end

data/spec/elastic_search_framework/index_alias_spec.rb

@@ -0,0 +1,144 @@
+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
+    it 'should call set on the repository for each index of the alias' do
+      expect(ExampleIndexAlias.repository).to receive(:set).with(entity: item, index: ExampleIndex, type: type).once
+      expect(ExampleIndexAlias.repository).to receive(:set).with(entity: item, index: ExampleIndex2, type: type).once
+      ExampleIndexAlias.put_item(type: type, item: item)
+    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

@@ -5,7 +5,6 @@ RSpec.describe ElasticSearchFramework::Index do
       expect(ExampleIndex.description[:name]).to eq 'example_index'
       expect(ExampleIndex.description[:id]).to eq :id
       expect(ExampleIndexWithId.description[:id]).to eq :number
-      expect(ExampleIndexWithShard.description[:shards]).to eq 1
     end
   end
 
@@ -16,7 +15,7 @@ RSpec.describe ElasticSearchFramework::Index do
       it 'raises an index error' do
         expect { ExampleIndex.index(name: 'test') }.to raise_error(
           ElasticSearchFramework::Exceptions::IndexError,
-          "[Class] - Duplicate index description. Name: test | Shards: ."
+          '[Class] - Duplicate index description. Name: test.'
         )
       end
     end
@@ -64,6 +63,44 @@ RSpec.describe ElasticSearchFramework::Index do
     end
   end
 
+  describe '#analysis' do
+    context 'when analysis is nil' do
+      before { ExampleIndex.delete if ExampleIndex.exists? }
+
+      it 'does not add analysis to the index' do
+        ExampleIndex.create
+        expect(ExampleIndexWithSettings.get.dig('example_index', 'settings', 'index', 'analysis')).to be_nil
+      end
+    end
+
+    context 'when analysis is not nil' do
+      before { ExampleIndexWithSettings.delete if ExampleIndexWithSettings.exists? }
+      let(:expected) do
+        {
+          'normalizer' => {
+            'custom_normalizer' => {
+              'filter' => ['lowercase'],
+              'type' => 'custom'
+            }
+          },
+          'analyzer' => {
+            'custom_analyzer' => {
+              'filter' => ['lowercase'],
+              'type' => 'custom',
+              'tokenizer' => 'standard'
+            }
+          }
+        }
+      end
+
+      it 'adds analysis to the index' do
+        ExampleIndexWithSettings.create
+        expect(ExampleIndexWithSettings.get.dig('example_index', 'settings', 'index', 'number_of_shards')).to eq('1')
+        expect(ExampleIndexWithSettings.get.dig('example_index', 'settings', 'index', 'analysis')).to eq(expected)
+      end
+    end
+  end
+
   describe '#valid?' do
     context 'for a valid index definition' do
       it 'should return true' do
@@ -239,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
 

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

@@ -4,7 +4,6 @@ class ExampleIndex
   index name: 'example_index'
 
   mapping name: 'default', field: :name, type: :keyword, index: true
-
 end
 
 class ExampleIndexWithId
@@ -15,16 +14,20 @@ class ExampleIndexWithId
   id :number
 
   mapping name: 'default', field: :name, type: :keyword, index: true
-
 end
 
-class ExampleIndexWithShard
+class ExampleIndexWithSettings
   extend ElasticSearchFramework::Index
 
-  index name: 'example_index', shards: 1
+  index name: 'example_index'
 
-  mapping name: 'default', field: :name, type: :keyword, index: true
+  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
 
 class InvalidExampleIndex

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: 1.4.0
+  version: 2.3.0
 platform: ruby
 authors:
 - vaughanbrittonsage
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-25 00:00:00.000000000 Z
+date: 2021-05-05 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.