es-elasticity 0.3.9 → 0.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b43991880f2556f0dfaa3e6a0a641fe21f39816
-  data.tar.gz: 25afec66923b407330c648fb767d9405cc1ec3cd
+  metadata.gz: b5d3a0524062086414be4b1e007baead644752fb
+  data.tar.gz: f94156960b946ae47439f0d0f66254686f6ff98f
 SHA512:
-  metadata.gz: ba981a87ef6b156d589c9f8c60505998a77b5cd6827c70af2f34719aa15c3306904288f9715713536d18570258c34b4332271bb7b11a3cd2eaae193fec58ba82
-  data.tar.gz: 0a6dabe8a4d45f85928e1bd5531a6d29dbc625115652a6029abe395f7506341458b40f14327cd166322f5d657b538549edb1859ab1eab42da8ce516074782b42
+  metadata.gz: 608ddfc31bcb487007447cb666b9a3476516c81c23baba6f239856b939e8ba6517939f7afef1a01040c6a27d5e66b0562da09b074ae5a9afe3a3533c1f8eba75
+  data.tar.gz: 035dd04cac5fa2bb1614037ca6126b859054d215fe97653c5f52bac0d1e9aa3f007821c7b6bebb21bbdcd41b887ef2b7a07ca5c0d6b65ca69a30a7b3a8e855e7

data/.travis.yml

@@ -6,6 +6,8 @@ rvm:
   - 2.1.2
   - 2.1.3
   - 2.1.4
+  - 2.2.2
+  - 2.2.3
 services:
   - elasticsearch
 env:

data/README.md

@@ -79,7 +79,7 @@ class Search::User < Elasticity::Document
       from: 0,
       size: 10,
       filter: {
-        { range: { birthdate: { gte: date.iso8601 }}},
+        range: { birthdate: { lte: date.iso8601 }},
       },
     }
 
@@ -173,6 +173,90 @@ adults = adults.active_record(User)
 
 For more information about the `active_record` method, read [ActiveRecord integration](#activerecord-integration).
 
+### Segmented Documents
+
+The idea of segmented documents is that documents of the same type/class can be distributed over separate segments, which are backed by separated indexes. This is good for manually sharding documents into their own indexes. For example, an application that supports multiple clients/organizations might want to separate the documents for each organization under separate indexes, making it easier to delete the data and isolate the documents.
+
+Using this feature is very easy and very similar to traditional documents. The only difference is that your document class should inherit from `Elasticity::SegmentedDocument`. Adjusting the definition that we had before:
+
+```ruby
+class Search::User < Elasticity::SegmentedDocument
+  configure do |c|
+    # Defines how the index will be named, the final name
+    # will depend on the stragy being used.
+    c.index_base_name = "users"
+
+    # Defines the document type that this class represents.
+    c.document_type = "user"
+
+    # Select which strategy should be used. AliasIndex uses two aliases
+    # in order to support hot remapping of indexes. This is the recommended
+    # strategy.
+    c.strategy = Elasticity::Strategies::AliasIndex
+
+    # Defines the mapping for this index/document_type.
+    c.mapping  = {
+      properties: {
+        name: { type: "string" },
+        birthdate: { type: "date" },
+      }
+    }
+  end
+
+  # Defines a search method.
+  def self.adults
+    date = Date.today - 21.years
+
+    # This is the query that will be submited to ES, same format ES would
+    # expect, translated to a Ruby hash, note the pagination params.
+    body = {
+      from: 0,
+      size: 10,
+      filter: {
+        range: { birthdate: { lte: date.iso8601 }},
+      },
+    }
+
+    # Creates a search object from the body and return it.
+    # The returned object # is a lazy evaluated search that behaves like a collection, being
+    # automatically triggered when data is iterated over.
+    self.search(body)
+  end
+
+  # All models automatically have the id attribute but you need to define the
+  # other accessors so that they can be set and get properly.
+  attr_accessor :name, :birthdate
+
+  # to_document is the only required method that needs to be implemented so an
+  # instance of this model can be indexed.
+  def to_document
+    {
+      name: self.name,
+      birthdate: self.birthdate.iso8601
+    }
+  end
+end
+```
+
+This class on itself can't be queried or manipulated directly. Trying to call the `adults` search method, one would get an error: `NoMethodError: undefined method 'search' for #<Class:0x007fd582933460>`. To be able to call any method you first need to define the segment that you want to use, which can easily be done by calling the method `segment`, which will return a class derived from the base class that contains all the available methods:
+
+```ruby
+users = Search::User.segment("doximity.com")
+users.create_index
+
+# users is a dynamically defined class that inherits from the Search::User class, 
+# therefore having all the necessary methods defined just properly.
+users           # => Search::User{"doximity.com"}
+users.class     # => Class
+users.ancestors # => [Search::User{"doximity.com"}, User, Elasticity::SegmentedDocument, ...]
+
+john = users.new(name: "John", birthdate: Date.civil(1985, 10, 31))
+john # => #<Search::User{"doximity.com"}:0x81a3ab6a0dea @name="John" @birthdate=Thu, 31 Oct 1985>
+john.update
+
+users.adults.to_a # => [#<Search::User{"doximity.com"}:0x819cc5a50cd5 @_id="AVCHLz5JyttLSz7M-tRI" @name="John" @birthdate="1985-10-31" @highlighted=nil>]
+```
+
 ### Strategies and Hot-remapping
 
 Strategies define how index creation and index operation happens on the lower level. Basically it define the structure that backs the document model. Currently, there are two strategies available: single-index and alias-index.

data/lib/elasticity.rb

@@ -10,7 +10,11 @@ require "elasticsearch"
 module Elasticity
   autoload :Bulk,               "elasticity/bulk"
   autoload :Config,             "elasticity/config"
+  autoload :IndexConfig,        "elasticity/index_config"
+  autoload :IndexMapper,        "elasticity/index_mapper"
+  autoload :BaseDocument,       "elasticity/base_document"
   autoload :Document,           "elasticity/document"
+  autoload :SegmentedDocument,  "elasticity/segmented_document"
   autoload :InstrumentedClient, "elasticity/instrumented_client"
   autoload :LogSubscriber,      "elasticity/log_subscriber"
   autoload :MultiSearch,        "elasticity/multi_search"

data/lib/elasticity/base_document.rb

@@ -0,0 +1,53 @@
+module Elasticity
+  class BaseDocument
+    include ::ActiveModel::Model
+
+    # Stores configuration for this class and all subclasses.
+    class_attribute :config
+
+    # Configure the given klass, changing default parameters and resetting
+    # some of the internal state.
+    def self.configure(&block)
+      self.config = IndexConfig.new(Elasticity.config, &block)
+    end
+
+    # Define common attributes for all documents
+    attr_accessor :_id, :highlighted
+
+    def attributes=(attributes)
+      attributes.each do |attr, value|
+        self.public_send("#{attr}=", value)
+      end
+    end
+
+    # Defines equality by comparing the ID and values of each instance variable.
+    def ==(other)
+      return false if other.nil?
+      return false if _id != other._id
+
+      instance_variables.all? do |ivar|
+        instance_variable_get(ivar) == other.instance_variable_get(ivar)
+      end
+    end
+
+    # IMPLEMENT
+    # Returns a hash with the attributes as they should be stored in the index.
+    # This will be stored as _source attributes on Elasticsearch.
+    def to_document
+      raise NotImplementedError, "to_document needs to be implemented for #{self.class}"
+    end
+
+    # Update this object on the index, creating or updating the document.
+    def update
+      self._id, @created = self.class.index_document(_id, to_document)
+    end
+
+    def delete
+      self.class.delete(self._id)
+    end
+
+    def created?
+      @created || false
+    end
+  end
+end

data/lib/elasticity/document.rb

@@ -1,196 +1,12 @@
 module Elasticity
-  class Document
-    include ::ActiveModel::Model
+  class Document < BaseDocument
+    IndexMapper.set_delegates(singleton_class, :mapper)
 
-    class NotConfigured < StandardError; end
+    private
 
-    Config = Struct.new(:index_base_name, :document_type, :mapping, :strategy)
-
-    # Configure the given klass, changing default parameters and resetting
-    # some of the internal state.
-    def self.configure
-      @config = Config.new
-      @config.strategy = Strategies::SingleIndex
-      yield(@config)
-    end
-
-    # Returns the stategy class being used.
-    # Check Elasticity::Strategies for more information.
-    def self.strategy
-      if @config.nil? || @config.strategy.nil?
-        raise NotConfigured, "#{self} has not been configured, make sure you call the configure method"
-      end
-
-      return @strategy if defined?(@strategy)
-
-      if namespace = Elasticity.config.namespace
-        index_base_name = "#{namespace}_#{@config.index_base_name}"
-      end
-
-      @strategy = @config.strategy.new(Elasticity.config.client, index_base_name, document_type)
-    end
-
-    # Document type
-    def self.document_type
-      if @config.nil? || @config.document_type.blank?
-        raise NotConfigured, "#{self} has not been configured, make sure you call the configure method"
-      end
-
-      @config.document_type
-    end
-
-    # Document type
-    def self.mapping
-      if @config.nil? || @config.mapping.blank?
-        raise NotConfigured, "#{self} has not been configured, make sure you call the configure method"
-      end
-
-      @config.mapping
-    end
-
-    # Creates the index for this document
-    def self.create_index
-      self.strategy.create_if_undefined(settings: Elasticity.config.settings, mappings: { document_type => mapping })
-    end
-
-    # Re-creates the index for this document
-    def self.recreate_index
-      self.strategy.recreate(settings: Elasticity.config.settings, mappings: { document_type => mapping })
-    end
-
-    # Deletes the index
-    def self.delete_index
-      self.strategy.delete
-    end
-
-    # Does the index exist?
-    def self.index_exists?
-      !self.strategy.missing?
-    end
-
-    # Gets the index name to be used when you need to reference the index somewhere.
-    # This depends on the strategy being used, but it always refers to the search index.
-    def self.ref_index_name
-      self.strategy.ref_index_name
-    end
-
-    # Remap
-    def self.remap!
-      self.strategy.remap(settings: Elasticity.config.settings, mappings: { document_type => mapping })
-    end
-
-    # Flushes the index, forcing any writes
-    def self.flush_index
-      self.strategy.flush
-    end
-
-    # Creates a instance of a document from a ElasticSearch hit data.
-    def self.from_hit(hit_data)
-      attrs = { _id: hit_data["_id"] }
-      attrs.merge!(hit_data["_source"]) if hit_data["_source"]
-
-      if hit_data["highlight"]
-        highlighted_attrs = attrs.dup
-        attrs_set = Set.new
-
-        hit_data["highlight"].each do |name, v|
-          name = name.gsub(/\..*\z/, '')
-          next if attrs_set.include?(name)
-          highlighted_attrs[name] = v
-          attrs_set << name
-        end
-
-        highlighted = new(highlighted_attrs)
-      end
-
-      new(attrs.merge(highlighted: highlighted))
-    end
-
-    # Searches the index using the parameters provided in the body hash, following the same
-    # structure Elasticsearch expects.
-    # Returns a DocumentSearch object.
-    def self.search(body)
-      search = self.strategy.search(self.document_type, body)
-      Search::DocumentProxy.new(search, self)
-    end
-
-    # Fetches one specific document from the index by ID.
-    def self.get(id)
-      if doc = self.strategy.get_document(document_type, id)
-        new(doc["_source"].merge(_id: doc['_id']))
-      end
-    end
-
-    # Removes one specific document from the index.
-    def self.delete(id)
-      self.strategy.delete_document(document_type, id)
-    end
-
-    # Removes entries based on a search
-    def self.delete_by_search(search)
-      self.strategy.delete_by_query(document_type, search.body)
-    end
-
-    # Bulk index the provided documents
-    def self.bulk_index(documents)
-      self.strategy.bulk do |b|
-        documents.each do |doc|
-          b.index(self.document_type, doc._id, doc.to_document)
-        end
-      end
-    end
-
-    # Bulk delete documents matching provided ids
-    def self.bulk_delete(ids)
-      self.strategy.bulk do |b|
-        ids.each do |id|
-          b.delete(self.document_type, id)
-        end
-      end
-    end
-
-    # Define common attributes for all documents
-    attr_accessor :_id, :highlighted
-
-    # Creates a new Document instance with the provided attributes.
-    def initialize(attributes = {})
-      super(attributes)
-    end
-
-    def attributes=(attributes)
-      attributes.each do |attr, value|
-        self.public_send("#{attr}=", value)
-      end
-    end
-
-    # Defines equality by comparing the ID and values of each instance variable.
-    def ==(other)
-      return false if other.nil?
-      return false if _id != other._id
-
-      instance_variables.all? do |ivar|
-        instance_variable_get(ivar) == other.instance_variable_get(ivar)
-      end
-    end
-
-    # IMPLEMENT
-    # Returns a hash with the attributes as they should be stored in the index.
-    # This will be stored as _source attributes on Elasticsearch.
-    def to_document
-      raise NotImplementedError, "to_document needs to be implemented for #{self.class}"
-    end
-
-    # Update this object on the index, creating or updating the document.
-    def update
-      self._id, @created = self.class.strategy.index_document(self.class.document_type, _id, to_document)
-    end
-
-    def delete
-      self.class.delete(self._id)
-    end
-
-    def created?
-      @created || false
+    def self.mapper
+      raise "document class not configured" unless config.present?
+      @mapper ||= IndexMapper.new(self, config)
     end
   end
 end

data/lib/elasticity/index_config.rb

@@ -0,0 +1,50 @@
+module Elasticity
+  class IndexConfig
+    ATTRS = [:index_base_name, :document_type, :mapping, :strategy].freeze
+    attr_accessor *ATTRS
+
+    def initialize(elasticity_config)
+      @elasticity_config = elasticity_config
+      yield(self)
+      validate!
+    end
+
+    def segment(name)
+      new_config = self.dup
+      new_config.index_base_name = "#{index_base_name}_#{name.underscore}"
+      new_config
+    end
+
+    def client
+      @elasticity_config.client
+    end
+
+    def definition
+      { settings: @elasticity_config.settings, mappings: { @document_type => @mapping } }
+    end
+
+    def fq_index_base_name
+      return @fq_index_base_name if defined?(@fq_index_base_name)
+
+      if namespace = @elasticity_config.namespace
+        @fq_index_base_name = "#{namespace}_#{@index_base_name}"
+      else
+        @fq_index_base_name = @index_base_name
+      end
+
+      @fq_index_base_name
+    end
+
+    def strategy
+      @strategy ||= Strategies::SingleIndex
+    end
+
+    private
+
+    def validate!
+      ATTRS.each do |attr|
+        raise "#{attr} is not set" if public_send(attr).nil?
+      end
+    end
+  end
+end

data/lib/elasticity/index_mapper.rb

@@ -0,0 +1,145 @@
+module Elasticity
+  class IndexMapper
+    def self.set_delegates(obj, to)
+      obj.delegate(
+        :document_type,
+        :mapping,
+        :ref_index_name,
+        :create_index,
+        :recreate_index,
+        :delete_index,
+        :index_exists?,
+        :remap!,
+        :flush_index,
+        :index_document,
+        :search,
+        :get,
+        :delete,
+        :delete_by_search,
+        :bulk_index,
+        :bulk_delete,
+        to: to
+      )
+    end
+
+    def initialize(document_klass, index_config)
+      @document_klass = document_klass
+      @index_config   = index_config
+      @strategy       = @index_config.strategy.new(@index_config.client, @index_config.fq_index_base_name, @index_config.document_type)
+    end
+
+    delegate(
+      :document_type,
+      :mapping,
+      :ref_index_name,
+      to: :@index_config
+    )
+
+    # Creates the index for this document
+    def create_index
+      @strategy.create_if_undefined(@index_config.definition)
+    end
+
+    # Re-creates the index for this document
+    def recreate_index
+      @strategy.recreate(@index_config.definition)
+    end
+
+    # Deletes the index
+    def delete_index
+      @strategy.delete
+    end
+
+    # Does the index exist?
+    def index_exists?
+      !@strategy.missing?
+    end
+
+    # Gets the index name to be used when you need to reference the index somewhere.
+    # This depends on the @strategy being used, but it always refers to the search index.
+    def ref_index_name
+      @strategy.ref_index_name
+    end
+
+    # Remap
+    def remap!
+      @strategy.remap(@index_config.definition)
+    end
+
+    # Flushes the index, forcing any writes
+    def flush_index
+      @strategy.flush
+    end
+
+    # Index the given document
+    def index_document(id, document_hash)
+      @strategy.index_document(document_type, id, document_hash)
+    end
+
+    # Searches the index using the parameters provided in the body hash, following the same
+    # structure Elasticsearch expects.
+    # Returns a DocumentSearch object.
+    def search(body)
+      search_obj = Search.build(@index_config.client, @strategy.search_index, document_type, body)
+      Search::DocumentProxy.new(search_obj, self.method(:map_hit))
+    end
+
+    # Fetches one specific document from the index by ID.
+    def get(id)
+      doc = @strategy.get_document(document_type, id)
+      @document_klass.new(doc["_source"].merge(_id: doc['_id'])) if doc.present?
+    end
+
+    # Removes one specific document from the index.
+    def delete(id)
+      @strategy.delete_document(document_type, id)
+    end
+
+    # Removes entries based on a search
+    def delete_by_search(search)
+      @strategy.delete_by_query(document_type, search.body)
+    end
+
+    # Bulk index the provided documents
+    def bulk_index(documents)
+      @strategy.bulk do |b|
+        documents.each do |doc|
+          b.index(document_type, doc._id, doc.to_document)
+        end
+      end
+    end
+
+    # Bulk delete documents matching provided ids
+    def bulk_delete(ids)
+      @strategy.bulk do |b|
+        ids.each do |id|
+          b.delete(document_type, id)
+        end
+      end
+    end
+
+    private
+
+    # Creates a instance of a document from a ElasticSearch hit data.
+    def map_hit(hit)
+      attrs = { _id: hit["_id"] }
+      attrs.merge!(hit["_source"]) if hit["_source"]
+
+      if hit["highlight"]
+        highlighted_attrs = attrs.dup
+        attrs_set = Set.new
+
+        hit["highlight"].each do |name, v|
+          name = name.gsub(/\..*\z/, '')
+          next if attrs_set.include?(name)
+          highlighted_attrs[name] = v
+          attrs_set << name
+        end
+
+        highlighted = @document_klass.new(highlighted_attrs)
+      end
+
+      @document_klass.new(attrs.merge(highlighted: highlighted))
+    end
+  end
+end

data/lib/elasticity/search.rb

@@ -1,5 +1,10 @@
 module Elasticity
   module Search
+    def self.build(client, index_name, document_type, body)
+      search_def = Search::Definition.new(index_name, document_type, body)
+      Search::Facade.new(client, search_def)
+    end
+
     # Elasticity::Search::Definition is a struct that encapsulates all the data specific to one
     # ElasticSearch search.
     class Definition
@@ -15,6 +20,10 @@ module Elasticity
         self.class.new(@index_name, @document_type, @body.deep_merge(body_changes))
       end
 
+      def to_count_args
+        { index: @index_name, type: @document_type, body: { query: @body.fetch(:query) }}
+      end
+
       def to_search_args
         { index: @index_name, type: @document_type, body: @body }
       end
@@ -45,11 +54,11 @@ module Elasticity
       end
 
       # Performs the search using the default search type and returning an iterator that will yield
-      # each document, converted to the provided document_klass.
-      def documents(document_klass)
+      # each document, converted using the provided mapper
+      def documents(mapper)
         return @documents if defined?(@documents)
         @documents = LazySearch.new(@client, @search_definition) do |hit|
-          document_klass.from_hit(hit)
+          mapper.(hit)
         end
       end
 
@@ -57,9 +66,9 @@ module Elasticity
       # as fast as possible. The sort option will be discarded.
       #
       # More info: http://www.elasticsearch.org/guide/en/elasticsearch/guide/current/scan-scroll.html
-      def scan_documents(document_klass, **options)
+      def scan_documents(mapper, **options)
         return @scan_documents if defined?(@scan_documents)
-        @scan_documents = ScanCursor.new(@client, @search_definition, document_klass, **options)
+        @scan_documents = ScanCursor.new(@client, @search_definition, mapper, **options)
       end
 
       # Performs the search only fetching document ids using it to load ActiveRecord objects from the provided
@@ -105,7 +114,7 @@ module Elasticity
       end
 
       def count(args = {})
-        @client.count(@search_definition.to_search_args.reverse_merge(args))["count"]
+        @client.count(@search_definition.to_count_args.reverse_merge(args))["count"]
       end
 
       def search_results
@@ -147,10 +156,10 @@ module Elasticity
     class ScanCursor
       include Enumerable
 
-      def initialize(client, search_definition, document_klass, size: 100, scroll: "1m")
+      def initialize(client, search_definition, mapper, size: 100, scroll: "1m")
         @client            = client
         @search_definition = search_definition
-        @document_klass    = document_klass
+        @mapper            = mapper
         @size              = size
         @scroll            = scroll
       end
@@ -190,7 +199,7 @@ module Elasticity
             hits     = response["hits"]["hits"]
             break if hits.empty?
 
-            y << hits.map { |hit| @document_klass.from_hit(hit) }
+            y << hits.map { |hit| @mapper.(hit) }
           end
         end
       end

data/lib/elasticity/segmented_document.rb

@@ -0,0 +1,33 @@
+module Elasticity
+  class SegmentedDocument < BaseDocument
+    # Creates a new segment which behaves almost the same as a Document class dynamically
+    # configured to access a segmented index.
+    #
+    # It creates a new class in runtime that inherits from your defined class, allowing
+    # methods defined in your class to be callable from the dynamic class.
+    def self.segment(segment_name)
+      qn = segment_name.camelize
+
+      klass = Class.new(self) do
+        class_attribute :mapper, :segment_name
+        IndexMapper.set_delegates(singleton_class, :mapper)
+
+        def self.inspect
+          "#{superclass.name}{\"#{segment_name}\"}"
+        end
+
+        def inspect
+          ivars = instance_variables.map do |name|
+            "#{name}=#{instance_variable_get(name).inspect}"
+          end
+
+          "#<#{self.class.inspect}:0x#{object_id.to_s(15)} #{ivars.join(" ")}>"
+        end
+      end
+
+      klass.segment_name = segment_name
+      klass.mapper = IndexMapper.new(klass, config.segment(segment_name))
+      klass
+    end
+  end
+end

data/lib/elasticity/strategies/alias_index.rb

@@ -213,8 +213,8 @@ module Elasticity
         @client.get(index: @main_alias, type: type, id: id)
       end
 
-      def search(type, body)
-        Search::Facade.new(@client, Search::Definition.new(@main_alias, type, body))
+      def search_index
+        @main_alias
       end
 
       def delete_by_query(type, body)

data/lib/elasticity/strategies/single_index.rb

@@ -64,8 +64,8 @@ module Elasticity
         @client.get(index: @index_name, type: type, id: id)
       end
 
-      def search(type, body)
-        Search::Facade.new(@client, Search::Definition.new(@index_name, type, body))
+      def search_index
+        @index_name
       end
 
       def delete_by_query(type, body)

data/lib/elasticity/version.rb

@@ -1,3 +1,3 @@
 module Elasticity
-  VERSION = "0.3.9"
+  VERSION = "0.3.10"
 end

data/spec/functional/segmented_spec.rb

@@ -0,0 +1,78 @@
+RSpec.describe "Segmented indexes", elasticsearch: true do
+  subject do
+    Class.new(Elasticity::SegmentedDocument) do
+      configure do |c|
+        c.index_base_name = "people"
+        c.document_type = "person"
+        c.mapping = {
+          properties: {
+            name: { type: "string" },
+          },
+        }
+      end
+
+      attr_accessor :name
+
+      def self.by_name(name)
+        search(query: { match: { name: name } })
+      end
+
+      def to_document
+        { name: name }
+      end
+    end
+  end
+
+  def ensure_index(*segments)
+    @indexed ||= []
+    segments.each(&:recreate_index)
+    @indexed += segments
+  end
+
+  after do
+    Array(@indexed).each { |i| i.delete_index }
+  end
+
+  it "allows all operations on a segment" do
+    seg = subject.segment("A")
+    ensure_index(seg)
+
+    rodrigo = seg.new(name: "rodrigo")
+    id, success = rodrigo.update
+    expect(id).to be_kind_of(String)
+    expect(success).to be true
+
+    seg.flush_index
+    results = seg.by_name("rodrigo").to_a
+    expect(results).to eq [rodrigo]
+
+    rodrigo.delete
+    seg.flush_index
+
+    results = seg.by_name("rodrigo").to_a
+    expect(results).to be_empty
+  end
+
+  it "isolates segments from one another" do
+    seg_a = subject.segment("A")
+    seg_b = subject.segment("B")
+    ensure_index(seg_a, seg_b)
+
+    doc_a = seg_a.new(name: "doc a")
+    _, success = doc_a.update
+    expect(success).to be true
+
+    doc_b = seg_b.new(name: "doc b")
+    _, success = doc_b.update
+    expect(success).to be true
+
+    seg_a.flush_index
+    seg_b.flush_index
+
+    res_a = seg_a.by_name("doc").to_a
+    expect(res_a).to eq [doc_a]
+
+    res_b = seg_b.by_name("doc").to_a
+    expect(res_b).to eq [doc_b]
+  end
+end

data/spec/units/document_spec.rb

@@ -42,49 +42,6 @@ RSpec.describe Elasticity::Document do
     expect { Class.new(described_class).new.to_document }.to raise_error(NotImplementedError)
   end
 
-  context "class" do
-    subject { klass }
-
-    it "properly instantiate from search hit" do
-      hit = { "_id" => 1, "_source" => { "name" => "foo", "items" => [{ name: "bar" }] }, "highlight" => { "name" => "<em>foo</em>" } }
-      doc = subject.from_hit(hit)
-      expect(doc.name).to eq "foo"
-      expect(doc.items).to eq [{ name: "bar" }]
-      expect(doc.highlighted.name).to eq "<em>foo</em>"
-      expect(doc.highlighted.items).to eq [{ name: "bar" }]
-    end
-
-    it "searches using DocumentSearch" do
-      body   = double(:body)
-      search = double(:search)
-
-      expect(strategy).to receive(:search).with("class_name", body).and_return(search)
-
-      doc_search = double(:doc_search)
-      expect(Elasticity::Search::DocumentProxy).to receive(:new).with(search, subject).and_return(doc_search)
-
-      expect(subject.search(body)).to be doc_search
-    end
-
-    it "gets specific document from the strategy" do
-      doc = { "_id" => 1, "_source" => { "name" => "Foo", "items" => [{ "name" => "Item1" }]}}
-      expect(strategy).to receive(:get_document).with("class_name", 1).and_return(doc)
-      expect(subject.get(1)).to eq klass.new(_id: 1, name: "Foo", items: [{ "name" => "Item1" }])
-    end
-
-    it "deletes specific document from strategy" do
-      strategy_ret = double(:strategy_return)
-      expect(strategy).to receive(:delete_document).with("class_name", 1).and_return(strategy_ret)
-      expect(subject.delete(1)).to eq strategy_ret
-    end
-
-    it "properly instantiates from search hit when no source is given" do
-      hit = { "_id" => 1, "_type" => "foo" }
-      doc = subject.from_hit(hit)
-      expect(doc._id).to eq(1)
-    end
-  end
-
   context "instance" do
     subject { klass.new _id: 1, name: "Foo", items: [{ name: "Item1" }] }
 

data/spec/units/index_mapper_spec.rb

@@ -0,0 +1,4 @@
+require "elasticity/index_mapper"
+
+RSpec.describe Elasticity::IndexMapper do
+end

data/spec/units/search_spec.rb

@@ -59,15 +59,17 @@ RSpec.describe "Search" do
     ]}}
   end
 
+  let :mapper do
+    -> (hit) {
+      klass.new(_id: hit["_id"], name: hit["_source"]["name"], age: hit["_source"]["age"])
+    }
+  end
+
   let :klass do
     Class.new do
       include ActiveModel::Model
       attr_accessor :_id, :name, :age
 
-      def self.from_hit(hit)
-        new(_id: hit["_id"], name: hit["_source"]["name"], age: hit["_source"]["age"])
-      end
-
       def ==(other)
         self._id == other._id && self.name == other.name
       end
@@ -82,7 +84,7 @@ RSpec.describe "Search" do
     it "searches the index and return document models" do
       expect(client).to receive(:search).with(index: index_name, type: document_type, body: body).and_return(full_response)
 
-      docs = subject.documents(klass)
+      docs = subject.documents(mapper)
       expected = [klass.new(_id: 1, name: "foo"), klass.new(_id: 2, name: "bar")]
 
       expect(docs.total).to eq 2
@@ -101,7 +103,7 @@ RSpec.describe "Search" do
     it "searches and the index returns aggregations" do
       expect(client).to receive(:search).with(index: index_name, type: document_type, body: body).and_return(full_response_with_aggregations)
 
-      docs = subject.documents(klass)
+      docs = subject.documents(mapper)
       expect(docs.aggregations).to eq aggregations
     end
 
@@ -110,7 +112,7 @@ RSpec.describe "Search" do
       expect(client).to receive(:scroll).with(scroll_id: "abc123", scroll: "1m").and_return(scroll_response)
       expect(client).to receive(:scroll).with(scroll_id: "abc456", scroll: "1m").and_return(empty_response)
 
-      docs = subject.scan_documents(klass)
+      docs = subject.scan_documents(mapper)
       expected = [klass.new(_id: 1, name: "foo"), klass.new(_id: 2, name: "bar")]
 
       expect(docs.total).to eq 2
@@ -144,7 +146,7 @@ RSpec.describe "Search" do
     it "provides defaul properties for pagination" do
       subject = Elasticity::Search::Facade.new(client, Elasticity::Search::Definition.new(index_name, document_type, body))
       expect(client).to receive(:search).with(index: index_name, type: document_type, body: body).and_return(full_response)
-      docs = subject.documents(klass)
+      docs = subject.documents(mapper)
 
       expect(docs.per_page).to eq(10)
       expect(docs.total_pages).to eq(1)
@@ -166,7 +168,7 @@ RSpec.describe "Search" do
           type: document_type,
           body: { size: 14, from: 25, filter: {} }
         ).and_return({ "hits" => { "total" => 112 } })
-      docs = subject.documents(klass)
+      docs = subject.documents(mapper)
 
       expect(docs.per_page).to eq(14)
       expect(docs.total_pages).to eq(8)
