es-elasticity 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4316eca2c0cf5953a781ed8233e13eb6b6ae90fd
+  data.tar.gz: f37edd93770533fc4cb5c05b515438abf481aea9
+SHA512:
+  metadata.gz: dfc1d0d24057f8e8a3bb890ff6b2812d3db20dbd0972ba07aa957e454bdc61f261fba3eca868397db40e14c6ae649ffb3314312ae288b005c532a7e855bd14d9
+  data.tar.gz: f76f11327b69c509442cda2a6788c5e13252e44a86146d6c5424981508fab1e480592f95a028aee8bf708768418de347255445e6c4d4a7bea3cfedcceb40dc4a

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.log

data/.rspec

@@ -0,0 +1 @@
+-Ilib -Ispec -rrspec_config --color --format progress --order rand

data/.simplecov

@@ -0,0 +1,5 @@
+SimpleCov.start do
+  add_filter do |src|
+    src.filename =~ /^#{Regexp.escape(File.dirname(__FILE__))}\/spec/
+  end
+end

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in elasticity.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Rodrigo Kochenburger
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,120 @@
+# Elasticity
+
+Elasticity provides a higher level abstraction on top of [elasticsearch-ruby](https://github.com/elasticsearch/elasticsearch-ruby) gem.
+
+Mainly, it provides a model-oriented approach to ElasticSearch, similar to what [ActiveRecord](https://github.com/rails/rails/tree/master/activerecord) provides to relational databases. It leverages [ActiveModel](https://github.com/rails/rails/tree/master/activemodel) to provide a familiar format for Rails developers.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'elasticity'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install elasticity
+
+## Usage overview
+
+The first thing to do, is setup a model class for a index and document type that inherits from `Elasticity::Document`.
+
+```ruby
+class Search::User < Elasticity::Document
+  # All models automatically have the id attribute but you need to define the others.
+  attr_accessor :name, :birthdate
+
+  # Define the index mapping for the index and document type this model represents.
+  self.mappings = {
+    properties: {
+      name: { type: "string" },
+      birthdate: { type: "date" },
+    }
+  }
+
+  # 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.
+    body = {
+      filter: {
+        { range: { birthdate: { gte: 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
+
+  # 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
+```
+
+Then instances of that model can be indexed pretty easily by just calling the `update` method.
+
+```ruby
+# Creates a new document on the index
+u = Search::User.new(id: 1, name: "John", birthdate: Date.civil(1985, 10, 31))
+u.update
+
+# Updates the same document on the index
+u.name = "Jonh Jon"
+u.update
+```
+
+Getting the results of a search is also pretty straightforward:
+
+```ruby
+# Get the search object, which is an instance of `Elasticity::DocumentSearchProxy`.
+# Search is not performed until data is accessed.
+adults = User.adults
+
+# Iterating over the results will trigger the query
+adults.each do |user|
+  # do something with user
+end
+
+# Or you can also, map the results back to an ActiveRecord relation.
+# In this case, only the ids will be fetched.
+adults.active_recors(Database::User) # => Array of Database::User instances
+```
+
+## Design Goals
+
+- Provide model specific for ElasticSearch documents instead of an ActiveRecord mixin;
+- proper separation of concerns and de-coupling;
+- lazy search evaluation and easy composition of multi-searches;
+- easy of debug;
+- higher level API that resembles ElasticSearch API;
+
+## Roadmap
+
+- [ ] Write more detailed documentation section for:
+  - [ ] Model definition
+  - [ ] Indexing, Bulk Indexing and Delete By Query
+  - [ ] Search and Multi Search
+  - [ ] ActiveRecord integration
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/elasticity/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new

data/bin/rake

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rake', 'rake')

data/bin/rspec

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rspec-core', 'rspec')

data/elasticity.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'elasticity/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "es-elasticity"
+  spec.version       = Elasticity::VERSION
+  spec.authors       = ["Rodrigo Kochenburger"]
+  spec.email         = ["rodrigo@doximity.com"]
+  spec.summary       = %q{ActiveModel-based library for working with ElasticSearch}
+  spec.description   = %q{Elasticity provides a higher level abstraction on top of [elasticsearch-ruby](https://github.com/elasticsearch/elasticsearch-ruby) gem}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  # spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.executables   = []
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.1.0"
+  spec.add_development_dependency "simplecov", "~> 0.7.1"
+  spec.add_development_dependency "oj"
+  spec.add_development_dependency "pry"
+
+  spec.add_dependency "activesupport", "~> 4.0.0"
+  spec.add_dependency "activemodel",   "~> 4.0.0"
+  spec.add_dependency "elasticsearch", "~> 1.0.5"
+end

data/lib/elasticity.rb

@@ -0,0 +1,5 @@
+require "elasticity_base"
+require "elasticity/index"
+require "elasticity/document"
+require "elasticity/search"
+require "elasticity/multi_search"

data/lib/elasticity/document.rb

@@ -0,0 +1,100 @@
+module Elasticity
+  class Document
+    include ::ActiveModel::Model
+
+    # Returns the instance of Elasticity::Index associated with this document.
+    def self.index
+      return @index if defined?(@index)
+
+      index_name = self.name.underscore.pluralize
+
+      if namespace = Elasticity.config.namespace
+        index_name = "#{namespace}_#{index_name}"
+      end
+
+      @index = Index.new(Elasticity.config.client, index_name)
+      @index.create_if_undefined(settings: Elasticity.config.settings, mappings: @mappings)
+      @index
+    end
+
+    # The index name to be used for indexing and storing data for this document model.
+    # By default, it's the class name converted to underscore and plural.
+    def self.index_name
+      self.index.name
+    end
+
+    # The document type to be used, it's inferred by the class name.
+    def self.document_type
+      self.name.underscore
+    end
+
+    # Sets the mapping for this model, which will be used to create the associated index and
+    # generate accessor methods.
+    def self.mappings=(mappings)
+      raise "Can't re-define mappings in runtime" if defined?(@mappings)
+      @mappings = mappings
+    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)
+      DocumentSearchProxy.new(Search.new(index, document_type, body), self)
+    end
+
+    # Fetches one specific document from the index by ID.
+    def self.get(id)
+      if doc = index.get_document(document_type, id)
+        new(doc["_source"])
+      end
+    end
+
+    # Removes one specific document from the index.
+    def self.delete(id)
+      index.delete_document(document_type, id)
+    end
+
+    # Removes entries based on a search
+    def self.delete_by_search(search)
+      index.delete_by_query(document_type, search.body)
+    end
+
+    # Bulk index the provided documents
+    def self.bulk_index(documents)
+      index.bulk do |b|
+        documents.each do |doc|
+          b.index(self.document_type, doc.id, doc.to_document)
+        end
+      end
+    end
+
+    # Define common attributes for all documents
+    attr_accessor :id
+
+    # Creates a new Document instance with the provided attributes.
+    def initialize(attributes = {})
+      super(attributes)
+    end
+
+    # Defines equality by comparing the ID and values of each instance variable.
+    def ==(other)
+      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.class.index.index_document(self.class.document_type, id, to_document)
+    end
+  end
+end

data/lib/elasticity/index.rb

@@ -0,0 +1,114 @@
+module Elasticity
+  class Index
+    attr_reader :name
+
+    def initialize(client, index_name)
+      @client    = client
+      @name      = index_name
+    end
+
+    def create(index_def)
+      args = { index: @name, body: index_def }
+      instrument("index_create", args) { @client.indices.create(args) }
+    end
+
+    def create_if_undefined(index_def)
+      create(index_def) unless @client.indices.exists(index: @name)
+    end
+
+    def delete
+      args = { index: @name }
+      instrument("index_delete", args) { @client.indices.delete(args) }
+    end
+
+    def delete_if_defined
+      delete if @client.indices.exists(index: @name)
+    end
+
+    def recreate(index_def = nil)
+      index_def ||= { settings: settings, mappings: mappings }
+      delete_if_defined
+      create(index_def)
+    end
+
+    def index_document(type, id, attributes)
+      args = { index: @name, type: type, id: id, body: attributes }
+      instrument("index_document", args) { @client.index(args) }
+    end
+
+    def delete_document(type, id)
+      args = { index: @name, type: type, id: id }
+      instrument("delete_document", args) { @client.delete(args) }
+    end
+
+    def get_document(type, id)
+      args = { index: @name, type: type, id: id }
+      instrument("get_document", args) { @client.get(args) }
+    end
+
+    def search(type, body)
+      args = { index: @name, type: type, body: body }
+      instrument("search", args) { @client.search(args) }
+    end
+
+    def delete_by_query(type, body)
+      args = { index: @name, type: type, body: body }
+      instrument("delete_by_query", args) { @client.delete_by_query(args) }
+    end
+
+    def bulk
+      b = Bulk.new(@client, @name)
+      yield b
+      b.execute
+    end
+
+    def settings
+      args = { index: @name }
+      settings = instrument("settings", args) { @client.indices.get_settings(args) }
+      settings[@name]["settings"] if settings[@name]
+    rescue Elasticsearch::Transport::Transport::Errors::NotFound
+      nil
+    end
+
+    def mappings
+      args = { index: @name }
+      mappings = instrument("mappings", args) { @client.indices.get_mapping(args) }
+      mappings[@name]["mappings"] if mappings[@name]
+    rescue Elasticsearch::Transport::Transport::Errors::NotFound
+      nil
+    end
+
+    def flush
+      args = { index: @name }
+      instrument("flush", args) { @client.indices.flush(args) }
+    end
+
+    private
+
+    def instrument(name, extra = {})
+      ActiveSupport::Notifications.instrument("elasticity.#{name}", args: extra) do
+        yield
+      end
+    end
+
+    class Bulk
+      def initialize(client, name)
+        @client     = client
+        @name       = name
+        @operations = []
+      end
+
+      def index(type, id, attributes)
+        @operations << { index: { _index: @name, _type: type, _id: id, data: attributes }}
+      end
+
+      def delete(type, id)
+        @operations << { delete: { _index: @name, _type: type, _id: id }}
+      end
+
+      def execute
+        @client.bulk(body: @operations)
+      end
+    end
+  end
+end

data/lib/elasticity/multi_search.rb

@@ -0,0 +1,46 @@
+module Elasticity
+  class MultiSearch
+    def initialize
+      @searches = []
+      yield self if block_given?
+    end
+
+    def add(name, search, documents: nil, active_records: nil)
+      mapper = case
+      when documents && active_records
+        raise ArgumentError, "you can only pass either :documents or :active_records as an option"
+      when documents
+        Search::DocumentMapper.new(documents)
+      when active_records
+        Search::ActiveRecordMapper.new(active_records)
+      else
+        raise ArgumentError, "you need to provide either :documents or :active_records as an option"
+      end
+
+      @searches << [name, search, mapper]
+    end
+
+    def [](name)
+      @results ||= fetch
+      @results[name]
+    end
+
+    private
+
+    def fetch
+      multi_body = @searches.map do |name, search, _|
+        { index: search.index.name, type: search.document_type, body: search.body }
+      end
+
+      results = {}
+
+      responses = Array(Elasticity.config.client.msearch(body: multi_body)["responses"])
+      responses.each_with_index do |resp, idx|
+        name, search, mapper = @searches[idx]
+        results[name] = Search::Result.new(resp, mapper)
+      end
+
+      results
+    end
+  end
+end

data/lib/elasticity/search.rb

@@ -0,0 +1,159 @@
+module Elasticity
+  # Search provides a simple interface for defining a search against an ElasticSearch
+  # index and fetching the results in different ways and mappings.
+  #
+  # Example:
+  #   search = Elasticity::Search.new("people", "person", {...})
+  #   search.documents(Person)
+  class Search
+    attr_reader :index, :document_type, :body
+
+    # Creates a new Search definitions for the given index, document_type and criteria. The
+    # search is not performend until methods are called, each method represents a different
+    # way of fetching and mapping the data.
+    #
+    # The body parameter is a hash following the exact same syntax as ElasticSearch's JSON
+    # query language.
+    def initialize(index, document_type, body)
+      @index          = index
+      @document_type  = document_type.freeze
+      @body           = body.freeze
+    end
+
+    # Execute the search, fetching only ids from ElasticSearch and then mapping the results
+    # into ActiveRecord models using the provided relation.
+    def active_records(relation)
+      return @active_record if defined?(@active_record)
+      response = @index.search(@document_type, @body.merge(_source: []))
+      @active_record = Result.new(response, ActiveRecordMapper.new(relation))
+    end
+
+    # Execute the search, fetching all documents from the index and mapping the stored attributes
+    # into instances of the provided class. It will call document_klass.new(attrs), where attrs
+    # are the stored attributes.
+    def documents(document_klass)
+      return @documents if defined?(@documents)
+      response = @index.search(@document_type, @body)
+      @documents = Result.new(response, DocumentMapper.new(document_klass))
+    end
+
+    # Result is a collection representing the response from a search against an index. It's what gets
+    # returned by any of the Elasticity::Search methods and it provides a lazily-evaluated and
+    # lazily-mapped – using the provided mapper class.
+    #
+    # Example:
+    #
+    #   response = {"took"=>0, "timed_out"=>false, "_shards"=>{"total"=>5, "successful"=>5, "failed"=>0}, "hits"=>{"total"=>2, "max_score"=>1.0, "hits"=>[
+    #     {"_index"=>"my_index", "_type"=>"my_type", "_id"=>"1", "_score"=>1.0, "_source"=> { "id" => 1, "name" => "Foo" },
+    #     {"_index"=>"my_index", "_type"=>"my_type", "_id"=>"2", "_score"=>1.0, "_source"=> { "id" => 2, "name" => "Bar" },
+    #   ]}}
+    #
+    #   class AttributesMapper
+    #     def map(hits)
+    #       hits.map { |h| h["_source"] }
+    #     end
+    #   end
+    #
+    #   r = Result.new(response, AttributesMapper.new)
+    #   r.total # => 2
+    #   r[0]    # => { "id" => 1, "name" => "Foo" }
+    #
+    class Result
+      include Enumerable
+
+      def initialize(response, mapper)
+        @response = response
+        @mapper   = mapper
+      end
+
+      def [](idx)
+        mapping[idx]
+      end
+
+      def each(&block)
+        mapping.each(&block)
+      end
+
+      def to_ary
+        mapping.to_ary
+      end
+
+      def size
+        mapping.size
+      end
+
+      # The total number of entries as returned by ES
+      def total
+        @response["hits"]["total"]
+      end
+
+      def empty?
+        total == 0
+      end
+
+      def blank?
+        empty?
+      end
+
+      def mapping
+        return @mapping if defined?(@mapping)
+        hits = Array(@response["hits"]["hits"])
+        @mapping = @mapper.map(hits)
+      end
+    end
+
+    class DocumentMapper
+      def initialize(document_klass)
+        @document_klass = document_klass
+      end
+
+      def map(hits)
+        hits.map do |hit|
+          @document_klass.new(hit["_source"])
+        end
+      end
+    end
+
+    class ActiveRecordMapper
+      def initialize(relation)
+        @relation = relation
+      end
+
+      def map(hits)
+        ids = hits.map { |h| h["_source"]["id"] }
+
+        if ids.any?
+          id_col = "#{quote(@relation.table_name)}.#{quote(@relation.klass.primary_key)}"
+          @relation.where(id: ids).order("FIELD(#{id_col},#{ids.join(',')})")
+        else
+          @relation.none
+        end
+      end
+
+      private
+
+      def quote(identifier)
+        @relation.connection.quote_column_name(identifier)
+      end
+    end
+  end
+
+  class DocumentSearchProxy < BasicObject
+    def initialize(search, document_klass)
+      @search         = search
+      @document_klass = document_klass
+    end
+
+    def active_records(relation)
+      @search.active_records(relation)
+    end
+
+    def documents
+      @search.documents(@document_klass)
+    end
+
+    def method_missing(method_name, *args, &block)
+      documents.public_send(method_name, *args, &block)
+    end
+  end
+end

data/lib/elasticity/version.rb

@@ -0,0 +1,3 @@
+module Elasticity
+  VERSION = "0.2.1"
+end

data/lib/elasticity_base.rb

@@ -0,0 +1,60 @@
+require "rubygems"
+require "bundler/setup"
+Bundler.setup
+
+require "active_support"
+require "active_support/core_ext"
+require "active_model"
+require "elasticsearch"
+
+module Elasticity
+  class Config
+    attr_writer :logger, :client, :settings, :namespace, :pretty_json
+
+    def logger
+      return @logger if defined?(@logger)
+      @logger = Logger.new(STDOUT)
+    end
+
+    def client
+      return @client if defined?(@client)
+      @client = Elasticsearch::Client.new
+    end
+
+    def settings
+      return @settings if defined?(@settings)
+      @settings = {}
+    end
+
+    def namespace
+      @namespace
+    end
+
+    def pretty_json
+      @pretty_json || false
+    end
+  end
+
+  def self.configure
+    @config = Config.new
+    yield(@config)
+  end
+
+  def self.config
+    return @config if defined?(@config)
+    @config = Config.new
+  end
+end
+
+ActiveSupport::Notifications.subscribe(/^elasticity\./) do |name, start, finish, id, payload|
+  time = (finish - start)*1000
+
+  if logger = Elasticity.config.logger
+    logger.debug "#{name} #{"%.2f" % time}ms #{MultiJson.dump(payload[:args], pretty: Elasticity.config.pretty_json)}"
+
+    exception, message = payload[:exception]
+    if exception
+      logger.error "#{name} #{exception}: #{message}"
+    end
+  end
+end

data/spec/rspec_config.rb

@@ -0,0 +1,35 @@
+require "elasticity_base"
+require "simplecov"
+require "oj"
+require "elasticity"
+
+def elastic_search_client
+  return @elastic_search_client if defined?(@elastic_search_client)
+  @elastic_search_client = Elasticsearch::Client.new host: "http://0.0.0.0:9200"
+end
+
+logger = Logger.new("spec/spec.log", File::WRONLY | File::APPEND | File::CREAT)
+
+RSpec.configure do |c|
+  c.disable_monkey_patching!
+
+  c.before(:suite) do
+    logger.info "rspec.init Starting test suite execution"
+  end
+
+  c.before(:each) do |example|
+    logger.info "rspec.spec #{example.full_description}"
+
+    if example.metadata[:elasticsearch]
+      client = elastic_search_client
+    else
+      client = double(:elasticsearch_client)
+    end
+
+    Elasticity.configure do |e|
+      e.logger    = logger
+      e.client    = client
+      e.namespace = "elasticity_test"
+    end
+  end
+end

data/spec/units/document_spec.rb

@@ -0,0 +1,100 @@
+require "elasticity/search"
+
+RSpec.describe Elasticity::Document do
+  mappings = {
+    properties: {
+      id: { type: "integer" },
+      name: { type: "string" },
+
+      items: {
+        type: "nested",
+        properties: {
+          name: { type: "string" },
+        },
+      }
+    }
+  }
+
+  let :klass do
+    Class.new(described_class) do
+      # Override the name since this is an anonymous class
+      def self.name
+        "ClassName"
+      end
+
+      self.mappings = mappings
+
+      attr_accessor :name, :items
+
+      def to_document
+        { id: id, name: name, items: items}
+      end
+    end
+  end
+
+  let :index do
+    double(:index, create_if_undefined: nil, name: "elasticity_test_class_names")
+  end
+
+  before :each do
+    allow(Elasticity::Index).to receive(:new).and_return(index)
+  end
+
+  it "requires subclasses to define to_document method" do
+    expect { Class.new(described_class).new.to_document }.to raise_error(NotImplementedError)
+  end
+
+  context "class" do
+    subject { klass }
+
+    it "extracts index name and document type from the class name" do
+      expect(subject.index_name).to eq "elasticity_test_class_names"
+      expect(subject.document_type).to eq "class_name"
+    end
+
+    it "have an associated Index instance" do
+      client   = double(:client)
+      settings = double(:settings)
+
+      Elasticity.config.settings = settings
+      Elasticity.config.client   = client
+
+      expect(Elasticity::Index).to receive(:new).with(client, "elasticity_test_class_names").and_return(index)
+      expect(index).to receive(:create_if_undefined).with(settings: settings, mappings: mappings)
+
+      expect(subject.index).to be index
+    end
+
+    it "searches using DocumentSearch" do
+      body   = double(:body)
+      search = double(:search)
+      expect(Elasticity::Search).to receive(:new).with(index, "class_name", body).and_return(search)
+
+      doc_search = double(:doc_search)
+      expect(Elasticity::DocumentSearchProxy).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 index" do
+      doc = { "_source" => { "id" => 1, "name" => "Foo", "items" => [{ "name" => "Item1" }]}}
+      expect(index).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 index" do
+      index_ret = double(:index_return)
+      expect(index).to receive(:delete_document).with("class_name", 1).and_return(index_ret)
+      expect(subject.delete(1)).to eq index_ret
+    end
+  end
+
+  context "instance" do
+    subject { klass.new id: 1, name: "Foo", items: [{ name: "Item1" }] }
+
+    it "stores the document in the index" do
+      expect(index).to receive(:index_document).with("class_name", 1, {id: 1, name: "Foo", items: [{ name: "Item1" }]})
+      subject.update
+    end
+  end
+end

data/spec/units/index_spec.rb

@@ -0,0 +1,97 @@
+require "elasticity/index"
+
+RSpec.describe Elasticity::Index, elasticsearch: true do
+  subject do
+    described_class.new(Elasticity.config.client, "test_index_name")
+  end
+
+  let :index_def do
+    {
+      mappings: {
+        document: {
+          properties: {
+            name: { type: "string" }
+          }
+        }
+      }
+    }
+  end
+
+  after do
+    subject.delete_if_defined
+  end
+
+  it "allows creating, recreating and deleting an index" do
+    subject.create(index_def)
+    expect(subject.mappings).to eq({"document"=>{"properties"=>{"name"=>{"type"=>"string"}}}})
+
+    subject.recreate
+    expect(subject.mappings).to eq({"document"=>{"properties"=>{"name"=>{"type"=>"string"}}}})
+
+    subject.delete
+    expect(subject.mappings).to be nil
+  end
+
+  it "returns nil for mapping and settings when index does not exist" do
+    expect(subject.mappings).to be nil
+    expect(subject.settings).to be nil
+  end
+
+  context "with existing index" do
+    before do
+      subject.create_if_undefined(index_def)
+    end
+
+    it "allows adding, getting and removing documents from the index" do
+      subject.index_document("document", 1, name: "test")
+
+      doc = subject.get_document("document", 1)
+      expect(doc["_source"]["name"]).to eq("test")
+
+      subject.delete_document("document", 1)
+      expect { subject.get_document("document", 1) }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
+    end
+
+    it "allows batching index and delete actions" do
+      results_a = subject.bulk do |b|
+        b.index "document", 1, name: "foo"
+      end
+      expect(results_a).to include("errors"=>false, "items"=>[{"index"=>{"_index"=>"test_index_name", "_type"=>"document", "_id"=>"1", "_version"=>1, "status"=>201}}])
+
+      results_b = subject.bulk do |b|
+        b.index  "document", 2, name: "bar"
+        b.delete "document", 1
+      end
+      expect(results_b).to include("errors"=>false, "items"=>[{"index"=>{"_index"=>"test_index_name", "_type"=>"document", "_id"=>"2", "_version"=>1, "status"=>201}}, {"delete"=>{"_index"=>"test_index_name", "_type"=>"document", "_id"=>"1", "_version"=>2, "status"=>200, "found"=>true}}])
+
+      subject.flush
+
+      expect { subject.get_document("document", 1) }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
+      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
+      results = subject.search("document", filter: { term: { name: "test" }})
+
+      expect(results["hits"]["total"]).to be 1
+
+      doc = results["hits"]["hits"][0]
+      expect(doc["_id"]).to eq "1"
+      expect(doc["_source"]).to eq({ "name" => "test" })
+    end
+
+    it "allows deleting by queryu" do
+      subject.index_document("document", 1, name: "foo")
+      subject.index_document("document", 2, name: "bar")
+
+      subject.delete_by_query("document", query: { term: { name: "foo" }})
+
+      expect { subject.get_document("document", 1) }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
+      expect { subject.get_document("document", 2) }.to_not raise_error
+
+      subject.flush
+    end
+  end
+end

data/spec/units/multi_search_spec.rb

@@ -0,0 +1,37 @@
+require "elasticity/search"
+require "elasticity/multi_search"
+
+RSpec.describe Elasticity::MultiSearch do
+  let :klass do
+    Class.new do
+      include ActiveModel::Model
+      attr_accessor :id, :name
+
+      def ==(other)
+        self.id == other.id && self.name == other.name
+      end
+    end
+  end
+
+  let :response do
+    {
+      "responses" => [
+        { "hits" => { "total" => 2, "hits" => [{"_source" => { "id" => 1, "name" => "foo" }}, {"_source" => { "id" => 2, "name" => "bar" }}]}},
+        { "hits" => { "total" => 1, "hits" => [{"_source" => { "id" => 3, "name" => "baz" }}]}},
+      ]
+    }
+  end
+
+  it "performs multi search" do
+    subject.add(:first, Elasticity::Search.new(double(:index, name: "index_first"), "document_first", { search: :first }), documents: klass)
+    subject.add(:second, Elasticity::Search.new(double(:index, name: "index_second"), "document_second", { search: :second }), documents: klass)
+
+    expect(Elasticity.config.client).to receive(:msearch).with(body: [
+      { index: "index_first", type: "document_first", body: { search: :first } },
+      { index: "index_second", type: "document_second", body: { search: :second } },
+    ]).and_return(response)
+
+    expect(Array(subject[:first])). to eq [klass.new(id: 1, name: "foo"), klass.new(id: 2, name: "bar")]
+    expect(Array(subject[:second])). to eq [klass.new(id: 3, name: "baz")]
+  end
+end

data/spec/units/search_spec.rb

@@ -0,0 +1,108 @@
+require "elasticity/search"
+
+RSpec.describe "Search" do
+  let(:index)          { double(:index) }
+  let(:document_type)  { "document" }
+  let(:body)           { {} }
+
+  let :full_response do
+    { "hits" => { "total" => 2, "hits" => [
+      {"_source" => { "id" => 1, "name" => "foo" }},
+      {"_source" => { "id" => 2, "name" => "bar" }},
+    ]}}
+  end
+
+  let :ids_response do
+    { "hits" => { "total" => 2, "hits" => [
+      {"_source" => { "id" => 1, "name" => "foo" }},
+      {"_source" => { "id" => 2, "name" => "bar" }},
+    ]}}
+  end
+
+  let :empty_response do
+    { "hits" => { "total" => 0, "hits" => [] }}
+  end
+
+  let :klass do
+    Class.new do
+      include ActiveModel::Model
+      attr_accessor :id, :name
+
+      def ==(other)
+        self.id == other.id && self.name == other.name
+      end
+    end
+  end
+
+  describe Elasticity::Search do
+    subject do
+      described_class.new(index, document_type, body)
+    end
+
+    it "searches the index and return document models" do
+      expect(index).to receive(:search).with(document_type, body).and_return(full_response)
+
+      docs = subject.documents(klass)
+      expected = [klass.new(id: 1, name: "foo"), klass.new(id: 2, name: "bar")]
+
+      expect(docs.total).to eq 2
+      expect(docs.size).to eq expected.size
+
+      expect(docs).to_not be_empty
+      expect(docs).to_not be_blank
+
+      expect(docs[0].name).to eq expected[0].name
+      expect(docs[1].name).to eq expected[1].name
+
+      expect(docs.each.first).to eq expected[0]
+      expect(Array(docs)).to eq expected
+    end
+
+    it "searches the index and return active record models" do
+      expect(index).to receive(:search).with(document_type, body.merge(_source: ["id"])).and_return(ids_response)
+
+      relation = double(:relation,
+        connection: double(:connection),
+        table_name: "table_name",
+        klass: double(:klass, primary_key: "id"),
+      )
+      allow(relation.connection).to receive(:quote_column_name) { |name| name }
+
+      expect(relation).to receive(:where).with(id: [1,2]).and_return(relation)
+      expect(relation).to receive(:order).with("FIELD(table_name.id,1,2)").and_return(relation)
+
+      expect(subject.active_records(relation).mapping).to be relation
+    end
+
+    it "return relation.none from activerecord relation with no matches" do
+      expect(index).to receive(:search).with(document_type, body.merge(_source: ["id"])).and_return(empty_response)
+
+      relation = double(:relation)
+      expect(relation).to receive(:none).and_return(relation)
+
+      expect(subject.active_records(relation).mapping).to be relation
+    end
+  end
+
+  describe Elasticity::DocumentSearchProxy do
+    let :search do
+      Elasticity::Search.new(index, "document", body)
+    end
+
+    subject do
+      described_class.new(search, klass)
+    end
+
+    it "automatically maps the documents into the provided Document class" do
+      expect(index).to receive(:search).with(document_type, body).and_return(full_response)
+      expect(Array(subject)).to eq [klass.new(id: 1, name: "foo"), klass.new(id: 2, name: "bar")]
+    end
+
+    it "delegates active_records for the underlying search" do
+      records = double(:records)
+      rel     = double(:relation)
+      expect(search).to receive(:active_records).with(rel).and_return(records)
+      expect(subject.active_records(rel)).to be records
+    end
+  end
+end

metadata

@@ -0,0 +1,199 @@
+--- !ruby/object:Gem::Specification
+name: es-elasticity
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Rodrigo Kochenburger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-07 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: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: elasticsearch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+description: Elasticity provides a higher level abstraction on top of [elasticsearch-ruby](https://github.com/elasticsearch/elasticsearch-ruby)
+  gem
+email:
+- rodrigo@doximity.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".simplecov"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/rake
+- bin/rspec
+- elasticity.gemspec
+- lib/elasticity.rb
+- lib/elasticity/document.rb
+- lib/elasticity/index.rb
+- lib/elasticity/multi_search.rb
+- lib/elasticity/search.rb
+- lib/elasticity/version.rb
+- lib/elasticity_base.rb
+- spec/rspec_config.rb
+- spec/units/document_spec.rb
+- spec/units/index_spec.rb
+- spec/units/multi_search_spec.rb
+- spec/units/search_spec.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.2.2
+signing_key: 
+specification_version: 4
+summary: ActiveModel-based library for working with ElasticSearch
+test_files:
+- spec/rspec_config.rb
+- spec/units/document_spec.rb
+- spec/units/index_spec.rb
+- spec/units/multi_search_spec.rb
+- spec/units/search_spec.rb
+has_rdoc: