chewy 0.0.1

data/lib/chewy/type/wrapper.rb

@@ -0,0 +1,35 @@
+module Chewy
+  module Type
+    module Wrapper
+      extend ActiveSupport::Concern
+
+      attr_accessor :attributes
+
+      def initialize(attributes = {})
+        @attributes = attributes.stringify_keys
+      end
+
+      def ==(other)
+        if other.is_a?(Chewy::Type::Base)
+          self.class == other.class && (respond_to?(:id) ? id == other.id : attributes == other.attributes)
+        elsif other.respond_to?(:id)
+          id.to_s == other.id.to_s
+        else
+          false
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        if @attributes.key?(method.to_s)
+          @attributes[method.to_s]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, _)
+        @attributes.key?(method.to_s) || super
+      end
+    end
+  end
+end

data/lib/chewy/version.rb

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

data/spec/chewy/config_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Chewy::Config do
+  include ClassHelpers
+  subject { described_class.send(:new) }
+
+  its(:observing_enabled) { should be_true }
+
+  describe '#atomic?' do
+    its(:atomic?) { should be_false }
+    specify { subject.atomic { subject.atomic?.should be_true } }
+    specify { subject.atomic { }; subject.atomic?.should be_false }
+  end
+
+  describe '#atomic' do
+    before do
+      stub_index(:dummies) do
+        define_type :dummy
+      end
+    end
+    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 do
+      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]
+      end
+    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.atomic do
+          subject.atomic_stash dummy_type, 1, 2
+        end
+      end
+    end
+  end
+
+  describe '#atomic_stash' do
+    specify { subject.atomic { subject.atomic_stash.should == [{}] } }
+  end
+end

data/spec/chewy/fields/base_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Chewy::Fields::Base do
+  specify { described_class.new('name').name.should == :name }
+  specify { described_class.new('name', type: 'integer').options[:type].should == 'integer' }
+
+  describe '#compose' do
+    let(:field) { described_class.new(:name, value: ->(o){ o.value }) }
+
+    specify { field.compose(double(value: 'hello')).should == {name: 'hello'} }
+    specify { field.compose(double(value: ['hello', 'world'])).should == {name: ['hello', 'world']} }
+
+    specify { described_class.new(:name).compose(double(name: 'hello')).should == {name: 'hello'} }
+
+    context do
+      before do
+        field.nested(described_class.new(:subname1, value: ->(o){ o.subvalue1 }))
+        field.nested(described_class.new(:subname2))
+      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'}]} }
+    end
+
+    context do
+      let(:field) { described_class.new(:name, type: 'multi_field') }
+      before do
+        field.nested(described_class.new(:name))
+        field.nested(described_class.new(:untouched))
+      end
+
+      specify { field.compose(double(name: 'Alex')).should == {name: 'Alex'} }
+    end
+  end
+
+  describe '#nested' do
+    let(:field) { described_class.new(:name) }
+
+    specify { expect { field.nested(described_class.new(:name1)) }
+      .to change { field.nested[:name1] }.from(nil).to(an_instance_of(described_class))  }
+  end
+
+  describe '#mappings_hash' do
+    let(:field) { described_class.new(:name, type: 'string') }
+    let(:fields1) { 2.times.map { |i| described_class.new("name#{i+1}", type: "string#{i+1}") } }
+    let(:fields2) { 2.times.map { |i| described_class.new("name#{i+3}", type: "string#{i+3}") } }
+    before do
+      fields1.each { |m| field.nested(m) }
+      fields2.each { |m| fields1[0].nested(m) }
+    end
+
+    specify { field.mappings_hash.should == {name: {type: 'string', properties: {
+      name1: {type: 'string1', properties: {
+        name3: {type: 'string3'}, name4: {type: 'string4'}
+      }}, name2: {type: 'string2'}
+    }}} }
+
+    context do
+      let(:field) { described_class.new(:name, type: 'multi_field') }
+
+      specify { field.mappings_hash.should == {name: {type: 'multi_field', fields: {
+        name1: {type: 'string1', properties: {
+          name3: {type: 'string3'}, name4: {type: 'string4'}
+        }}, name2: {type: 'string2'}
+      }}} }
+    end
+  end
+end

data/spec/chewy/fields/default_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe Chewy::Fields::Default do
+  specify { described_class.new('name').options[:type].should == 'string' }
+  # TODO: add 'should_behave_like base_field'
+end

data/spec/chewy/fields/root_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe Chewy::Fields::Root do
+  specify { described_class.new('name').value.should be_a(Proc) }
+  # TODO: add 'should_behave_like base_field'
+end

data/spec/chewy/index/actions_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Chewy::Index::Actions do
+  include ClassHelpers
+  before { Chewy::Index.client.indices.delete }
+
+  before { stub_index :dummies }
+
+  describe '.index_exists?' do
+    specify { DummiesIndex.index_exists?.should be_false }
+
+    context do
+      before { DummiesIndex.index_create }
+      specify { DummiesIndex.index_exists?.should be_true }
+    end
+  end
+
+  describe '.index_create' do
+    specify { DummiesIndex.index_create.should be_true }
+
+    context do
+      before { DummiesIndex.index_create }
+      specify { DummiesIndex.index_create.should be_false }
+    end
+  end
+
+  describe '.index_create!' do
+    specify { expect { DummiesIndex.index_create! }.not_to raise_error }
+
+    context do
+      before { DummiesIndex.index_create }
+      specify { expect { DummiesIndex.index_create! }.to raise_error }
+    end
+  end
+
+  describe '.index_delete' do
+    specify { DummiesIndex.index_delete.should be_false }
+
+    context do
+      before { DummiesIndex.index_create }
+      specify { DummiesIndex.index_delete.should be_true }
+    end
+  end
+
+  describe '.index_delete!' do
+    specify { expect { DummiesIndex.index_delete! }.to raise_error }
+
+    context do
+      before { DummiesIndex.index_create }
+      specify { expect { DummiesIndex.index_delete! }.not_to raise_error }
+    end
+  end
+end

data/spec/chewy/index/client_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Chewy::Index::Client do
+  include ClassHelpers
+
+  describe '.client' do
+    specify { stub_index(:dummies1).client.should == stub_index(:dummies2).client }
+
+    context do
+      before do
+        stub_index(:dummies1)
+        stub_index(:dummies2, Dummies1Index)
+      end
+
+      specify { Dummies1Index.client.should == Dummies2Index.client }
+    end
+  end
+end

data/spec/chewy/index/search_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Chewy::Index::Search do
+  include ClassHelpers
+
+  before do
+    stub_index(:products) do
+      define_type :product
+      define_type :product2
+    end
+  end
+
+  let(:product) { ProductsIndex.product }
+
+  describe '.search' do
+    specify do
+      product.search.should be_a Chewy::Query
+    end
+  end
+
+  describe '.search_string' do
+    specify do
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(q: 'hello')).twice
+      ProductsIndex.search_string('hello')
+      product.search_string('hello')
+    end
+
+    specify do
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(explain: true)).twice
+      ProductsIndex.search_string('hello', explain: true)
+      product.search_string('hello', explain: true)
+    end
+
+    specify do
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: 'products', type: ['product', 'product2']))
+      ProductsIndex.search_string('hello')
+    end
+
+    specify do
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: 'products', type: 'product'))
+      product.search_string('hello')
+    end
+  end
+
+  describe '.search_index' do
+    specify { ProductsIndex.search_index.should == ProductsIndex }
+    specify { product.search_index.should == ProductsIndex }
+  end
+
+  describe '.search_type' do
+    specify { ProductsIndex.search_type.should == ['product', 'product2'] }
+    specify { product.search_type.should == 'product' }
+  end
+end

data/spec/chewy/index_spec.rb

@@ -0,0 +1,65 @@
+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
+
+      specify { DummiesIndex.types.should have_key 'dummy' }
+      specify { DummiesIndex.types['dummy'].should be < Chewy::Type::Base }
+      specify { DummiesIndex.types['dummy'].type_name.should == 'dummy' }
+    end
+  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' }
+    specify { stub_const('DeveloperIndex', Class.new(Chewy::Index)).index_name.should == 'developer' }
+    specify { stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name.should == 'developers' }
+  end
+
+  describe '.index_params' do
+    specify { stub_index(:documents).index_params.should == {} }
+    specify { stub_index(:documents) { settings number_of_shards: 1 }.index_params.keys.should == [:settings] }
+    specify { stub_index(:documents) do
+      define_type :document do
+        field :name, type: 'string'
+      end
+    end.index_params.keys.should == [:mappings] }
+    specify { stub_index(:documents) do
+      settings number_of_shards: 1
+      define_type :document do
+        field :name, type: 'string'
+      end
+    end.index_params.keys.should =~ [:mappings, :settings] }
+  end
+
+  describe '.settings_hash' do
+    specify { stub_index(:documents).settings_hash.should == {} }
+    specify { stub_index(:documents) { settings number_of_shards: 1 }.settings_hash.should == {settings: {number_of_shards: 1}} }
+  end
+
+  describe '.mappings_hash' do
+    specify { stub_index(:documents).mappings_hash.should == {} }
+    specify { stub_index(:documents) { define_type :document }.mappings_hash.should == {} }
+    specify { stub_index(:documents) do
+      define_type :document do
+        field :name, type: 'string'
+      end
+    end.mappings_hash.should == {mappings: {document: {properties: {name: {type: 'string'}}}}} }
+    specify { stub_index(:documents) do
+      define_type :document do
+        field :name, type: 'string'
+      end
+      define_type :document2 do
+        field :name, type: 'string'
+      end
+    end.mappings_hash[:mappings].keys.should =~ [:document, :document2] }
+  end
+end

