mongoid-elasticsearch 0.2.1

data/lib/mongoid/elasticsearch.rb

@@ -0,0 +1,106 @@
+require "mongoid/elasticsearch/version"
+
+require 'elasticsearch'
+require 'active_support/concern'
+
+require 'mongoid/elasticsearch/utils'
+require 'mongoid/elasticsearch/es'
+require 'mongoid/elasticsearch/callbacks'
+require 'mongoid/elasticsearch/index'
+require 'mongoid/elasticsearch/indexing'
+require 'mongoid/elasticsearch/response'
+require 'mongoid/elasticsearch/slash_monkeypatch'
+
+module Mongoid
+  module Elasticsearch
+    mattr_accessor :prefix
+    self.prefix = ''
+
+    mattr_accessor :client_options
+    self.client_options = {}
+
+    mattr_accessor :registered_indexes
+    self.registered_indexes = []
+
+    extend ActiveSupport::Concern
+    included do
+      def self.es
+        @__es__ ||= Mongoid::Elasticsearch::Es.new(self)
+      end
+
+      # Add elasticsearch to the model
+      # @option index_name [String] name of the index for this model
+      # @option index_options [Hash] Index options to be passed to Elasticsearch
+      # when creating an index
+      # @option client_options [Hash] Options for Elasticsearch::Client.new
+      # @option wrapper [Symbol] Select what wrapper to use for results
+      # possible options:
+      # :model - creates a new model instance, set its attributes, and marks it as persisted
+      # :mash - Hashie::Mash for object-like access  (perfect for simple models, needs gem 'hashie')
+      # :none - raw hash
+      # :load - load models from Mongo by IDs
+      def self.elasticsearch!(options = {})
+        options = {
+          prefix_name: true,
+          index_name: nil,
+          client_options: {},
+          index_options: {},
+          index_mappings: nil,
+          wrapper: :model,
+          callbacks: true
+        }.merge(options)
+        
+        if options[:wrapper] == :model
+          attr_accessor :_type, :_score, :_source
+        end
+
+        cattr_accessor :es_client_options, :es_index_name, :es_index_options, :es_wrapper
+
+        self.es_client_options = Mongoid::Elasticsearch.client_options.dup.merge(options[:client_options])
+        self.es_index_name     = (options[:prefix_name] ? Mongoid::Elasticsearch.prefix : '') + (options[:index_name] || model_name.plural)
+        self.es_index_options  = options[:index_options]
+        self.es_wrapper        = options[:wrapper]
+
+        Mongoid::Elasticsearch.registered_indexes.push self.es_index_name
+
+        unless options[:index_mappings].nil?
+          self.es_index_options = self.es_index_options.deep_merge({
+            :mappings => {
+              es.index.type.to_sym => {
+                :properties => options[:index_mappings]
+              }
+            }
+          })
+        end
+
+        include Indexing
+        include Callbacks if options[:callbacks]
+
+        es.index.create
+      end
+    end
+
+    # search multiple models
+    def self.search(query, options = {}, wrapper = :model)
+      if query.is_a?(String)
+        query = {q: Utils.clean(query)}
+      end
+      # use `_all` or empty string to perform the operation on all indices
+      # regardless whether they are managed by Mongoid::Elasticsearch or not
+      unless query.key?(:index)
+        query.merge!(index: Mongoid::Elasticsearch.registered_indexes.join(','), ignore_indices: 'missing')
+      end
+
+      page = options[:page]
+      options[:per_page] ||= 50
+      per_page = options[:per_page]
+
+      query[:size] = ( per_page.to_i ) if per_page
+      query[:from] = ( page.to_i <= 1 ? 0 : (per_page.to_i * (page.to_i-1)) ) if page && per_page
+
+
+      client = ::Elasticsearch::Client.new Mongoid::Elasticsearch.client_options
+      Response.new(client, query, true, nil, wrapper, options)
+    end
+  end
+end

data/lib/mongoid-elasticsearch.rb

@@ -0,0 +1,2 @@
+require 'elasticsearch'
+require 'mongoid/elasticsearch'

data/mongoid-elasticsearch.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mongoid/elasticsearch/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mongoid-elasticsearch"
+  spec.version       = Mongoid::Elasticsearch::VERSION
+  spec.authors       = ["glebtv"]
+  spec.email         = ["glebtv@gmail.com"]
+  spec.description   = %q{Simple and easy integration of mongoid with the new elasticsearch gem}
+  spec.summary       = %q{Simple and easy integration of mongoid with the new elasticsearch gem}
+  spec.homepage      = "https://github.com/rs-pro/mongoid-elasticsearch"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "mongoid", [">= 4.0", "< 5.0"]
+  spec.add_dependency "elasticsearch", "~> 0.4.0"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "kaminari"
+  spec.add_development_dependency "database_cleaner"
+  spec.add_development_dependency "coveralls"
+end

data/spec/models/article.rb

@@ -0,0 +1,27 @@
+class Article
+  include Mongoid::Document
+  include Mongoid::Timestamps::Short
+  include ActiveModel::ForbiddenAttributesProtection
+
+  field :name
+  field :tags
+
+  include Mongoid::Elasticsearch
+  i_fields = {
+    name:     {type: 'string', analyzer: 'snowball'},
+    raw:      {type: 'string', index: :not_analyzed}
+  }
+
+  if Gem::Version.new(::Elasticsearch::Client.new.info['version']['number']) > Gem::Version.new('0.90.2')
+    i_fields[:suggest] = {type: 'completion'} 
+  end
+
+  elasticsearch! index_name: 'mongoid_es_news', prefix_name: false, index_mappings: {
+    name: {
+      type: 'multi_field',
+      fields: i_fields
+    },
+    tags: {type: 'string', include_in_all: false}
+  }, wrapper: :load
+end
+

data/spec/models/namespaced.rb

@@ -0,0 +1,22 @@
+module Namespaced
+  class Model
+    include Mongoid::Document
+    include Mongoid::Timestamps::Short
+    include ActiveModel::ForbiddenAttributesProtection
+
+    field :name
+
+    include Mongoid::Elasticsearch
+    elasticsearch! index_options: {
+      'namespaced/model' => {
+        mappings: {
+          properties: {
+            name: {
+              type: 'string'
+            }
+          }
+        }
+      }
+    }
+  end
+end

data/spec/models/nowrapper.rb

@@ -0,0 +1,9 @@
+class Nowrapper
+  include Mongoid::Document
+
+  field :name, type: String
+
+  include Mongoid::Elasticsearch
+  elasticsearch! wrapper: :none
+end
+

data/spec/models/post.rb

@@ -0,0 +1,13 @@
+class Post
+  include Mongoid::Document
+
+  field :name, type: String
+  field :content, type: String
+
+  include Mongoid::Elasticsearch
+  elasticsearch!
+  def as_indexed_json
+    {name: name, content: content}
+  end
+end
+

data/spec/mongoid_elasticsearch_spec.rb

@@ -0,0 +1,293 @@
+require "spec_helper"
+
+describe Article do
+  it 'properly uses options' do
+    Article.es_index_name.should eq 'mongoid_es_news'
+    Article.es.index.name.should eq 'mongoid_es_news'
+    Article.es.index.type.should eq 'articles'
+    Article.es_wrapper.should eq :load
+    Article.es_client_options.should eq({})
+  end
+
+  context 'index operations' do
+    it 'creates and destroys index' do
+      Article.es.index.exists?.should be_true
+      Article.es.index.delete
+      Article.es.index.exists?.should be_false
+      Article.es.index.create
+      Article.es.index.exists?.should be_true
+    end
+  end
+
+  context 'adding to index' do
+    it 'successfuly saves mongoid document' do
+      article = Article.new(name: 'test article name')
+      article.save.should be_true
+    end
+  end
+
+  context 'deleting from index' do
+    it 'deletes document from index when model is destroyed' do
+      Article.create(name: 'test article name')
+      Article.es.index.refresh
+      Article.es.all.count.should eq 1
+
+      Article.first.destroy
+      Article.es.index.refresh
+      Article.es.all.count.should eq 0
+    end
+  end
+
+  context 'searching' do
+    before :each do
+      @article_1 = Article.create!(name: 'test article name likes', tags: 'likely')
+      @article_2 = Article.create!(name: 'tests likely an another article title')
+      @article_3 = Article.create!(name: 'a strange name for this stuff')
+      Article.es.index.refresh
+    end
+
+    it 'searches and returns models' do
+      results = Article.es.search q: 'likely'
+      results.count.should eq 1
+      results.to_a.count.should eq 1
+      results.first.id.should eq @article_2.id
+      results.first.name.should eq @article_2.name
+    end
+
+    if Article.es.completion_supported?
+      it 'completion' do
+        Article.es.completion('te', 'name.suggest').should eq [
+          {"text"=>"test article name likes", "score"=>1.0},
+          {"text"=>"tests likely an another article title", "score"=>1.0}
+        ]
+      end
+    else
+      pending "completion suggester not supported in ES version #{Article.es.version}"
+    end
+  end
+
+  context 'pagination' do
+    before :each do
+      @articles = []
+      10.times { @articles << Article.create!(name: 'test') }
+      Article.es.index.refresh
+    end
+
+    it '#search' do
+      Article.es.search('test', per_page: 7, page: 2).to_a.size.should eq 3
+    end
+
+    it '#all' do
+      result = Article.es.all(per_page: 7, page: 2)
+      result.num_pages.should eq 2
+      result.current_page.should eq 2
+      result.total_entries.should eq 10
+      result.previous_page.should eq 1
+      result.next_page.should be_nil
+      result.to_a.size.should eq 3
+      result.out_of_bounds?.should be_false
+      result.first_page?.should be_false
+      result.last_page?.should be_true
+      
+      p1 = Article.es.all(per_page: 7, page: 1)
+      p1.out_of_bounds?.should be_false
+      p1.first_page?.should be_true
+      p1.last_page?.should be_false
+      p1.current_page.should eq 1
+      p1.next_page.should eq 2
+
+      p3 = Article.es.all(per_page: 7, page: 3)
+      p3.out_of_bounds?.should be_true
+
+      p1.length.should eq 7
+      all = (result.to_a + p1.to_a).map(&:id).map(&:to_s).sort
+      all.length.should eq 10
+      all.should eq @articles.map(&:id).map(&:to_s).sort
+    end
+  end
+end
+
+
+describe Post do
+  it 'properly uses options' do
+    Post.es_index_name.should eq 'mongoid_es_test_posts'
+    Post.es_wrapper.should eq :model
+    Post.es_client_options.should eq({})
+  end
+
+  context 'index operations' do
+    it 'does not create index with empty definition (ES will do it for us)' do
+      Post.es.index.exists?.should be_false
+      Post.es.index.create
+      Post.es.index.exists?.should be_false
+    end
+    it 'ES autocreates index on first index' do
+      Post.es.index.exists?.should be_false
+      Post.create!(name: 'test post')
+      Post.es.index.exists?.should be_true
+    end
+  end
+
+  context 'adding to index' do
+    it 'successfuly saves mongoid document' do
+      article = Post.new(name: 'test article name')
+      article.save.should be_true
+    end
+  end
+
+  context 'searching' do
+    before :each do
+      @post_1 = Post.create!(name: 'test article name')
+      @post_2 = Post.create!(name: 'another article title')
+      Post.es.index.refresh
+    end
+
+    it 'searches and returns models' do
+      Post.es.search('article').first.class.should eq Post
+      sleep 1
+      Post.es.search('article').count.should eq 2
+      Post.es.search('another').count.should eq 1
+      Post.es.search('another').first.id.should eq @post_2.id
+    end
+  end
+
+  context 'pagination' do
+    before :each do
+      10.times { Post.create(name: 'test') }
+      Post.es.index.refresh
+    end
+
+    it '#search' do
+      Post.es.search('test').size.should eq 10
+      Post.es.search('test', per_page: 7, page: 2).to_a.size.should eq 3
+    end
+
+    it '#all' do
+      Post.es.all.size.should eq 10
+      Post.es.all(per_page: 7, page: 2).to_a.size.should eq 3
+    end
+  end
+end
+
+describe Nowrapper do
+  it 'properly uses options' do
+    Nowrapper.es_index_name.should eq 'mongoid_es_test_nowrappers'
+    Nowrapper.es_wrapper.should eq :none
+  end
+
+  context 'searching' do
+    before :each do
+      @post_1 = Nowrapper.create!(name: 'test article name')
+      @post_2 = Nowrapper.create!(name: 'another article title')
+      Nowrapper.es.index.refresh
+    end
+
+    it 'searches and returns hashes' do
+      # #count uses _count
+      Nowrapper.es.search('article').count.should eq 2
+      # #size and #length fetch results
+      Nowrapper.es.search('article').length.should eq 2
+      Nowrapper.es.search('article').first.class.should eq Hash
+    end
+  end
+end
+
+describe "Multisearch" do
+  before :each do
+    @post_1 = Post.create!(name: 'test article name')
+    Post.es.index.refresh
+
+    @article_1 = Article.create!(name: 'test article name likes', tags: 'likely')
+    @article_2 = Article.create!(name: 'test likely an another article title')
+    Article.es.index.refresh
+
+    @ns_1 = Namespaced::Model.create!(name: 'test article name likes')
+    Namespaced::Model.es.index.refresh
+  end
+  it 'works' do
+    response = Mongoid::Elasticsearch.search 'test'
+    response.length.should eq 4
+    response.to_a.map(&:class).map(&:name).uniq.sort.should eq ['Article', 'Namespaced::Model', 'Post']
+    response.select { |r| r.class == Article && r.id == @article_1.id }.first.should_not be_nil
+  end
+end
+
+describe Namespaced::Model do
+  it 'properly uses options' do
+    Namespaced::Model.es_index_name.should eq 'mongoid_es_test_namespaced_models'
+    Namespaced::Model.es.index.name.should eq 'mongoid_es_test_namespaced_models'
+    Namespaced::Model.es.index.type.should eq 'namespaced/models'
+    Namespaced::Model.es_wrapper.should eq :model
+    Namespaced::Model.es_client_options.should eq({})
+  end
+
+  context 'index operations' do
+    it 'creates and destroys index' do
+      Namespaced::Model.es.index.exists?.should be_true
+      Namespaced::Model.es.index.delete
+      Namespaced::Model.es.index.exists?.should be_false
+      Namespaced::Model.es.index.create
+      Namespaced::Model.es.index.exists?.should be_true
+    end
+  end
+
+  context 'adding to index' do
+    it 'successfuly saves mongoid document' do
+      article = Namespaced::Model.new(name: 'test article name')
+      article.save.should be_true
+    end
+    it 'successfuly destroys mongoid document' do
+      article = Namespaced::Model.create(name: 'test article name')
+      Namespaced::Model.es.index.refresh
+      Namespaced::Model.es.all.count.should eq 1
+      article.destroy
+      Namespaced::Model.es.index.refresh
+      Namespaced::Model.es.all.count.should eq 0
+    end
+  end
+
+  context 'searching' do
+    before :each do
+      @article_1 = Namespaced::Model.create!(name: 'test article name likes')
+      @article_2 = Namespaced::Model.create!(name: 'tests likely an another article title')
+      @article_3 = Namespaced::Model.create!(name: 'a strange name for this stuff')
+      Namespaced::Model.es.index.refresh
+    end
+
+    it 'searches and returns models' do
+      results = Namespaced::Model.es.search q: 'likely'
+      results.count.should eq 1
+      results.to_a.count.should eq 1
+      results.first.id.should eq @article_2.id
+      results.first.name.should eq @article_2.name
+    end
+  end
+
+  context 'pagination' do
+    before :each do
+      @articles = []
+      20.times { @articles << Namespaced::Model.create!(name: 'test') }
+      Namespaced::Model.es.index.refresh
+    end
+
+    it '#search' do
+      Namespaced::Model.es.search('test', per_page: 10, page: 2).to_a.size.should eq 10
+      Namespaced::Model.es.search('test', per_page: 30, page: 2).to_a.size.should eq 0
+      Namespaced::Model.es.search('test', per_page: 2, page: 2).to_a.size.should eq 2
+    end
+
+    it '#all' do
+      result = Namespaced::Model.es.all(per_page: 7, page: 3)
+      result.num_pages.should eq 3
+      result.to_a.size.should eq 6
+      p1 = Namespaced::Model.es.all(per_page: 7, page: 1).to_a
+      p2 = Namespaced::Model.es.all(per_page: 7, page: 2).to_a
+      p1.length.should eq 7
+      p2.length.should eq 7
+      all = (result.to_a + p1 + p2).map(&:id).map(&:to_s).sort
+      all.length.should eq 20
+      all.should eq @articles.map(&:id).map(&:to_s).sort
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,56 @@
+require 'coveralls'
+Coveralls.wear!
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+MODELS = File.join(File.dirname(__FILE__), "models")
+
+require "rubygems"
+require "rspec"
+require "mongoid"
+require "database_cleaner"
+
+require "mongoid-elasticsearch"
+
+Mongoid::Elasticsearch.prefix = "mongoid_es_test_"
+
+Dir["#{MODELS}/*.rb"].each { |f| require f }
+
+Mongoid.configure do |config|
+  config.connect_to "mongoid_elasticsearch_test"
+end
+Mongoid.logger = Logger.new($stdout)
+
+
+DatabaseCleaner.orm = "mongoid"
+
+RSpec.configure do |config|
+  config.before(:all) do
+    DatabaseCleaner.strategy = :truncation
+    Article.es.index.reset
+    Post.es.index.reset
+    Nowrapper.es.index.reset
+    Namespaced::Model.es.index.reset
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+    Article.es.index.reset
+    Post.es.index.reset
+    Nowrapper.es.index.reset
+    Namespaced::Model.es.index.reset
+  end
+
+  config.after(:all) do
+    DatabaseCleaner.clean
+    Article.es.index.delete
+    Post.es.index.delete
+    Nowrapper.es.index.delete
+    Namespaced::Model.es.index.delete
+  end
+end