chewy 0.0.1 → 0.1.0

data/lib/chewy/type/observe.rb

@@ -4,9 +4,21 @@ module Chewy
       extend ActiveSupport::Concern
 
       module ActiveRecordMethods
-        def update_elasticsearch(type_name, &block)
+        def update_index(type_name, *args, &block)
+          options = args.extract_options!
+          method = args.first
+
           update = Proc.new do
-            Chewy.derive_type(type_name).update_index(instance_eval(&block))
+            backreference = if method && method.to_s == 'self'
+              self
+            elsif method
+              send(method)
+            else
+              instance_eval(&block)
+            end
+
+            Chewy.derive_type(type_name).update_index(backreference,
+              options.reverse_merge(urgent: Chewy.urgent_update))
           end
 
           after_save &update
@@ -15,19 +27,17 @@ module Chewy
       end
 
       module ClassMethods
-        def update_index(objects)
-          if Chewy.observing_enabled
-            if Chewy.atomic?
-              ids = if objects.is_a?(::ActiveRecord::Relation)
-                objects.pluck(:id)
-              else
-                Array.wrap(objects).map { |object| object.respond_to?(:id) ? object.id : object.to_i }
-              end
-              Chewy.atomic_stash self, ids
+        def update_index(objects, options = {})
+          if Chewy.atomic?
+            ids = if objects.is_a?(::ActiveRecord::Relation)
+              objects.pluck(:id)
             else
-              import objects
-            end if objects
-          end
+              Array.wrap(objects).map { |object| object.respond_to?(:id) ? object.id : object.to_i }
+            end
+            Chewy.stash self, ids
+          else
+            import(objects) if options[:urgent]
+          end if objects
 
           true
         end

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/tasks/chewy.rake

@@ -0,0 +1,27 @@
+namespace :chewy do
+  namespace :reset do
+    desc 'Destroy, recreate and import data for all found indexes'
+    task all: :environment do
+      Rails.application.config.paths['app/chewy'].existent.each do |dir|
+        Dir.glob(File.join(dir, '**/*.rb')).each { |file| require file }
+      end
+
+      Chewy::Index.descendants.each do |index|
+        puts "Resetting #{index}"
+        index.reset
+      end
+    end
+  end
+
+  desc 'Destroy, recreate and import data to specified index'
+  task :reset, [:index] => :environment do |task, args|
+    "#{args[:index].camelize}Index".constantize.reset
+  end
+
+  desc 'Updates specified index'
+  task :update, [:index] => :environment do |task, args|
+    index = "#{args[:index].camelize}Index".constantize
+    raise "Index `#{index.index_name}` does not exists. Use rake chewy:reset[index] to create and update it." unless index.exists?
+    index.import
+  end
+end

data/spec/chewy/config_spec.rb

@@ -4,7 +4,17 @@ describe Chewy::Config do
   include ClassHelpers
   subject { described_class.send(:new) }
 
-  its(:observing_enabled) { should be_true }
+  its(:query_mode) { should == :must }
+  its(:filter_mode) { should == :and }
+  its(:logger) { should be_nil }
+  its(:client_options) { should_not have_key :logger }
+
+  describe '#logger' do
+    before { subject.logger = double(:logger) }
+
+    its(:logger) { should_not be_nil }
+    its(:client_options) { should have_key :logger }
+  end
 
   describe '#atomic?' do
     its(:atomic?) { should be_false }
@@ -21,30 +31,38 @@ describe Chewy::Config do
     let(:dummy_type) { DummiesIndex::Dummy }
 
     specify { subject.atomic { 42 }.should == 42 }
-    specify { expect { subject.atomic { subject.atomic_stash Class.new, 42 } }.to raise_error ArgumentError }
-    specify { subject.atomic { subject.atomic { subject.atomic_stash.should == [{}, {}] } } }
+    specify { expect { subject.atomic { subject.stash Class.new, 42 } }.to raise_error ArgumentError }
+    specify { subject.atomic { subject.atomic { subject.stash.should == [{}, {}] } } }
 
     specify do
-      expect(dummy_type).to receive(:import).with([1,2,3]).once
+      expect(dummy_type).to receive(:import).with([1, 2, 3]).once
       subject.atomic do
-        subject.atomic_stash dummy_type, 1, 2
-        subject.atomic_stash dummy_type, [2, 3]
+        subject.stash dummy_type, [1, 2]
+        subject.stash dummy_type, [2, 3]
       end
     end
 
     specify do
-      expect(dummy_type).to receive(:import).with([2,3]).once
-      expect(dummy_type).to receive(:import).with([1,2]).once
+      expect(dummy_type).to receive(:import).with([1, 2]).once
+      subject.atomic do
+        subject.stash dummy_type, [1, 2]
+        raise
+      end rescue nil
+    end
+
+    specify do
+      expect(dummy_type).to receive(:import).with([2, 3]).once
+      expect(dummy_type).to receive(:import).with([1, 2]).once
       subject.atomic do
-        subject.atomic_stash dummy_type, [2, 3]
+        subject.stash dummy_type, [2, 3]
         subject.atomic do
-          subject.atomic_stash dummy_type, 1, 2
+          subject.stash dummy_type, [1, 2]
         end
       end
     end
   end
 
-  describe '#atomic_stash' do
-    specify { subject.atomic { subject.atomic_stash.should == [{}] } }
+  describe '#stash' do
+    specify { subject.atomic { subject.stash.should == [{}] } }
   end
 end

data/spec/chewy/fields/base_spec.rb

@@ -15,13 +15,19 @@ describe Chewy::Fields::Base do
     context do
       before do
         field.nested(described_class.new(:subname1, value: ->(o){ o.subvalue1 }))
-        field.nested(described_class.new(:subname2))
+        field.nested(described_class.new(:subname2, value: ->{ subvalue2 }))
+        field.nested(described_class.new(:subname3))
       end
 
-      specify { field.compose(double(value: double(subvalue1: 'hello', subname2: 'world')))
-        .should == {name: {'subname1' => 'hello', 'subname2' => 'world'}} }
-      specify { field.compose(double(value: [double(subvalue1: 'hello1', subname2: 'world1'), double(subvalue1: 'hello2', subname2: 'world2')]))
-        .should == {name: [{'subname1' => 'hello1', 'subname2' => 'world1'}, {'subname1' => 'hello2', 'subname2' => 'world2'}]} }
+      specify { field.compose(double(value: double(subvalue1: 'hello', subvalue2: 'value', subname3: 'world')))
+        .should == {name: {'subname1' => 'hello', 'subname2' => 'value', 'subname3' => 'world'}} }
+      specify { field.compose(double(value: [
+        double(subvalue1: 'hello1', subvalue2: 'value1', subname3: 'world1'),
+        double(subvalue1: 'hello2', subvalue2: 'value2', subname3: 'world2')
+      ])).should == {name: [
+        {'subname1' => 'hello1', 'subname2' => 'value1', 'subname3' => 'world1'},
+        {'subname1' => 'hello2', 'subname2' => 'value2', 'subname3' => 'world2'}
+      ]} }
     end
 
     context do

data/spec/chewy/index/actions_spec.rb

@@ -6,48 +6,48 @@ describe Chewy::Index::Actions do
 
   before { stub_index :dummies }
 
-  describe '.index_exists?' do
-    specify { DummiesIndex.index_exists?.should be_false }
+  describe '.exists?' do
+    specify { DummiesIndex.exists?.should be_false }
 
     context do
-      before { DummiesIndex.index_create }
-      specify { DummiesIndex.index_exists?.should be_true }
+      before { DummiesIndex.create }
+      specify { DummiesIndex.exists?.should be_true }
     end
   end
 
-  describe '.index_create' do
-    specify { DummiesIndex.index_create.should be_true }
+  describe '.create' do
+    specify { DummiesIndex.create.should be_true }
 
     context do
-      before { DummiesIndex.index_create }
-      specify { DummiesIndex.index_create.should be_false }
+      before { DummiesIndex.create }
+      specify { DummiesIndex.create.should be_false }
     end
   end
 
-  describe '.index_create!' do
-    specify { expect { DummiesIndex.index_create! }.not_to raise_error }
+  describe '.create!' do
+    specify { expect { DummiesIndex.create! }.not_to raise_error }
 
     context do
-      before { DummiesIndex.index_create }
-      specify { expect { DummiesIndex.index_create! }.to raise_error }
+      before { DummiesIndex.create }
+      specify { expect { DummiesIndex.create! }.to raise_error }
     end
   end
 
