chewy 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 600f8bb51476db3d8d55a156cd6c8d5a955f02b0
-  data.tar.gz: bad3af9a8e5038c08518b9cfa87dcacb12b6085a
+  metadata.gz: 434f4c2db17b4906fcb08963bd2e539869179ee6
+  data.tar.gz: 827aba062a02a1911666162159f48671a1ed3634
 SHA512:
-  metadata.gz: faba93331adeff1f6cbbedff24e0d47beb76f217399954c38e68d5a944e35fc5c1a7d9f494d731c10f0d5ca59687c7d093c360cc44131e5daa96eff2b434eec1
-  data.tar.gz: 33c3bc5b12a6d9e5410ad826120ad982e82c7369cc68d9c87c883faa4a69eb74f0ea91a26cde400769fd9a3e786026a674e088dc244f7c9bdedee8c13aabe36d
+  metadata.gz: 1cf88693d5554070dc6bf5a6ce402e67c30afb4c2d9eb0018b2c8c61d774b1944099bf4d2d043c550743a973eb1fe83dba87e0f6443bec896b58f9a977cad6e6
+  data.tar.gz: 5846df79cf664b56123a77cbfe3c6b3b2d030e5a475919d1500bcbe1d72671c942e440cbf5e95cb6f4091d68f832fb46198e7257a745360daebf10867f1489e0

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # master
 
+# Version 0.5.2
+
+## Changes
+
+  * `Chewy.massacre` aliased to `Chewy.delete_all` method deletes all the indexes with current prefix
+
+## Incompatible changes:
+
+  * `Chewy::Type::Base` removed in favour of using `Chewy::Type` as a base class for all types
+
+## Bugfixes:
+
+  * Advanced type classes resolving (@inbeom)
+
+  * `import` ignores nil
+
 # Version 0.5.1
 
 ## Changes:

data/README.md