@@ -180,7 +182,7 @@ RSpec.describe "Search" do
     end
 
     subject do
-      described_class.new(search, klass)
+      described_class.new(search, mapper)
     end
 
     it "automatically maps the documents into the provided Document class" do

data/spec/units/strategies/single_index_spec.rb

@@ -69,16 +69,6 @@ RSpec.describe Elasticity::Strategies::SingleIndex, elasticsearch: true do
       expect(subject.get_document("document", 2)).to eq({"_index"=>"test_index_name", "_type"=>"document", "_id"=>"2", "_version"=>1, "found"=>true, "_source"=>{"name"=>"bar"}})
     end
 
-    it "allows searching documents" do
-      subject.index_document("document", 1, name: "test")
-      subject.flush
-
-      search = subject.search("document", filter: { term: { name: "test" }})
-      hashes = search.document_hashes
-      expect(hashes.size).to be 1
-      expect(hashes[0]).to eq("_id" => "1", "_index" => "test_index_name", "_type" => "document", "_score" => 1.0, "_source" => { "name" => "test" })
-    end
-
     it "allows deleting by queryu" do
       subject.index_document("document", 1, name: "foo")
       subject.index_document("document", 2, name: "bar")

metadata

@@ -1,167 +1,167 @@
 --- !ruby/object:Gem::Specification
 name: es-elasticity
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.3.10
 platform: ruby
 authors:
 - Rodrigo Kochenburger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-08 00:00:00.000000000 Z
+date: 2015-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 3.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.7.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.7.1
 - !ruby/object:Gem::Dependency
   name: oj
   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: 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: codeclimate-test-reporter
   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: redis
   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: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
 - !ruby/object:Gem::Dependency
   name: elasticsearch
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.0.12
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.0.12
 description: Elasticity provides a higher level abstraction on top of [elasticsearch-ruby](https://github.com/elasticsearch/elasticsearch-ruby)
@@ -172,10 +172,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .simplecov
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".simplecov"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -184,21 +184,27 @@ files:
 - bin/rspec
 - elasticity.gemspec
 - lib/elasticity.rb
+- lib/elasticity/base_document.rb
 - lib/elasticity/bulk.rb
 - lib/elasticity/config.rb
 - lib/elasticity/document.rb
+- lib/elasticity/index_config.rb
+- lib/elasticity/index_mapper.rb
 - lib/elasticity/instrumented_client.rb
 - lib/elasticity/log_subscriber.rb
 - lib/elasticity/multi_search.rb
 - lib/elasticity/railtie.rb
 - lib/elasticity/search.rb
+- lib/elasticity/segmented_document.rb
 - lib/elasticity/strategies.rb
 - lib/elasticity/strategies/alias_index.rb
 - lib/elasticity/strategies/single_index.rb
 - lib/elasticity/version.rb
 - spec/functional/persistence_spec.rb
+- spec/functional/segmented_spec.rb
 - spec/rspec_config.rb
 - spec/units/document_spec.rb
+- spec/units/index_mapper_spec.rb
 - spec/units/multi_search_spec.rb
 - spec/units/search_spec.rb
 - spec/units/strategies/single_index_spec.rb
@@ -212,24 +218,27 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: ActiveModel-based library for working with Elasticsearch
 test_files:
 - spec/functional/persistence_spec.rb
+- spec/functional/segmented_spec.rb
 - spec/rspec_config.rb
 - spec/units/document_spec.rb
+- spec/units/index_mapper_spec.rb
 - spec/units/multi_search_spec.rb
 - spec/units/search_spec.rb
 - spec/units/strategies/single_index_spec.rb
+has_rdoc: