chewy 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 37ef7870c9b4ea62e334143eddf486f55e21627e
-  data.tar.gz: 57cd914528a78448c58f89d687f84a666b8a2ffc
+  metadata.gz: 618e32a755ee2b5035e4640b4a7969e76492689f
+  data.tar.gz: 420d6db94ffd55a322246a27e3537467c334782d
 SHA512:
-  metadata.gz: 9e923803456e4d75abe810db4c2cceb6bd4cdd758de480f937131570830dcb7e5e1053a4db06ec1aec62f74cf0abe43173f02d461a56e83e9705f2f819d0b7df
-  data.tar.gz: 53e95e0795081fda77fbb8858207081eded90ab8d5ce5b01b4ae2f140641f71e1db11c3af470f321c4ece7f881916045286a4e22b0ab81694ca5bdb01b271655
+  metadata.gz: 9db80b8a18cfc60735822fcd5b9c6e761221a8c485e04fb23088c1cdf4f83f43090a7b211949656eb9c989cf0b3832852b87cde3aa8d888558db157a1e38edc6
+  data.tar.gz: be4cb7e42fd04ec7607d9ad9e12dc1cbd664fd004b046b2a756e584760c3a488bf296563ecad006288e45557027db1f2b588d27db45d721e2f70391e9b0ef988

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # master
 
+# Version 0.2.1
+
+  * Auto-resolved analyzers and analyzers repository:
+
+    ```ruby
+      # Setting up analyzers repository:
+      Chewy.analyzer :title_analyzer, type: 'custom', filter: %w(lowercase icu_folding title_nysiis)
+      Chewy.filter :title_nysiis, type: 'phonetic', encoder: 'nysiis', replace: false
+
+      # Using analyzers from repository in index classes
+      class ProductsIndex < Chewy::Index
+        settings analysis: {analyzer: ['title_analyzer', {one_more_analyzer: {type: 'custom', tokenizer: 'lowercase'}}]}
+      end
+    ```
+
+    `title_analyzer` here will be automatically resolved and passed to index mapping
+
+# Version 0.2.0
+
   * Reworked import error handling. Now all the import errors from ElasticSearch are handled properly, also import method returns true of false depending on the import process success.
 
   * `Chewy::Index.import` now takes types hash as argument within options hash:

data/Guardfile

@@ -3,7 +3,7 @@
 
 guard :rspec do
   watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }
 
   # Rails example

data/README.md

@@ -113,7 +113,7 @@ Chewy.logger = Logger.new
 
   Mapping definitions - http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/mapping.html
 
-4. Add some index- and type-related settings
+4. Add some index- and type-related settings. Analyzers repositories might be used as well. See `Chewy::Index.settings` docs for details:
 
   ```ruby
   class UsersIndex < Chewy::Index

data/lib/chewy.rb

@@ -6,6 +6,7 @@ require 'singleton'
 require 'elasticsearch'
 
 require 'chewy/version'
+require 'chewy/errors'
 require 'chewy/config'
 require 'chewy/index'
 require 'chewy/type'
@@ -21,18 +22,6 @@ ActiveSupport.on_load(:active_record) do
 end
 
 module Chewy
-  class Error < StandardError
-  end
-
-  class UndefinedIndex < Error
-  end
-
-  class UndefinedType < Error
-  end
-
-  class UnderivableType < Error
-  end
-
   def self.derive_type name
     return name if name.is_a?(Class) && name < Chewy::Type::Base
 

data/lib/chewy/config.rb

@@ -2,19 +2,67 @@ module Chewy
   class Config
     include Singleton
 
+    attr_reader :analyzers, :tokenizers, :filters, :char_filters
     attr_accessor :client_options, :urgent_update, :query_mode, :filter_mode, :logger
 
     def self.delegated
       public_instance_methods - self.superclass.public_instance_methods - Singleton.public_instance_methods
     end
 
+    def self.repository name
+      plural_name = name.to_s.pluralize
+
+      class_eval <<-EOS
+        def #{name}(name, options = nil)
+          options ? #{plural_name}[name.to_sym] = options : #{plural_name}[name.to_sym]
+        end
+      EOS
+    end
+
     def initialize
       @urgent_update = false
       @client_options = {}
       @query_mode = :must
       @filter_mode = :and
+      @analyzers = {}
+      @tokenizers = {}
+      @filters = {}
+      @char_filters = {}
     end
 
+    # Analysers repository:
+    #
+    #   Chewy.analyzer :my_analyzer2, {
+    #     type: custom,
+    #     tokenizer: 'my_tokenizer1',
+    #     filter : ['my_token_filter1', 'my_token_filter2']
+    #     char_filter : ['my_html']
+    #   }
+    #   Chewy.analyzer(:my_analyzer2) # => {type: 'custom', tokenizer: ...}
+    #
+    repository :analyzer
+
+    # Tokenizers repository:
+    #
+    #   Chewy.tokenizer :my_tokenizer1, {type: standard, max_token_length: 900}
+    #   Chewy.tokenizer(:my_tokenizer1) # => {type: standard, max_token_length: 900}
+    #
+    repository :tokenizer
+
+    # Token filters repository:
+    #
+    #   Chewy.filter :my_token_filter1, {type: stop, stopwords: [stop1, stop2, stop3, stop4]}
+    #   Chewy.filter(:my_token_filter1) # => {type: stop, stopwords: [stop1, stop2, stop3, stop4]}
+    #
+    repository :filter
+
+    # Char filters repository:
+    #
+    #   Chewy.char_filter :my_html, {type: html_strip, escaped_tags: [xxx, yyy], read_ahead: 1024}
+    #   Chewy.char_filter(:my_html) # => {type: html_strip, escaped_tags: [xxx, yyy], read_ahead: 1024}
+    #
+    repository :char_filter
+
     def client_options
       options = @client_options.merge(yaml_options)
       options.merge!(logger: logger) if logger

data/lib/chewy/errors.rb

@@ -0,0 +1,13 @@
+module Chewy
+  class Error < StandardError
+  end
+
+  class UndefinedIndex < Error
+  end
+
+  class UndefinedType < Error
+  end
+
+  class UnderivableType < Error
+  end
+end

data/lib/chewy/index.rb

@@ -1,6 +1,7 @@
 require 'chewy/index/actions'
 require 'chewy/index/aliases'
 require 'chewy/index/search'
+require 'chewy/index/settings'
 
 module Chewy
   class Index
@@ -14,7 +15,7 @@ module Chewy
     self.type_hash = {}
 
     class_attribute :_settings
-    self._settings = {}
+    self._settings = Chewy::Index::Settings.new
 
     # Setups or returns ElasticSearch index name
     #
@@ -129,23 +130,11 @@ module Chewy
     # See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-update-settings.html
     # for more details
     #
-    def self.settings(params)
-      self._settings = params
-    end
-
-    # Perform import operation for every defined type
+    # It is possible to store analyzers settings in Chewy repositories
+    # and link them form index class. See `Chewy::Index::Settings` for details.
     #
-    #   UsersIndex.import
-    #   UsersIndex.import refresh: false # to disable index refreshing after import
-    #   UsersIndex.import suffix: Time.now.to_i # imports data to index with specified suffix if such is exists
-    #   UsersIndex.import batch_size: 300 # import batch size
-    #
-    def self.import options = {}
-      objects = options.extract!(*type_names.map(&:to_sym))
-      types.map do |type|
-        args = [objects[type.type_name.to_sym], options.dup].reject(&:blank?)
-        type.import *args
-      end.all?
+    def self.settings(params)
+      self._settings = Chewy::Index::Settings.new params
     end
 
   private
@@ -156,7 +145,7 @@ module Chewy
     end
 
     def self.settings_hash
-      _settings.present? ? {settings: _settings} : {}
+      _settings.to_hash
     end
 
     def self.mappings_hash

data/lib/chewy/index/actions.rb

@@ -107,11 +107,29 @@ module Chewy
         #   UsersIndex.purge! '01-2014' # deletes `users` and `users_01-2014` indexes, creates `users_01-2014`
         #
         def purge! suffix = nil
-          delete if suffix.present?
-          delete suffix
+          begin
+            delete! if suffix.present? && exists?
+            delete! suffix
+          rescue Elasticsearch::Transport::Transport::Errors::NotFound
+          end
           create! suffix
         end
 
+        # Perform import operation for every defined type
+        #
+        #   UsersIndex.import
+        #   UsersIndex.import refresh: false # to disable index refreshing after import
+        #   UsersIndex.import suffix: Time.now.to_i # imports data to index with specified suffix if such is exists
+        #   UsersIndex.import batch_size: 300 # import batch size
+        #
+        def import options = {}
+          objects = options.extract!(*type_names.map(&:to_sym))
+          types.map do |type|
+            args = [objects[type.type_name.to_sym], options.dup].reject(&:blank?)
+            type.import *args
+          end.all?
+        end
+
         # Deletes, creates and imports data to the index.
         # Returns import result
         #

data/lib/chewy/index/search.rb

@@ -5,7 +5,7 @@ module Chewy
 
       included do
         singleton_class.delegate :explain, :limit, :offset, :facets, :query,
-          :filter, :order, :reorder, :only, :types, to: :all
+          :filter, :order, :reorder, :only, :types, :none, to: :all
       end
 
       module ClassMethods

data/lib/chewy/index/settings.rb

@@ -0,0 +1,77 @@
+module Chewy
+  class Index
+
+    # Stores ElasticSearch index settings and resolves `analysis`
+    # hash. At first, you need to store sone analyzers or other
+    # analysis options to the corresponding repository:
+    #
+    #   Chewy.analyzer :title_analyzer, type: 'custom', filter: %w(lowercase icu_folding title_nysiis)
+    #   Chewy.filter :title_nysiis, type: 'phonetic', encoder: 'nysiis', replace: false
+    #
+    # `title_nysiis` filter here will be expanded automatically when
+    # `title_analyzer` analyser will be used in index settings:
+    #
+    #   class ProductsIndex < Chewy::Index
+    #     settings analysis: {
+    #       analyzer: [
+    #         'title_analyzer',
+    #         {one_more_analyzer: {type: 'custom', tokenizer: 'lowercase'}}
+    #       ]
+    #     }
+    #   end
+    #
+    # Additional analysing options, which wasn't stored in repositories,
+    # might be used as well.
+    #
+    class Settings
+      def initialize(params = {})
+        @params = params
+      end
+
+      def to_hash
+        return {} unless @params.present?
+
+        params = @params.deep_dup
+        params[:analysis] = resolve_analysis(params[:analysis]) if params[:analysis]
+
+        {settings: params}
+      end
+
+    private
+
+      def resolve_analysis(analysis)
+        analyzer = resolve(analysis[:analyzer], Chewy.analyzers)
+
+        options = [:tokenizer, :filter, :char_filter].each.with_object({}) do |type, result|
+          dependencies = collect_dependencies(type, analyzer)
+          resolved = resolve(dependencies.push(analysis[type]), Chewy.send(type.to_s.pluralize))
+          result.merge!(type => resolved) if resolved.present?
+        end
+
+        options.merge!(analyzer: analyzer) if analyzer.present?
+        options
+      end
+
+      def collect_dependencies(type, analyzer)
+        analyzer.map { |_, options| options[type] }.compact.flatten.uniq
+      end
+
+      def resolve(params, repository)
+        if params.is_a?(Array)
+          params.flatten.reject(&:blank?).each.with_object({}) do |name_or_hash, result|
+            options = if name_or_hash.is_a?(Hash)
+              name_or_hash
+            else
+              name_or_hash = name_or_hash.to_sym
+              resolved = repository[name_or_hash]
+              resolved ? {name_or_hash => resolved} : {}
+            end
+            result.merge!(options)
+          end
+        else
+          params || {}
+        end
+      end
+    end
+  end
+end

data/lib/chewy/query.rb

@@ -246,6 +246,20 @@ module Chewy
       chain { criteria.update_facets params }
     end
 
+    # Marks the criteria as having zero records. This scope  always returns empty array
+    # without touching the elasticsearch server.
+    # All the chained calls of methods don't affect the result
+    #
+    #   UsersIndex.none.to_a
+    #     # => []
+    #   UsersIndex.query(text: {name: 'Johny'}).none.to_a
+    #     # => []
+    #   UsersIndex.none.query(text: {name: 'Johny'}).to_a
+    #     # => []
+    def none
+      chain { criteria.update_options none: true }
+    end
+
     # Adds one or more query to the search request
     # Internally queries are stored as an array
     # While the full query compilation this array compiles
@@ -448,7 +462,7 @@ module Chewy
     end
 
     def _results
-      @_results ||= _response['hits']['hits'].map do |hit|
+      @_results ||= (criteria.none? ? [] : _response['hits']['hits']).map do |hit|
         attributes = hit['_source'] || hit['fields'] || {}
         attributes.reverse_merge!(id: hit['_id'])
           .merge!(_score: hit['_score'], _explanation: hit['_explanation'])

data/lib/chewy/query/criteria.rb

@@ -30,6 +30,10 @@ module Chewy
         end
       end
 
+      def none?
+        !!options[:none]
+      end
+
       def update_options(modifer)
         options.merge!(modifer)
       end

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = "0.2.0"
+  VERSION = '0.2.2'
 end

data/spec/chewy/config_spec.rb

@@ -8,6 +8,50 @@ describe Chewy::Config do
   its(:filter_mode) { should == :and }
   its(:logger) { should be_nil }
   its(:client_options) { should_not have_key :logger }
+  its(:analyzers) { should == {} }
+  its(:tokenizers) { should == {} }
+  its(:filters) { should == {} }
+  its(:char_filters) { should == {} }
+
+  describe '#analyzer' do
+    specify { subject.analyzer(:name).should be_nil }
+
+    context do
+      before { subject.analyzer(:name, option: :foo) }
+      specify { subject.analyzer(:name).should == {option: :foo} }
+      specify { subject.analyzers.should == {name: {option: :foo}} }
+    end
+  end
+
+  describe '#tokenizer' do
+    specify { subject.tokenizer(:name).should be_nil }
+
+    context do
+      before { subject.tokenizer(:name, option: :foo) }
+      specify { subject.tokenizer(:name).should == {option: :foo} }
+      specify { subject.tokenizers.should == {name: {option: :foo}} }
+    end
+  end
+
+  describe '#filter' do
+    specify { subject.filter(:name).should be_nil }
+
+    context do
+      before { subject.filter(:name, option: :foo) }
+      specify { subject.filter(:name).should == {option: :foo} }
+      specify { subject.filters.should == {name: {option: :foo}} }
+    end
+  end
+
+  describe '#char_filter' do
+    specify { subject.char_filter(:name).should be_nil }
+
+    context do
+      before { subject.char_filter(:name, option: :foo) }
+      specify { subject.char_filter(:name).should == {option: :foo} }
+      specify { subject.char_filters.should == {name: {option: :foo}} }
+    end
+  end
 
   describe '#logger' do
     before { subject.logger = double(:logger) }

data/spec/chewy/index/settings_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Chewy::Index::Settings do
+  include ClassHelpers
+
+  describe '#to_hash' do
+    before { Chewy.stub(config: Chewy::Config.send(:new)) }
+
+    specify { described_class.new.to_hash.should == {} }
+    specify { described_class.new(number_of_nodes: 3).to_hash.should == {settings: {number_of_nodes: 3}} }
+    specify { described_class.new(number_of_nodes: 3, analysis: {}).to_hash
+      .should == {settings: {number_of_nodes: 3, analysis: {}}} }
+    specify { described_class.new(number_of_nodes: 3, analysis: {filter: {filter1: {}}}).to_hash
+      .should == {settings: {number_of_nodes: 3, analysis: {filter: {filter1: {}}}}} }
+    specify { described_class.new(number_of_nodes: 3, analysis: {analyzer: {analyzer1: {}}}).to_hash
+      .should == {settings: {number_of_nodes: 3, analysis: {analyzer: {analyzer1: {}}}}} }
+    specify { described_class.new(number_of_nodes: 3, analysis: {
+      analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}}
+    }).to_hash
+      .should == {settings: {number_of_nodes: 3, analysis: {
+        analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}}
+      }}} }
+    specify { described_class.new(number_of_nodes: 3, analysis: {analyser: ['analyzer1']}).to_hash
+      .should == {settings: {number_of_nodes: 3, analysis: {}}} }
+
+    context do
+      before { Chewy.tokenizer :tokenizer1, {options: 42} }
+
+      specify { described_class.new(number_of_nodes: 3, analysis: {
+        analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}}
+      }).to_hash
+        .should == {settings: {number_of_nodes: 3, analysis: {
+          analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}},
+          tokenizer: {tokenizer1: {options: 42}}
+        }}} }
+    end
+
+    context do
+      before do
+        Chewy.filter :filter2, {options: 42}
+        Chewy.filter :filter3, {options: 43}
+        Chewy.filter :filter5, {options: 44}
+      end
+
+      specify { described_class.new(number_of_nodes: 3, analysis: {
+        analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}},
+        filter: ['filter3', {filter4: {options: 45}}]
+      }).to_hash
+        .should == {settings: {number_of_nodes: 3, analysis: {
+          analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}},
+          filter: {filter2: {options: 42}, filter3: {options: 43}, filter4: {options: 45}}
+        }}} }
+    end
+
+    context do
+      before do
+        Chewy.analyzer :analyzer1, {options: 42, tokenizer: 'tokenizer1'}
+        Chewy.tokenizer :tokenizer1, {options: 43}
+      end
+
+      specify { described_class.new(number_of_nodes: 3, analysis: {
+        analyzer: ['analyzer1', {analyzer2: {options: 44}}]
+      }).to_hash
+        .should == {settings: {number_of_nodes: 3, analysis: {
+          analyzer: {analyzer1: {options: 42, tokenizer: 'tokenizer1'}, analyzer2: {options: 44}},
+          tokenizer: {tokenizer1: {options: 43}}
+        }}} }
+    end
+  end
+end

data/spec/chewy/index_spec.rb

@@ -22,6 +22,30 @@ describe Chewy::Index do
     end
   end
 
+  describe '.settings' do
+    before do
+      Chewy.stub(config: Chewy::Config.send(:new))
+
+      Chewy.analyzer :name, filter: ['lowercase', 'icu_folding', 'names_nysiis']
+      Chewy.analyzer :phone, tokenizer: 'ngram', char_filter: ['phone']
+      Chewy.tokenizer :ngram, type: 'nGram', min_gram: 3, max_gram: 3
+      Chewy.char_filter :phone, type: 'pattern_replace', pattern: '[^\d]', replacement: ''
+      Chewy.filter :names_nysiis, type: 'phonetic', encoder: 'nysiis', replace: false
+    end
+
+    let(:documents) { stub_index(:documents) { settings analysis: {analyzer: [:name, :phone, {sorted: {option: :baz}}]} } }
+
+    specify { expect { documents.settings_hash }.to_not change(documents._settings, :inspect)  }
+    specify { documents.settings_hash.should == {settings: {analysis: {
+      analyzer: {name: {filter: ['lowercase', 'icu_folding', 'names_nysiis']},
+                 phone: {tokenizer: 'ngram', char_filter: ['phone']},
+                 sorted: {option: :baz}},
+      tokenizer: {ngram: {type: 'nGram', min_gram: 3, max_gram: 3}},
+      char_filter: {phone: {type: 'pattern_replace', pattern: '[^\d]', replacement: ''}},
+      filter: {names_nysiis: {type: 'phonetic', encoder: 'nysiis', replace: false}}
+    }}} }
+  end
+
   describe '.define_type' do
     specify { DummiesIndex.type_hash['dummy'].should == DummiesIndex::Dummy }
 

data/spec/chewy/query/criteria_spec.rb

@@ -13,6 +13,7 @@ describe Chewy::Query::Criteria do
   its(:fields) { should == [] }
   its(:types) { should == [] }
 
+  its(:none?){ should be_false }
   its(:facets?) { should be_false }
   its(:queries?) { should be_false }
   its(:filters?) { should be_false }

data/spec/chewy/query_spec.rb

@@ -72,6 +72,20 @@ describe Chewy::Query do
     specify { expect { subject.offset(10) }.not_to change { subject.criteria.options } }
   end
 
+  describe '#none' do
+    specify { subject.none.should be_a described_class }
+    specify { subject.none.should_not == subject }
+    specify { subject.none.criteria.should be_none }
+
+    context do
+      before { described_class.any_instance.should_not_receive(:_response) }
+
+      specify { subject.none.to_a.should == [] }
+      specify { subject.query(match: 'hello').none.to_a.should == [] }
+      specify { subject.none.query(match: 'hello').to_a.should == [] }
+    end
+  end
+
   describe '#query' do
     specify { subject.query(match: 'hello').should be_a described_class }
     specify { subject.query(match: 'hello').should_not == subject }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chewy
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - pyromaniac
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-09 00:00:00.000000000 Z
+date: 2014-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -157,6 +157,7 @@ files:
 - filters
 - lib/chewy.rb
 - lib/chewy/config.rb
+- lib/chewy/errors.rb
 - lib/chewy/fields/base.rb
 - lib/chewy/fields/default.rb
 - lib/chewy/fields/root.rb
@@ -164,6 +165,7 @@ files:
 - lib/chewy/index/actions.rb
 - lib/chewy/index/aliases.rb
 - lib/chewy/index/search.rb
+- lib/chewy/index/settings.rb
 - lib/chewy/query.rb
 - lib/chewy/query/compose.rb
 - lib/chewy/query/criteria.rb
@@ -211,6 +213,7 @@ files:
 - spec/chewy/index/actions_spec.rb
 - spec/chewy/index/aliases_spec.rb
 - spec/chewy/index/search_spec.rb
+- spec/chewy/index/settings_spec.rb
 - spec/chewy/index_spec.rb
 - spec/chewy/query/criteria_spec.rb
 - spec/chewy/query/filters_spec.rb
@@ -277,6 +280,7 @@ test_files:
 - spec/chewy/index/actions_spec.rb
 - spec/chewy/index/aliases_spec.rb
 - spec/chewy/index/search_spec.rb
+- spec/chewy/index/settings_spec.rb
 - spec/chewy/index_spec.rb
 - spec/chewy/query/criteria_spec.rb
 - spec/chewy/query/filters_spec.rb