chewy 0.8.4 → 0.9.0

data/lib/chewy/query/nodes/has_child.rb

@@ -5,6 +5,7 @@ module Chewy
     module Nodes
       class HasChild < HasRelation
       private
+
         def _relation
           :has_child
         end

data/lib/chewy/query/nodes/has_parent.rb

@@ -5,6 +5,7 @@ module Chewy
     module Nodes
       class HasParent < HasRelation
       private
+
         def _relation
           :has_parent
         end

data/lib/chewy/query/nodes/has_relation.rb

@@ -6,7 +6,7 @@ module Chewy
       class HasRelation < Expr
         include Compose
 
-        def initialize type, outer = nil
+        def initialize(type, outer = nil)
           @type = type.to_s
           @outer = outer
           @query_mode = :must
@@ -15,26 +15,23 @@ module Chewy
           @filters = []
         end
 
-        def query_mode mode
+        def query_mode(mode)
           @query_mode = mode
           self
         end
 
-        def filter_mode mode
+        def filter_mode(mode)
           @filter_mode = mode
           self
         end
 
-        def query params = nil, &block
-          if block
-            raise 'Query DLS is not supported yet'
-          else
-            @queries.push(params)
-          end
+        def query(params = nil, &block)
+          raise 'Query DLS is not supported yet' if block
+          @queries.push(params)
           self
         end
 
-        def filter params = nil, &block
+        def filter(params = nil, &block)
           if block
             @filters.push(Chewy::Query::Filters.new(@outer, &block).__render__)
           else
@@ -48,12 +45,13 @@ module Chewy
           filters = _filters_join @filters, @filter_mode
 
           body = if filters && !queries
-            {filter: filters}
+            { filter: filters }
           else
             _filtered_query(queries, filters)
-          end || {}
+          end
+          body ||= {}
 
-          {_relation => body.merge(type: @type)} if body
+          { _relation => body.merge(type: @type) }
         end
       end
     end

data/lib/chewy/query/nodes/match_all.rb

@@ -3,7 +3,7 @@ module Chewy
     module Nodes
       class MatchAll < Expr
         def __render__
-          {match_all: {}}
+          { match_all: {} }
         end
       end
     end

data/lib/chewy/query/nodes/missing.rb

@@ -2,7 +2,7 @@ module Chewy
   class Query
     module Nodes
       class Missing < Expr
-        def initialize name, options = {}
+        def initialize(name, options = {})
           @name = name.to_s
           @options = options.reverse_merge(existence: true, null_value: false)
         end
@@ -12,7 +12,7 @@ module Chewy
         end
 
         def __render__
-          {missing: {field: @name}.merge(@options.slice(:existence, :null_value))}
+          { missing: { field: @name }.merge(@options.slice(:existence, :null_value)) }
         end
       end
     end

data/lib/chewy/query/nodes/not.rb

@@ -2,7 +2,7 @@ module Chewy
   class Query
     module Nodes
       class Not < Expr
-        def initialize expr, options = {}
+        def initialize(expr, options = {})
           @expr = expr
           @options = options
         end
@@ -14,9 +14,9 @@ module Chewy
         def __render__
           expr = @expr.__render__
           if @options.key?(:cache)
-            {not: {filter: expr, _cache: !!@options[:cache]}}
+            { not: { filter: expr, _cache: !!@options[:cache] } }
           else
-            {not: expr}
+            { not: expr }
           end
         end
       end

data/lib/chewy/query/nodes/or.rb

@@ -2,7 +2,7 @@ module Chewy
   class Query
     module Nodes
       class Or < Expr
-        def initialize *nodes
+        def initialize(*nodes)
           @options = nodes.extract_options!
           @nodes = nodes.flatten.map { |node| node.is_a?(self.class) ? node.__nodes__ : node }.flatten
         end
@@ -14,9 +14,9 @@ module Chewy
         def __render__
           nodes = @nodes.map(&:__render__)
           if @options.key?(:cache)
-            {or: {filters: nodes, _cache: !!@options[:cache]}}
+            { or: { filters: nodes, _cache: !!@options[:cache] } }
           else
-            {or: nodes}
+            { or: nodes }
           end
         end
       end

data/lib/chewy/query/nodes/prefix.rb

@@ -2,13 +2,14 @@ module Chewy
   class Query
     module Nodes
       class Prefix < Expr
-        def initialize name, value, options = {}
+        def initialize(name, value, options = {})
           @name = name.to_s
-          @value, @options = value, options
+          @value = value
+          @options = options
         end
 
         def __render__
-          filter = {prefix: {@name => @value}}
+          filter = { prefix: { @name => @value } }
           filter[:prefix][:_cache] = !!@options[:cache] if @options.key?(:cache)
           filter
         end

data/lib/chewy/query/nodes/query.rb

@@ -2,16 +2,16 @@ module Chewy
   class Query
     module Nodes
       class Query < Expr
-        def initialize query, options = {}
+        def initialize(query, options = {})
           @query = query
           @options = options
         end
 
         def __render__
           if @options.key?(:cache)
-            {fquery: {query: @query, _cache: !!@options[:cache]}}
+            { fquery: { query: @query, _cache: !!@options[:cache] } }
           else
-            {query: @query}
+            { query: @query }
           end
         end
       end

data/lib/chewy/query/nodes/range.rb

@@ -3,22 +3,22 @@ module Chewy
     module Nodes
       class Range < Expr
         EXECUTION = {
-          :i => :index,
-          :index => :index,
-          :f => :fielddata,
-          :fielddata => :fielddata,
-        }
+          i: :index,
+          index: :index,
+          f: :fielddata,
+          fielddata: :fielddata
+        }.freeze
 
-        def initialize name, *args
+        def initialize(name, *args)
           @name = name.to_s
           @options = args.extract_options!
-          @range = @options.reject { |k, v| ![:gt, :lt].include?(k) }
-          @bounds = @options.reject { |k, v| ![:left_closed, :right_closed].include?(k) }
+          @range = @options.reject { |k, _v| ![:gt, :lt].include?(k) }
+          @bounds = @options.reject { |k, _v| ![:left_closed, :right_closed].include?(k) }
           execution = EXECUTION[args.first.to_sym] if args.first
           @options[:execution] = execution if execution
         end
 
-        def & other
+        def &(other)
           if other.is_a?(self.class) && other.__name__ == @name
             state = __state__.merge(other.__state__)
 
@@ -51,11 +51,11 @@ module Chewy
           body[@bounds[:left_closed] ? :gte : :gt] = @range[:gt] if @range.key?(:gt)
           body[@bounds[:right_closed] ? :lte : :lt] = @range[:lt] if @range.key?(:lt)
 
-          filter = {@name => body}
+          filter = { @name => body }
           filter[:_cache] = !!@options[:cache] if @options.key?(:cache)
           filter.merge!(@options.slice(:execution))
 
-          {range: filter}
+          { range: filter }
         end
       end
     end

data/lib/chewy/query/nodes/raw.rb

@@ -2,7 +2,7 @@ module Chewy
   class Query
     module Nodes
       class Raw < Expr
-        def initialize raw
+        def initialize(raw)
           @raw = raw
         end
 

data/lib/chewy/query/nodes/regexp.rb

@@ -2,28 +2,32 @@ module Chewy
   class Query
     module Nodes
       class Regexp < Expr
-        FLAGS = %w(all anystring automaton complement empty intersection interval none)
+        FLAGS = %w(all anystring automaton complement empty intersection interval none).freeze
 
-        def initialize name, regexp, *args
+        def initialize(name, regexp, *args)
           @name = name.to_s
           @regexp = regexp.respond_to?(:source) ? regexp.source : regexp.to_s
           @options = args.extract_options!
-          if args.present? || @options[:flags].present?
-            @options[:flags] = FLAGS & (args.present? ? args.flatten : @options[:flags]).map(&:to_s).map(&:downcase)
-          end
+          return if args.blank? && @options[:flags].blank?
+          @options[:flags] = FLAGS & (args.present? ? args.flatten : @options[:flags]).map(&:to_s).map(&:downcase)
         end
 
         def __render__
-          body = @options[:flags] ?
-            {value: @regexp, flags: @options[:flags].map(&:to_s).map(&:upcase).uniq.join('|')} :
+          body = if @options[:flags]
+            { value: @regexp, flags: @options[:flags].map(&:to_s).map(&:upcase).uniq.join('|') }
+          else
             @regexp
-          filter = {@name => body}
+          end
+          filter = { @name => body }
           if @options.key?(:cache)
             filter[:_cache] = !!@options[:cache]
-            filter[:_cache_key] = @options[:cache].is_a?(TrueClass) || @options[:cache].is_a?(FalseClass) ?
-              @regexp.underscore : @options[:cache]
+            filter[:_cache_key] = if @options[:cache].is_a?(TrueClass) || @options[:cache].is_a?(FalseClass)
+              @regexp.underscore
+            else
+              @options[:cache]
+            end
           end
-          {regexp: filter}
+          { regexp: filter }
         end
       end
     end

data/lib/chewy/query/nodes/script.rb

@@ -2,17 +2,17 @@ module Chewy
   class Query
     module Nodes
       class Script < Expr
-        def initialize script, params = {}
+        def initialize(script, params = {})
           @script = script
           @params = params
-          @options = params.reject { |k, v| ![:cache].include?(k) }
+          @options = params.reject { |k, _v| ![:cache].include?(k) }
         end
 
         def __render__
-          script = {script: @script}
-          script.merge!(params: @params) if @params.present?
-          script.merge!(_cache: !!@options[:cache]) if @options.key?(:cache)
-          {script: script}
+          script = { script: @script }
+          script[:params] = @params if @params.present?
+          script[:_cache] = !!@options[:cache] if @options.key?(:cache)
+          { script: script }
         end
       end
     end

data/lib/chewy/query/pagination/will_paginate.rb

@@ -7,12 +7,12 @@ module Chewy
 
         attr_reader :current_page, :per_page
 
-        def paginate(options={})
+        def paginate(options = {})
           @current_page = ::WillPaginate::PageNumber(options[:page] || @current_page || 1)
           @page_multiplier = @current_page - 1
           @per_page = (options[:per_page] || @per_page || ::WillPaginate.per_page).to_i
 
-          #call Chewy::Query methods to limit results
+          # call Chewy::Query methods to limit results
           limit(@per_page).offset(@page_multiplier * @per_page)
         end
 

data/lib/chewy/railtie.rb

@@ -51,7 +51,7 @@ module Chewy
     end
 
     initializer 'chewy.logger', after: 'active_record.logger' do
-      ActiveSupport.on_load(:active_record)  { Chewy.logger ||= ActiveRecord::Base.logger }
+      ActiveSupport.on_load(:active_record) { Chewy.logger ||= ActiveRecord::Base.logger }
     end
 
     initializer 'chewy.migration_strategy' do
@@ -70,9 +70,9 @@ module Chewy
       app.config.middleware.insert_after(Rails::Rack::Logger, RequestStrategy)
     end
 
-    initializer 'chewy.add_app_chewy_path' do |app|
+    initializer 'chewy.add_indices_path' do |_app|
       Chewy::Railtie.all_engines.each do |engine|
-        engine.paths.add 'app/chewy'
+        engine.paths.add Chewy.configuration[:indices_path]
       end
     end
   end

data/lib/chewy/rake_helper.rb

@@ -1,26 +1,32 @@
 module Chewy
   module RakeHelper
     class << self
-
-      def subscribed_task_stats(&block)
-        callback = ->(name, start, finish, id, payload) do
+      def subscribed_task_stats
+        import_callback = lambda do |_name, start, finish, _id, payload|
           duration = (finish - start).round(2)
           puts "  Imported #{payload[:type]} for #{duration}s, documents total: #{payload[:import].try(:[], :index).to_i}"
-          payload[:errors].each do |action, errors|
-            puts "    #{action.to_s.humanize} errors:"
-            errors.each do |error, documents|
-              puts "      `#{error}`"
-              puts "        on #{documents.count} documents: #{documents}"
+          if payload[:errors]
+            payload[:errors].each do |action, errors|
+              puts "    #{action.to_s.humanize} errors:"
+              errors.each do |error, documents|
+                puts "      `#{error}`"
+                puts "        on #{documents.count} documents: #{documents}"
+              end
             end
-          end if payload[:errors]
+          end
         end
-        ActiveSupport::Notifications.subscribed(callback, 'import_objects.chewy') do
-          yield
+        journal_callback = lambda do |_, _, _, _, payload|
+          puts "Applying journal. Stage #{payload[:stage]}"
+        end
+        ActiveSupport::Notifications.subscribed(journal_callback, 'apply_journal.chewy') do
+          ActiveSupport::Notifications.subscribed(import_callback, 'import_objects.chewy') do
+            yield
+          end
         end
       end
 
       def eager_load_chewy!
-        dirs = Chewy::Railtie.all_engines.map { |engine| engine.paths['app/chewy'] }.compact.map(&:existent).flatten.uniq
+        dirs = Chewy::Railtie.all_engines.map { |engine| engine.paths[Chewy.configuration[:indices_path]] }.compact.map(&:existent).flatten.uniq
 
         dirs.each do |dir|
           Dir.glob(File.join(dir, '**/*.rb')).each do |file|
@@ -29,36 +35,51 @@ module Chewy
         end
       end
 
-      def normalize_index index
+      def all_indexes
+        eager_load_chewy!
+        Chewy::Index.descendants
+      end
+
+      def normalize_index(index)
+        return index if index.is_a?(Chewy::Index)
         "#{index.to_s.gsub(/index\z/i, '').camelize}Index".constantize
       end
 
+      def normalize_indexes(*indexes)
+        indexes.flatten.map { |index| normalize_index(index) }
+      end
+
       # Performs zero downtime reindexing of all documents in the specified index.
-      def reset_index index
-        index = normalize_index(index)
-        puts "Resetting #{index}"
-        index.reset! (Time.now.to_f * 1000).round
+      def reset_index(*indexes)
+        normalize_indexes(indexes).each do |index|
+          puts "Resetting #{index}"
+          time = Time.now
+          index.reset!((time.to_f * 1000).round)
+          if index.journal?
+            Chewy::Journal.create
+            Chewy::Journal::Apply.since(time, only: [index])
+          end
+        end
       end
 
       # Performs zero downtime reindexing of all documents across all indices.
-      def reset_all
-        eager_load_chewy!
-        Chewy::Index.descendants.each { |index| reset_index index }
+      def reset_all(*except)
+        reset_index(all_indexes - normalize_indexes(except))
       end
 
-      def update_index index
-        index = normalize_index(index)
-        puts "Updating #{index}"
-        if index.exists?
-          index.import
-        else
-          puts "Index `#{index.index_name}` does not exists. Use rake chewy:reset[#{index.index_name}] to create and update it."
+      def update_index(*indexes)
+        normalize_indexes(indexes).each do |index|
+          puts "Updating #{index}"
+          if index.exists?
+            index.import
+          else
+            puts "Index `#{index.index_name}` does not exists. Use rake chewy:reset[#{index.index_name}] to create and update it."
+          end
         end
       end
 
-      def update_all
-        eager_load_chewy!
-        Chewy::Index.descendants.each { |index| update_index index }
+      def update_all(*except)
+        update_index(all_indexes - normalize_indexes(except))
       end
     end
   end