@@ -1,5 +1,6 @@
 [![Build Status](https://travis-ci.org/toptal/chewy.png)](https://travis-ci.org/toptal/chewy)
 [![Code Climate](https://codeclimate.com/github/toptal/chewy.png)](https://codeclimate.com/github/toptal/chewy)
+[![Inline docs](http://inch-ci.org/github/toptal/chewy.svg?branch=master)](http://inch-ci.org/github/toptal/chewy)
 
 # Chewy
 
@@ -279,6 +280,10 @@ end
 
 Also atomic blocks might be nested and don't affect each other.
 
+### Async reindexing
+
+Chewy is not support async index update, but it's planned. Until you can use third-party solutions, such as [https://github.com/averell23/chewy_kiqqer](https://github.com/averell23/chewy_kiqqer)
+
 ### Index querying
 
 ```ruby
@@ -635,6 +640,22 @@ When the response comes back, it will have the ```:facets``` sidechannel include
 < { ... ,"facets":{"countries":{"_type":"terms","missing":?,"total":?,"other":?,"terms":[{"term":"USA","count":?},{"term":"Brazil","count":?}, ...}}
 ```
 
+### Script scoring
+
+Script scoring is used to score the search results. All scores are added to the search request and combined according to boost mode and score mode. This can be useful if, for example, a score function is computationally expensive and it is sufficient to compute the score on a filtered set of documents. For example, you might want to multiply the score by another numeric field in the doc:
+
+```ruby
+UsersIndex.script_score("_score * doc['my_numeric_field'].value")
+```
+
+### Boost Factor
+
+Boost factors are a way to add a boost to a query where documents match the filter. If you have some users who are experts and some are regular users, you might want to give the experts a higher score and boost to the top of the search results. You can accomplish this by using the #boost_factor method and adding a boost score for an expert user of 5:
+
+```ruby
+UsersIndex.boost_factor(5, filter: {term: {type: 'Expert'}})
+```
+
 ### Objects loading
 
 It is possible to load source objects from database for every search result:
@@ -745,6 +766,7 @@ See [update_index.rb](lib/chewy/rspec/update_index.rb) for more details.
 * update_all support
 * Other than ActiveRecord ORMs support (Mongoid)
 * Maybe, closer ORM/ODM integration, creating index classes implicitly
+* Asunc indexes updating
 
 ## Contributing
 

data/lib/chewy.rb

@@ -30,29 +30,73 @@ ActiveSupport.on_load(:active_record) do
 end
 
 module Chewy
-  def self.derive_type name
-    return name if name.is_a?(Class) && name < Chewy::Type::Base
-
-    index_name, type_name = name.split('#', 2)
-    class_name = "#{index_name.camelize}Index"
-    index = class_name.safe_constantize
-    raise Chewy::UnderivableType.new("Can not find index named `#{class_name}`") unless index && index < Chewy::Index
-    type = if type_name.present?
-      index.type_hash[type_name] or raise Chewy::UnderivableType.new("Index `#{class_name}` doesn`t have type named `#{type_name}`")
-    elsif index.types.one?
-      index.types.first
-    else
-      raise Chewy::UnderivableType.new("Index `#{class_name}` has more than one type, please specify type via `#{index_name}#type_name`")
+  class << self
+    # Derives type from string `index#type` representation:
+    #
+    #   Chewy.derive_type('users#user') # => UsersIndex::User
+    #
+    # If index has only one type - it is possible to derive it without specification:
+    #
+    #   Chewy.derive_type('users') # => UsersIndex::User
+    #
+    # If index has more then one type - it raises Chewy::UnderivableType.
+    #
+    def derive_type name
+      return name if name.is_a?(Class) && name < Chewy::Type
+
+      index_name, type_name = name.split('#', 2)
+      class_name = "#{index_name.camelize}Index"
+      index = class_name.safe_constantize
+      raise Chewy::UnderivableType.new("Can not find index named `#{class_name}`") unless index && index < Chewy::Index
+      type = if type_name.present?
+        index.type_hash[type_name] or raise Chewy::UnderivableType.new("Index `#{class_name}` doesn`t have type named `#{type_name}`")
+      elsif index.types.one?
+        index.types.first
+      else
+        raise Chewy::UnderivableType.new("Index `#{class_name}` has more than one type, please specify type via `#{index_name}#type_name`")
+      end
     end
-  end
 
-  def self.wait_for_status
-    client.cluster.health wait_for_status: Chewy.configuration[:wait_for_status] if Chewy.configuration[:wait_for_status].present?
-  end
+    # Creates Chewy::Type ancestor defining index and adapter methods.
+    #
+    def create_type index, target, options = {}, &block
+      type = Class.new(Chewy::Type)
 
-  def self.config
-    Chewy::Config.instance
-  end
+      adapter = if (target.is_a?(Class) && target < ActiveRecord::Base) || target.is_a?(::ActiveRecord::Relation)
+        Chewy::Type::Adapter::ActiveRecord.new(target, options)
+      else
+        Chewy::Type::Adapter::Object.new(target, options)
+      end
+
+      index.const_set(adapter.name, type)
+      type.send(:define_singleton_method, :index) { index }
+      type.send(:define_singleton_method, :adapter) { adapter }
+
+      type.class_eval &block if block
+      type
+    end
 
-  singleton_class.delegate *Chewy::Config.delegated, to: :config
+    # Sends wait_for_status request to ElasticSearch with status
+    # defined in configuration.
+    #
+    # Does nothing in case of config `wait_for_status` is undefined.
+    #
+    def wait_for_status
+      client.cluster.health wait_for_status: Chewy.configuration[:wait_for_status] if Chewy.configuration[:wait_for_status].present?
+    end
+
+    # Deletes all corresponding indexes with current prefix from ElasticSearch.
+    # Be careful, if current prefix is blank, this will destroy all the indexes.
+    #
+    def massacre
+      Chewy.client.indices.delete(index: [Chewy.configuration[:prefix], '*'].delete_if(&:blank?).join(?_))
+      Chewy.wait_for_status
+    end
+    alias_method :delete_all, :massacre
+
+    def config
+      Chewy::Config.instance
+    end
+    delegate *Chewy::Config.delegated, to: :config
+  end
 end

data/lib/chewy/config.rb

@@ -139,10 +139,6 @@ module Chewy
       options
     end
 
-    def client?
-      !!Thread.current[:chewy_client]
-    end
-
     def client
       Thread.current[:chewy_client] ||= ::Elasticsearch::Client.new configuration
     end
@@ -161,7 +157,7 @@ module Chewy
     def stash *args
       if args.any?
         type, ids = *args
-        raise ArgumentError.new('Only Chewy::Type::Base accepted as the first argument') unless type < Chewy::Type::Base
+        raise ArgumentError.new('Only Chewy::Type accepted as the first argument') unless type < Chewy::Type
         stash.last[type] ||= []
         stash.last[type] |= ids
       else

data/lib/chewy/index.rb

@@ -77,7 +77,7 @@ module Chewy
     # passed.
     #
     def self.define_type(target, options = {}, &block)
-      type_class = Chewy::Type.new(self, target, options, &block)
+      type_class = Chewy.create_type(self, target, options, &block)
       self.type_hash = type_hash.merge(type_class.type_name => type_class)
 
       class_eval <<-METHOD, __FILE__, __LINE__ + 1

data/lib/chewy/query.rb

@@ -290,7 +290,7 @@ module Chewy
     # added to the search request and combinded according to
     # <tt>boost_mode</tt> and <tt>score_mode</tt>
     #
-    #   UsersIndex.script_score("doc['boost'].value", filter: { foo: :bar})
+    #   UsersIndex.script_score("doc['boost'].value", filter: { term: {foo: :bar} })
     #       # => {body:
     #              query: {
     #                function_score: {
@@ -299,7 +299,7 @@ module Chewy
     #                    script_score: {
     #                       script: "doc['boost'].value"
     #                     },
-    #                     filter: { foo: :bar }
+    #                     filter: { term: { foo: :bar } }
     #                    }
     #                  }]
     #                } } }
@@ -315,14 +315,14 @@ module Chewy
     # This probably only makes sense if you specifiy a filter
     # for the boost factor as well
     #
-    #   UsersIndex.boost_factor(23, filter: { foo: :bar})
+    #   UsersIndex.boost_factor(23, filter: { term: { foo: :bar} })
     #       # => {body:
     #              query: {
     #                function_score: {
     #                  query: { ...},
     #                  functions: [{
     #                    boost_factor: 23,
-    #                    filter: { foo: :bar }
+    #                    filter: { term: { foo: :bar } }
     #                  }]
     #                } } }
     def boost_factor(factor, options = {})

data/lib/chewy/type.rb

@@ -1,22 +1,57 @@
-require 'chewy/type/base'
+require 'chewy/index/search'
+require 'chewy/type/mapping'
+require 'chewy/type/wrapper'
+require 'chewy/type/observe'
+require 'chewy/type/actions'
+require 'chewy/type/import'
+require 'chewy/type/adapter/object'
+require 'chewy/type/adapter/active_record'
 
 module Chewy
-  module Type
-    def self.new(index, target, options = {}, &block)
-      type = Class.new(Chewy::Type::Base)
+  class Type
+    include Chewy::Index::Search
+    include Mapping
+    include Wrapper
+    include Observe
+    include Actions
+    include Import
 
-      adapter = if (target.is_a?(Class) && target < ActiveRecord::Base) || target.is_a?(::ActiveRecord::Relation)
-        Chewy::Type::Adapter::ActiveRecord.new(target, options)
-      else
-        Chewy::Type::Adapter::Object.new(target, options)
-      end
+    singleton_class.delegate :client, to: :index
+
+    def self.index
+      raise NotImplementedError
+    end
 
-      index.const_set(adapter.name, type)
-      type.send(:define_singleton_method, :index) { index }
-      type.send(:define_singleton_method, :adapter) { adapter }
+    def self.adapter
+      raise NotImplementedError
+    end
+
+    def self.type_name
+      adapter.type_name
+    end
 
-      type.class_eval &block if block
-      type
+    def self.search_index
+      index
+    end
+
+    def self.search_type
+      type_name
+    end
+
+    def self.const_missing(name)
+      to_resolve = "#{self.to_s}::#{name}"
+      to_resolve[index.to_s] = ''
+
+      @__resolved_constants ||= {}
+
+      if to_resolve.empty? || @__resolved_constants[to_resolve]
+        super
+      else
+        @__resolved_constants[to_resolve] = true
+        to_resolve.constantize
+      end
+    rescue NotImplementedError
+      super
     end
   end
 end

data/lib/chewy/type/actions.rb

@@ -1,5 +1,5 @@
 module Chewy
-  module Type
+  class Type
     module Actions
       extend ActiveSupport::Concern
 

data/lib/chewy/type/adapter/active_record.rb

@@ -1,7 +1,7 @@
 require 'chewy/type/adapter/base'
 
 module Chewy
-  module Type
+  class Type
     module Adapter
       class ActiveRecord < Base
         def initialize *args
@@ -62,7 +62,7 @@ module Chewy
           import_options = args.extract_options!
           import_options[:batch_size] ||= BATCH_SIZE
           collection = args.none? ? model_all :
-            (args.one? && args.first.is_a?(::ActiveRecord::Relation) ? args.first : args.flatten)
+            (args.one? && args.first.is_a?(::ActiveRecord::Relation) ? args.first : args.flatten.compact)
 
           if collection.is_a?(::ActiveRecord::Relation)
             result = true

data/lib/chewy/type/adapter/base.rb

@@ -1,5 +1,5 @@
 module Chewy
-  module Type
+  class Type
     module Adapter
       # Basic adapter class. Contains interface, need to implement to add any classes support
       class Base

data/lib/chewy/type/adapter/object.rb

@@ -1,7 +1,7 @@
 require 'chewy/type/adapter/base'
 
 module Chewy
-  module Type
+  class Type
     module Adapter
       class Object < Base
         def initialize *args
@@ -31,7 +31,7 @@ module Chewy
         def import *args, &block
           import_options = args.extract_options!
           batch_size = import_options.delete(:batch_size) || BATCH_SIZE
-          objects = args.flatten
+          objects = args.flatten.compact
 
           objects.in_groups_of(batch_size, false).map do |group|
             action_groups = group.group_by do |object|

data/lib/chewy/type/import.rb

@@ -1,5 +1,5 @@
 module Chewy
-  module Type
+  class Type
     module Import
       extend ActiveSupport::Concern
 

data/lib/chewy/type/mapping.rb

@@ -1,5 +1,5 @@
 module Chewy
-  module Type
+  class Type
     module Mapping
       extend ActiveSupport::Concern
 

data/lib/chewy/type/observe.rb

@@ -1,5 +1,5 @@
 module Chewy
-  module Type
+  class Type
     module Observe
       extend ActiveSupport::Concern
 

data/lib/chewy/type/wrapper.rb

@@ -1,5 +1,5 @@
 module Chewy
-  module Type
+  class Type
     module Wrapper
       extend ActiveSupport::Concern
 
@@ -10,7 +10,7 @@ module Chewy
       end
 
       def ==(other)
-        if other.is_a?(Chewy::Type::Base)
+        if other.is_a?(Chewy::Type)
           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

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '0.5.1'
+  VERSION = '0.5.2'
 end

data/spec/chewy/index_spec.rb

@@ -57,12 +57,40 @@ describe Chewy::Index do
       before { stub_index(:dummies) { define_type City, name: :country } }
       specify { DummiesIndex.type_hash['country'].should == DummiesIndex::Country }
     end
+
+
+    context do
+      before { stub_model('City') }
+      before { stub_model('City::District', City) }
+
+      specify do
+        expect {
+          Kernel.eval <<-DUMMY_CITY_INDEX
+            class DummyCityIndex < Chewy::Index
+              define_type City
+              define_type City::District
+            end
+          DUMMY_CITY_INDEX
+        }.not_to raise_error
+      end
+
+      specify do
+        expect {
+          Kernel.eval <<-DUMMY_CITY_INDEX
+            class DummyCityIndex2 < Chewy::Index
+              define_type City
+              define_type City::Nothing
+            end
+          DUMMY_CITY_INDEX
+        }.to raise_error(NameError)
+      end
+    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'].should be < Chewy::Type }
     specify { DummiesIndex.type_hash['dummy'].type_name.should == 'dummy' }
   end
 

data/spec/chewy/query_spec.rb

@@ -227,15 +227,12 @@ describe Chewy::Query do
         before { CitiesIndex::City.import! cities }
 
         specify { CitiesIndex.aggregations.should == {} }
-        specify { CitiesIndex.aggregations(ratings: {terms: {field: 'rating'}}).aggregations.should == {
-          'ratings' => {
-            'buckets' => [
-              {'key' => 0, 'key_as_string' => '0', 'doc_count' => 4},
-              {'key' => 1, 'key_as_string' => '1', 'doc_count' => 3},
-              {'key' => 2, 'key_as_string' => '2', 'doc_count' => 3}
-            ]
-          }
-        } }
+        specify { CitiesIndex.aggregations(ratings: {terms: {field: 'rating'}})
+          .aggregations['ratings']['buckets'].map { |h| h.slice('key', 'doc_count') }.should == [
+          { 'key' => 0, 'doc_count' => 4 },
+          { 'key' => 1, 'doc_count' => 3 },
+          { 'key' => 2, 'doc_count' => 3 }
+        ] }
       end
     end
   end

data/spec/chewy/type/adapter/active_record_spec.rb

@@ -68,6 +68,9 @@ describe Chewy::Type::Adapter::ActiveRecord do
         {delete: deleted.first(2).map(&:id)},
         {delete: deleted.last(1).map(&:id)}] }
 
+      specify { import(cities.first, nil).should == [{index: [cities.first]}] }
+      specify { import(cities.first.id, nil).should == [{index: [cities.first]}] }
+
       context do
         before { deleted.map { |object| object.stub(delete_from_index?: true, destroyed?: true) } }
         specify { import(deleted).should == [{delete: deleted}] }

data/spec/chewy/type/adapter/object_spec.rb

@@ -54,6 +54,8 @@ describe Chewy::Type::Adapter::Object do
           {index: objects.last(1), delete: deleted.first(1)},
           {delete: deleted.last(1)}] }
 
+      specify { import(objects.first, nil).should == [{index: [objects.first]}] }
+
       context do
         let(:deleted) { 2.times.map { |i| double(delete_from_index?: true, destroyed?: true) } }
         specify { import(deleted).should == [{delete: deleted}] }

data/spec/chewy/type/mapping_spec.rb

@@ -31,7 +31,7 @@ describe Chewy::Type::Mapping do
   end
 
   describe '.mappings_hash' do
-    specify { Class.new(Chewy::Type::Base).mappings_hash.should == {} }
+    specify { Class.new(Chewy::Type).mappings_hash.should == {} }
     specify { product.mappings_hash.should == product.root_object.mappings_hash }
 
     context 'parent-child relationship' do

data/spec/chewy/type_spec.rb

@@ -1,64 +1,4 @@
 require 'spec_helper'
 
 describe Chewy::Type do
-  describe '.new' do
-    before { stub_index(:cities) }
-
-    context 'Symbol' do
-      subject { described_class.new(CitiesIndex, :city) }
-
-      it { should be_a Class }
-      it { should be < Chewy::Type::Base }
-      its(:name) { should == 'CitiesIndex::City' }
-      its(:index) { should == CitiesIndex }
-      its(:type_name) { should == 'city' }
-    end
-
-    context 'ActiveRecord model' do
-      before { stub_model(:city) }
-      subject { described_class.new(CitiesIndex, City) }
-
-      it { should be_a Class }
-      it { should be < Chewy::Type::Base }
-      its(:name) { should == 'CitiesIndex::City' }
-      its(:index) { should == CitiesIndex }
-      its(:type_name) { should == 'city' }
-    end
-
-    context 'ActiveRecord scope' do
-      before { stub_model(:city) }
-      subject { described_class.new(CitiesIndex, City.includes(:country)) }
-
-      it { should be_a Class }
-      it { should be < Chewy::Type::Base }
-      its(:name) { should == 'CitiesIndex::City' }
-      its(:index) { should == CitiesIndex }
-      its(:type_name) { should == 'city' }
-    end
-
-    context 'Namespaced index' do
-      before { stub_model(:city) }
-      before { stub_index('namespace/cities') }
-
-      subject { described_class.new(Namespace::CitiesIndex, City) }
-
-      it { should be_a Class }
-      it { should be < Chewy::Type::Base }
-      its(:name) { should == 'Namespace::CitiesIndex::City' }
-      its(:index) { should == Namespace::CitiesIndex }
-      its(:type_name) { should == 'city' }
-    end
-
-    context 'Namespaced model' do
-      before { stub_model('namespace/city') }
-
-      subject { described_class.new(CitiesIndex, Namespace::City) }
-
-      it { should be_a Class }
-      it { should be < Chewy::Type::Base }
-      its(:name) { should == 'CitiesIndex::City' }
-      its(:index) { should == CitiesIndex }
-      its(:type_name) { should == 'city' }
-    end
-  end
 end

data/spec/chewy_spec.rb

@@ -31,4 +31,85 @@ describe Chewy do
     specify { described_class.derive_type('namespace/autocomplete#developer').should == Namespace::AutocompleteIndex.developer }
     specify { described_class.derive_type('namespace/autocomplete#company').should == Namespace::AutocompleteIndex.company }
   end
+
+  describe '.create_type' do
+    before { stub_index(:cities) }
+
+    context 'Symbol' do
+      subject { described_class.create_type(CitiesIndex, :city) }
+
+      it { should be_a Class }
+      it { should be < Chewy::Type }
+      its(:name) { should == 'CitiesIndex::City' }
+      its(:index) { should == CitiesIndex }
+      its(:type_name) { should == 'city' }
+    end
+
+    context 'ActiveRecord model' do
+      before { stub_model(:city) }
+      subject { described_class.create_type(CitiesIndex, City) }
+
+      it { should be_a Class }
+      it { should be < Chewy::Type }
+      its(:name) { should == 'CitiesIndex::City' }
+      its(:index) { should == CitiesIndex }
+      its(:type_name) { should == 'city' }
+    end
+
+    context 'ActiveRecord scope' do
+      before { stub_model(:city) }
+      subject { described_class.create_type(CitiesIndex, City.includes(:country)) }
+
+      it { should be_a Class }
+      it { should be < Chewy::Type }
+      its(:name) { should == 'CitiesIndex::City' }
+      its(:index) { should == CitiesIndex }
+      its(:type_name) { should == 'city' }
+    end
+
+    context 'Namespaced index' do
+      before { stub_model(:city) }
+      before { stub_index('namespace/cities') }
+
+      subject { described_class.create_type(Namespace::CitiesIndex, City) }
+
+      it { should be_a Class }
+      it { should be < Chewy::Type }
+      its(:name) { should == 'Namespace::CitiesIndex::City' }
+      its(:index) { should == Namespace::CitiesIndex }
+      its(:type_name) { should == 'city' }
+    end
+
+    context 'Namespaced model' do
+      before { stub_model('namespace/city') }
+
+      subject { described_class.create_type(CitiesIndex, Namespace::City) }
+
+      it { should be_a Class }
+      it { should be < Chewy::Type }
+      its(:name) { should == 'CitiesIndex::City' }
+      its(:index) { should == CitiesIndex }
+      its(:type_name) { should == 'city' }
+    end
+  end
+
+  describe '.massacre' do
+    before do
+      Chewy.client.indices.delete index: '*'
+    end
+
+    before do
+      Chewy.configuration = Chewy.configuration.merge(prefix: 'prefix1')
+      stub_index(:admins).create!
+      Chewy.configuration = Chewy.configuration.merge(prefix: 'prefix2')
+      stub_index(:developers).create!
+      stub_index(:companies).create!
+
+      Chewy.massacre
+    end
+
+    specify { AdminsIndex.exists?.should == true }
+    specify { DevelopersIndex.exists?.should == false }
+    specify { CompaniesIndex.exists?.should == false }
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chewy
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - pyromaniac
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-11 00:00:00.000000000 Z
+date: 2014-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -220,7 +220,6 @@ files:
 - lib/chewy/type/adapter/active_record.rb
 - lib/chewy/type/adapter/base.rb
 - lib/chewy/type/adapter/object.rb
-- lib/chewy/type/base.rb
 - lib/chewy/type/import.rb
 - lib/chewy/type/mapping.rb
 - lib/chewy/type/observe.rb

data/lib/chewy/type/base.rb

@@ -1,43 +0,0 @@
-require 'chewy/index/search'
-require 'chewy/type/mapping'
-require 'chewy/type/wrapper'
-require 'chewy/type/observe'
-require 'chewy/type/actions'
-require 'chewy/type/import'
-require 'chewy/type/adapter/object'
-require 'chewy/type/adapter/active_record'
-
-module Chewy
-  module Type
-    class Base
-      include Chewy::Index::Search
-      include Mapping
-      include Wrapper
-      include Observe
-      include Actions
-      include Import
-
-      singleton_class.delegate :client, to: :index
-
-      def self.index
-        raise NotImplementedError
-      end
-
-      def self.adapter
-        raise NotImplementedError
-      end
-
-      def self.type_name
-        adapter.type_name
-      end
-
-      def self.search_index
-        index
-      end
-
-      def self.search_type
-        type_name
-      end
-    end
-  end
-end