-  describe '.index_delete' do
-    specify { DummiesIndex.index_delete.should be_false }
+  describe '.delete' do
+    specify { DummiesIndex.delete.should be_false }
 
     context do
-      before { DummiesIndex.index_create }
-      specify { DummiesIndex.index_delete.should be_true }
+      before { DummiesIndex.create }
+      specify { DummiesIndex.delete.should be_true }
     end
   end
 
-  describe '.index_delete!' do
-    specify { expect { DummiesIndex.index_delete! }.to raise_error }
+  describe '.delete!' do
+    specify { expect { DummiesIndex.delete! }.to raise_error }
 
     context do
-      before { DummiesIndex.index_create }
-      specify { expect { DummiesIndex.index_delete! }.not_to raise_error }
+      before { DummiesIndex.create }
+      specify { expect { DummiesIndex.delete! }.not_to raise_error }
     end
   end
 end

data/spec/chewy/index/search_spec.rb

@@ -10,12 +10,12 @@ describe Chewy::Index::Search do
     end
   end
 
-  let(:product) { ProductsIndex.product }
+  let(:product) { ProductsIndex::Product }
 
-  describe '.search' do
-    specify do
-      product.search.should be_a Chewy::Query
-    end
+  describe '.all' do
+    specify { product.all.should be_a Chewy::Query }
+    specify { product.all.object_id.should_not == product.all.object_id }
+    specify { product.all.should == product.all }
   end
 
   describe '.search_string' do

data/spec/chewy/index_spec.rb

@@ -3,20 +3,40 @@ require 'spec_helper'
 describe Chewy::Index do
   include ClassHelpers
 
-  describe '.define_type' do
-    context 'blank name' do
+  before do
+    stub_index(:dummies) do
+      define_type :dummy
+    end
+  end
+
+  describe '.client' do
+    specify { stub_index(:dummies1).client.should == stub_index(:dummies2).client }
+
+    context do
       before do
-        stub_index(:dummies) do
-          define_type :dummy
-        end
+        stub_index(:dummies1)
+        stub_index(:dummies2, Dummies1Index)
       end
 
-      specify { DummiesIndex.types.should have_key 'dummy' }
-      specify { DummiesIndex.types['dummy'].should be < Chewy::Type::Base }
-      specify { DummiesIndex.types['dummy'].type_name.should == 'dummy' }
+      specify { Dummies1Index.client.should == Dummies2Index.client }
     end
   end
 
+  describe '.type_hash' do
+    specify { DummiesIndex.type_hash['dummy'].should == DummiesIndex::Dummy }
+    specify { DummiesIndex.type_hash.should have_key 'dummy' }
+    specify { DummiesIndex.type_hash['dummy'].should be < Chewy::Type::Base }
+    specify { DummiesIndex.type_hash['dummy'].type_name.should == 'dummy' }
+  end
+
+  specify { DummiesIndex.type_names.should == DummiesIndex.type_hash.keys }
+
+  describe '.types' do
+    specify { DummiesIndex.types.should == DummiesIndex.type_hash.values }
+    specify { DummiesIndex.types(:dummy).should be_a Chewy::Query }
+    specify { DummiesIndex.types(:user).should be_a Chewy::Query }
+  end
+
   describe '.index_name' do
     specify { expect { Class.new(Chewy::Index).index_name }.to raise_error Chewy::UndefinedIndex }
     specify { Class.new(Chewy::Index) { index_name :myindex }.index_name.should == 'myindex' }

data/spec/chewy/query/context_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+describe Chewy::Query::Context do
+  def Bool options
+    Chewy::Query::Nodes::Bool.new.tap do |bool|
+      bool.must(*options[:must]) if options[:must].present?
+      bool.must_not(*options[:must_not]) if options[:must_not].present?
+      bool.should(*options[:should]) if options[:should].present?
+    end
+  end
+
+  %w(field group and or not raw exists missing prefix regexp range equal query script).each do |method|
+    define_method method.camelize do |*args|
+      "Chewy::Query::Nodes::#{method.camelize}".constantize.new *args
+    end
+  end
+
+  def query &block
+    Chewy::Query::Context.new(&block).__result__
+  end
+
+  context 'outer scope' do
+    let(:email) { 'email' }
+    specify { query { email }.should be_eql Field(:email) }
+    specify { query { o{email} }.should == 'email' }
+  end
+
+  context 'field' do
+    let(:email) { 'email' }
+    specify { query { f(:email) }.should be_eql Field(:email) }
+    specify { query { f{ :email } }.should be_eql Field(:email) }
+    specify { query { f{ email } }.should be_eql Field(:email) }
+    specify { query { email }.should be_eql Field(:email) }
+    specify { query { emails.first }.should be_eql Field('emails.first') }
+    specify { query { emails.first.second }.should be_eql Field('emails.first.second') }
+  end
+
+  context 'term' do
+    specify { query { email == 'email' }.should be_eql Equal(:email, 'email') }
+    specify { query { name != 'name' }.should be_eql Not(Equal(:name, 'name')) }
+    specify { query { email == ['email1', 'email2'] }.should be_eql Equal(:email, ['email1', 'email2']) }
+    specify { query { email != ['email1', 'email2'] }.should be_eql Not(Equal(:email, ['email1', 'email2'])) }
+    specify { query { email(execution: :bool) == ['email1', 'email2'] }
+      .should be_eql Equal(:email, ['email1', 'email2'], execution: :bool) }
+    specify { query { email(:bool) == ['email1', 'email2'] }
+      .should be_eql Equal(:email, ['email1', 'email2'], execution: :bool) }
+    specify { query { email(:b) == ['email1', 'email2'] }
+      .should be_eql Equal(:email, ['email1', 'email2'], execution: :bool) }
+  end
+
+  context 'bool' do
+    specify { query { must(email == 'email') }.should be_eql Bool(must: [Equal(:email, 'email')]) }
+    specify { query { must_not(email == 'email') }.should be_eql Bool(must_not: [Equal(:email, 'email')]) }
+    specify { query { should(email == 'email') }.should be_eql Bool(should: [Equal(:email, 'email')]) }
+    specify { query {
+      must(email == 'email').should(address != 'address', age == 42)
+      .must_not(sex == 'm').must(name == 'name')
+    }.should be_eql Bool(
+      must: [Equal(:email, 'email'), Equal(:name, 'name')],
+      must_not: [Equal(:sex, 'm')],
+      should: [Not(Equal(:address, 'address')), Equal(:age, 42)]
+    ) }
+  end
+
+  context 'exists' do
+    specify { query { email? }.should be_eql Exists(:email) }
+    specify { query { !!email? }.should be_eql Exists(:email) }
+    specify { query { emails.first? }.should be_eql Exists('emails.first') }
+    specify { query { !!emails.first? }.should be_eql Exists('emails.first') }
+    specify { query { emails != nil }.should be_eql Exists('emails') }
+    specify { query { !(emails == nil) }.should be_eql Exists('emails') }
+  end
+
+  context 'missing' do
+    specify { query { !email }.should be_eql Missing(:email) }
+    specify { query { !email? }.should be_eql Missing(:email, null_value: true) }
+    specify { query { !emails.first }.should be_eql Missing('emails.first') }
+    specify { query { !emails.first? }.should be_eql Missing('emails.first', null_value: true) }
+    specify { query { emails == nil }.should be_eql Missing('emails', existence: false, null_value: true) }
+    specify { query { emails.first == nil }.should be_eql Missing('emails.first', existence: false, null_value: true) }
+  end
+
+  context 'range' do
+    specify { query { age > 42 }.should be_eql Range(:age, gt: 42) }
+    specify { query { age >= 42 }.should be_eql Range(:age, gt: 42, left_closed: true) }
+    specify { query { age < 42 }.should be_eql Range(:age, lt: 42) }
+    specify { query { age <= 42 }.should be_eql Range(:age, lt: 42, right_closed: true) }
+
+    specify { query { age == (30..42) }.should be_eql Range(:age, gt: 30, lt: 42) }
+    specify { query { age == [30..42] }.should be_eql Range(:age, gt: 30, lt: 42, left_closed: true, right_closed: true) }
+    specify { query { (age > 30) & (age < 42) }.should be_eql Range(:age, gt: 30, lt: 42) }
+    specify { query { (age > 30) & (age <= 42) }.should be_eql Range(:age, gt: 30, lt: 42, right_closed: true) }
+    specify { query { (age >= 30) & (age < 42) }.should be_eql Range(:age, gt: 30, lt: 42, left_closed: true) }
+    specify { query { (age >= 30) & (age <= 42) }.should be_eql Range(:age, gt: 30, lt: 42, right_closed: true, left_closed: true) }
+    specify { query { (age > 30) | (age < 42) }.should be_eql Or(Range(:age, gt: 30), Range(:age, lt: 42)) }
+  end
+
+  context 'prefix' do
+    specify { query { name =~ 'nam' }.should be_eql Prefix(:name, 'nam') }
+    specify { query { name !~ 'nam' }.should be_eql Not(Prefix(:name, 'nam')) }
+  end
+
+  context 'regexp' do
+    specify { query { name =~ /name/ }.should be_eql Regexp(:name, 'name') }
+    specify { query { name == /name/ }.should be_eql Regexp(:name, 'name') }
+    specify { query { name !~ /name/ }.should be_eql Not(Regexp(:name, 'name')) }
+    specify { query { name != /name/ }.should be_eql Not(Regexp(:name, 'name')) }
+    specify { query { name(:anystring, :intersection) =~ /name/ }.should be_eql Regexp(:name, 'name', flags: %w(anystring intersection)) }
+  end
+
+  context 'query' do
+    let(:some_query) { 'some query' }
+    specify { query { q('some query') }.should be_eql Query('some query') }
+    specify { query { q{'some query'} }.should be_eql Query('some query') }
+    specify { query { q{ some_query } }.should be_eql Query('some query') }
+  end
+
+  context 'raw' do
+    let(:raw_query) { {term: {name: 'name'}} }
+    specify { query { r(term: {name: 'name'}) }.should be_eql Raw(term: {name: 'name'}) }
+    specify { query { r{ {term: {name: 'name'}} } }.should be_eql Raw(term: {name: 'name'}) }
+    specify { query { r{ raw_query } }.should be_eql Raw(term: {name: 'name'}) }
+  end
+
+  context 'script' do
+    let(:some_script) { 'some script' }
+    specify { query { s('some script') }.should be_eql Script('some script') }
+    specify { query { s('some script', param1: 42) }.should be_eql Script('some script', param1: 42) }
+    specify { query { s{'some script'} }.should be_eql Script('some script') }
+    specify { query { s(param1: 42) { some_script } }.should be_eql Script('some script', param1: 42) }
+  end
+
+  context 'and or not' do
+    specify { query { (email == 'email') & (name == 'name') }
+      .should be_eql And(Equal(:email, 'email'), Equal(:name, 'name')) }
+    specify { query { (email == 'email') | (name == 'name') }
+      .should be_eql Or(Equal(:email, 'email'), Equal(:name, 'name')) }
+    specify { query { !(email == 'email') }.should be_eql Not(Equal(:email, 'email')) }
+
+    specify { query { (email == 'email') & (name == 'name') | (address != 'address') }
+      .should be_eql Or(
+        And(
+          Equal(:email, 'email'),
+          Equal(:name, 'name')
+        ),
+        Not(Equal(:address, 'address'))
+      ) }
+    specify { query { (email == 'email') & ((name == 'name') | (address != 'address')) }
+      .should be_eql And(
+        Equal(:email, 'email'),
+        Or(
+          Equal(:name, 'name'),
+          Not(Equal(:address, 'address')),
+        )
+      ) }
+    specify { query { (email == 'email') & ((name == 'name') & (address != 'address')) }
+      .should be_eql And(
+        Equal(:email, 'email'),
+        Equal(:name, 'name'),
+        Not(Equal(:address, 'address')),
+      ) }
+    specify { query { ((email == 'email') | (name == 'name')) | (address != 'address') }
+      .should be_eql Or(
+        Equal(:email, 'email'),
+        Equal(:name, 'name'),
+        Not(Equal(:address, 'address')),
+      ) }
+    specify { query { !((email == 'email') | (name == 'name')) }
+      .should be_eql Not(Or(Equal(:email, 'email'), Equal(:name, 'name'))) }
+    specify { query { !!((email == 'email') | (name == 'name')) }
+      .should be_eql Or(Equal(:email, 'email'), Equal(:name, 'name')) }
+  end
+end