data/spec/chewy/query/criteria_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Chewy::Query::Criteria do
+  include ClassHelpers
+
+  subject { described_class.new }
+
+  its(:search) { should == {} }
+  its(:query) { should == {} }
+  its(:facets) { should == {} }
+  its(:filters) { should == [] }
+  its(:sort) { should == [] }
+  its(:fields) { should == [] }
+
+  its(:search?) { should be_false }
+  its(:query?) { should be_false }
+  its(:facets?) { should be_false }
+  its(:filters?) { should be_false }
+  its(:sort?) { should be_false }
+  its(:fields?) { should be_false }
+
+  describe '#update_search' do
+    specify { expect { subject.update_search(field: 'hello') }.to change { subject.search? }.to(true) }
+    specify { expect { subject.update_search(field: 'hello') }.to change { subject.search }.to(field: 'hello') }
+  end
+
+  describe '#update_query' do
+    specify { expect { subject.update_query(field: 'hello') }.to change { subject.query? }.to(true) }
+    specify { expect { subject.update_query(field: 'hello') }.to change { subject.query }.to(field: 'hello') }
+  end
+
+  describe '#update_facets' do
+    specify { expect { subject.update_facets(field: 'hello') }.to change { subject.facets? }.to(true) }
+    specify { expect { subject.update_facets(field: 'hello') }.to change { subject.facets }.to(field: 'hello') }
+  end
+
+  describe '#update_filters' do
+    specify { expect { subject.update_filters(field: 'hello') }.to change { subject.filters? }.to(true) }
+    specify { expect { subject.update_filters(field: 'hello') }.to change { subject.filters }.to([{field: 'hello'}]) }
+    specify { expect { subject.update_filters(field: 'hello'); subject.update_filters(field: 'world') }
+      .to change { subject.filters }.to([{field: 'hello'}, {field: 'world'}]) }
+    specify { expect { subject.update_filters([{field: 'hello'}, {field: 'world'}, nil]) }
+      .to change { subject.filters }.to([{field: 'hello'}, {field: 'world'}]) }
+  end
+
+  describe '#update_sort' do
+    specify { expect { subject.update_sort(:field) }.to change { subject.sort? }.to(true) }
+
+    specify { expect { subject.update_sort([:field]) }.to change { subject.sort }.to([:field]) }
+    specify { expect { subject.update_sort([:field1, :field2]) }.to change { subject.sort }.to([:field1, :field2]) }
+    specify { expect { subject.update_sort([{field: :asc}]) }.to change { subject.sort }.to([{field: :asc}]) }
+    specify { expect { subject.update_sort([:field1, field2: {order: :asc}]) }.to change { subject.sort }.to([:field1, {field2: {order: :asc}}]) }
+    specify { expect { subject.update_sort([{field1: {order: :asc}}, :field2]) }.to change { subject.sort }.to([{field1: {order: :asc}}, :field2]) }
+    specify { expect { subject.update_sort([field1: :asc, field2: {order: :asc}]) }.to change { subject.sort }.to([{field1: :asc}, {field2: {order: :asc}}]) }
+    specify { expect { subject.update_sort([{field1: {order: :asc}}, :field2, :field3]) }.to change { subject.sort }.to([{field1: {order: :asc}}, :field2, :field3]) }
+    specify { expect { subject.update_sort([{field1: {order: :asc}}, [:field2, :field3]]) }.to change { subject.sort }.to([{field1: {order: :asc}}, :field2, :field3]) }
+    specify { expect { subject.update_sort([{field1: {order: :asc}}, [:field2], :field3]) }.to change { subject.sort }.to([{field1: {order: :asc}}, :field2, :field3]) }
+    specify { expect { subject.update_sort([{field1: {order: :asc}, field2: :desc}, [:field3], :field4]) }.to change { subject.sort }.to([{field1: {order: :asc}}, {field2: :desc}, :field3, :field4]) }
+    specify { expect { subject.tap { |s| s.update_sort([field1: {order: :asc}, field2: :desc]) }.update_sort([[:field3], :field4]) }.to change { subject.sort }.to([{field1: {order: :asc}}, {field2: :desc}, :field3, :field4]) }
+    specify { expect { subject.tap { |s| s.update_sort([field1: {order: :asc}, field2: :desc]) }.update_sort([[:field3], :field4], purge: true) }.to change { subject.sort }.to([:field3, :field4]) }
+  end
+
+  describe '#update_fields' do
+    specify { expect { subject.update_fields(:field) }.to change { subject.fields? }.to(true) }
+    specify { expect { subject.update_fields(:field) }.to change { subject.fields }.to(['field']) }
+    specify { expect { subject.update_fields([:field, :field]) }.to change { subject.fields }.to(['field']) }
+    specify { expect { subject.update_fields([:field1, :field2]) }.to change { subject.fields }.to(['field1', 'field2']) }
+    specify { expect { subject.tap { |s| s.update_fields(:field1) }.update_fields([:field2, :field3]) }
+      .to change { subject.fields }.to(['field1', 'field2', 'field3']) }
+    specify { expect { subject.tap { |s| s.update_fields(:field1) }.update_fields([:field2, :field3], purge: true) }
+      .to change { subject.fields }.to(['field2', 'field3']) }
+  end
+end