chewy 0.8.4 → 0.9.0

data/lib/chewy/type/mapping.rb

@@ -31,8 +31,8 @@ module Chewy
         #     end
         #   end
         #
-        def root options = {}, &block
-          raise "Root is already defined" if root_object
+        def root(options = {}, &block)
+          raise 'Root is already defined' if root_object
           build_root(options, &block)
         end
 
@@ -96,7 +96,7 @@ module Chewy
         #     field :en, value: ->(name) { name['en'] }
         #   end
         #
-        # Off course it is possible to define object fields contents dynamically
+        # Of course it is possible to define object fields contents dynamically
         # but make sure evaluation proc returns hash:
         #
         #   field :name, type: 'object', value: -> { name_translations }
@@ -109,7 +109,7 @@ module Chewy
         #     field :sorted, analyzer: 'sorted'
         #   end
         #
-        def field *args, &block
+        def field(*args, &block)
           options = args.extract_options!
           build_root
 
@@ -136,10 +136,9 @@ module Chewy
         #       end
         #     end
         #   end
-        def agg *args, &block
-          options = args.extract_options!
+        def agg(name, &block)
           build_root
-          self._agg_defs = _agg_defs.merge(args.first => block)
+          self._agg_defs = _agg_defs.merge(name => block)
         end
         alias_method :aggregation, :agg
 
@@ -148,7 +147,7 @@ module Chewy
         #   class CarsIndex < Chewy::Index
         #     define_type Car do
         #       template 'model.*', type: 'string', analyzer: 'special'
-        #       field 'model', type: 'object' # here we can put { ru: 'Мерседес', en: 'Mercedes' }
+        #       field 'model', type: 'object' # here we can put { de: 'Der Mercedes', en: 'Mercedes' }
         #                                     # and template will be applyed to this field
         #     end
         #   end
@@ -163,8 +162,8 @@ module Chewy
         #   template /tit.+/, 'string', mapping_hash # "match_mapping_type" as the optionsl second argument
         #   template template42: {match: 'hello*', mapping: {type: 'object'}} # or even pass a template as is
         #
-        def template *args
-          build_root.dynamic_template *args
+        def template(*args)
+          build_root.dynamic_template(*args)
         end
         alias_method :dynamic_template, :template
 
@@ -176,20 +175,21 @@ module Chewy
 
       private
 
-        def expand_nested field, &block
+        def expand_nested(field, &block)
           if @_current_field
             field.parent = @_current_field
             @_current_field.children.push(field)
           end
 
-          if block
-            previous_field, @_current_field = @_current_field, field
-            block.call
-            @_current_field = previous_field
-          end
+          return unless block
+
+          previous_field = @_current_field
+          @_current_field = field
+          yield
+          @_current_field = previous_field
         end
 
-        def build_root options = {}, &block
+        def build_root(options = {}, &block)
           return root_object if root_object
           self.root_object = Chewy::Fields::Root.new(type_name, options)
           expand_nested(root_object, &block)

data/lib/chewy/type/observe.rb

@@ -8,7 +8,7 @@ module Chewy
           options = args.extract_options!
           method = args.first
 
-          Proc.new do
+          proc do
             backreference = if method && method.to_s == 'self'
               self
             elsif method
@@ -18,9 +18,11 @@ module Chewy
             end
 
             reference = if type_name.is_a?(Proc)
-              type_name.arity == 0 ?
-                instance_exec(&type_name) :
+              if type_name.arity.zero?
+                instance_exec(&type_name)
+              else
                 type_name.call(self)
+              end
             else
               type_name
             end
@@ -31,11 +33,11 @@ module Chewy
 
         def extract_callback_options!(args)
           options = args.extract_options!
-          options.each_key.with_object({}) { |key, hash|
+          result = options.each_key.with_object({}) do |key, hash|
             hash[key] = options.delete(key) if [:if, :unless].include?(key)
-          }.tap {
-            args.push(options) unless options.empty?
-          }
+          end
+          args.push(options) unless options.empty?
+          result
         end
       end
 

data/lib/chewy/type/witchcraft.rb

@@ -1,10 +1,11 @@
-def try_require lib
-  require lib
+begin
+  require 'method_source'
+  require 'parser/current'
+  require 'unparser'
 rescue LoadError
+  nil
 end
 
-%w[method_source parser/current unparser].each { |lib| try_require lib }
-
 module Chewy
   class Type
     module Witchcraft
@@ -22,9 +23,9 @@ module Chewy
 
         def check_requirements!
           messages = []
-          messages << "MethodSource gem is required for the Witchcraft™, please add `gem 'method_source'` to your Gemfile" unless Proc.method_defined?(:source)
-          messages << "Parser gem is required for the Witchcraft™, please add `gem 'parser'` to your Gemfile" unless '::Parser'.safe_constantize
-          messages << "Unparser gem is required for the Witchcraft™, please add `gem 'unparser'` to your Gemfile" unless '::Unparser'.safe_constantize
+          messages << "MethodSource gem is required for the Witchcraft, please add `gem 'method_source'` to your Gemfile" unless Proc.method_defined?(:source)
+          messages << "Parser gem is required for the Witchcraft, please add `gem 'parser'` to your Gemfile" unless '::Parser'.safe_constantize
+          messages << "Unparser gem is required for the Witchcraft, please add `gem 'unparser'` to your Gemfile" unless '::Unparser'.safe_constantize
           messages = messages.join("\n")
 
           raise messages if messages.present?
@@ -40,19 +41,22 @@ module Chewy
       end
 
       class Cauldron
+        attr_reader :locals
+
         def initialize(type)
           @type = type
+          @locals = []
         end
 
         def brew(object, crutches = nil)
-          alicorn.call(object, crutches).as_json
+          alicorn.call(locals, object, crutches).as_json
         end
 
       private
 
         def alicorn
           @alicorn ||= class_eval <<-RUBY
-            -> (object0, crutches) do
+            -> (locals, object0, crutches) do
               #{composed_values(@type.root_object, 0)}
             end
           RUBY
@@ -94,21 +98,21 @@ module Chewy
             <<-RUBY
               (if #{object}.is_a?(Hash)
                 {
-                  #{non_proc_fields.map do |field|
-                    fetcher = "#{object}.has_key?(:#{field.name}) ? #{object}[:#{field.name}] : #{object}['#{field.name}']"
-                    "#{field.name}: #{composed_value(field, fetcher, nesting)}"
+                  #{non_proc_fields.map do |f|
+                    fetcher = "#{object}.has_key?(:#{f.name}) ? #{object}[:#{f.name}] : #{object}['#{f.name}']"
+                    "#{f.name}: #{composed_value(f, fetcher, nesting)}"
                   end.join(', ')}
                 }
               else
                 {
-                  #{non_proc_fields.map do |field|
-                    "#{field.name}: #{composed_value(field, "#{object}.#{field.name}", nesting)}"
+                  #{non_proc_fields.map do |f|
+                    "#{f.name}: #{composed_value(f, "#{object}.#{f.name}", nesting)}"
                   end.join(', ')}
                 }
               end)
             RUBY
           else
-            "{}"
+            '{}'
           end
         end
 
@@ -118,13 +122,13 @@ module Chewy
           if proc_fields.present?
             <<-RUBY
               {
-                #{proc_fields.map do |field|
-                  "#{field.name}: (#{composed_value(field, source_for(field.value, nesting), nesting)})"
+                #{proc_fields.map do |f|
+                  "#{f.name}: (#{composed_value(f, source_for(f.value, nesting), nesting)})"
                 end.join(', ')}
               }
             RUBY
           else
-            "{}"
+            '{}'
           end
         end
 
@@ -145,26 +149,36 @@ module Chewy
           raise "No lambdas found, try to reformat your code:\n`#{proc.source}`" unless lambdas
 
           source = lambdas.first
-          if proc.arity == 0
+          proc_params = proc.parameters.map(&:second)
+
+          if proc.arity.zero?
             source = replace_self(source, :"object#{nesting}")
             source = replace_send(source, :"object#{nesting}")
           elsif proc.arity < 0
             raise "Splat arguments are unsupported by witchcraft:\n`#{proc.source}"
           else
             (nesting + 1).times do |n|
-              source = replace_lvar(source, proc.parameters[n][1], :"object#{n}") if proc.parameters[n]
+              source = replace_lvar(source, proc_params[n], :"object#{n}") if proc_params[n]
+            end
+            source = replace_lvar(source, proc_params[nesting + 1], :crutches) if proc_params[nesting + 1]
+
+            binding_variable_list(source).each do |variable|
+              locals.push(proc.binding.eval(variable.to_s))
+              source = replace_local(source, variable, locals.size - 1)
             end
-            source = replace_lvar(source, proc.parameters[nesting + 1][1], :crutches) if proc.parameters[nesting + 1]
+
           end
+
           Unparser.unparse(source)
         end
 
         def exctract_lambdas(node)
+          return unless node.is_a?(Parser::AST::Node)
           if node.type == :block && node.children[0].type == :send && node.children[0].to_a == [nil, :lambda]
-            node.children[2]
+            [node.children[2]]
           else
             node.children.map { |child| exctract_lambdas(child) }.flatten.compact
-          end if node.is_a?(Parser::AST::Node)
+          end
         end
 
         def replace_lvar(node, old_variable, new_variable)
@@ -202,6 +216,31 @@ module Chewy
             node
           end
         end
+
+        def replace_local(node, variable, local_index)
+          if node.is_a?(Parser::AST::Node)
+            if node.type == :send && node.children.to_a == [nil, variable]
+              node.updated(nil, [
+                Parser::AST::Node.new(:lvar, [:locals]),
+                :[],
+                Parser::AST::Node.new(:int, [local_index])
+              ])
+            else
+              node.updated(nil, node.children.map { |child| replace_local(child, variable, local_index) })
+            end
+          else
+            node
+          end
+        end
+
+        def binding_variable_list(node)
+          return unless node.is_a?(Parser::AST::Node)
+          if node.type == :send && node.children[0].nil?
+            node.children[1]
+          else
+            node.children.map { |child| binding_variable_list(child) }.flatten.compact.uniq
+          end
+        end
       end
     end
   end

data/lib/chewy/type/wrapper.rb

@@ -19,34 +19,40 @@ module Chewy
         end
       end
 
-      def method_missing(method_name, *args, &block)
-        method_name.to_s.match(/_highlight\z/) do |match|
-          return highlight(match.pre_match) if highlight?(match.pre_match)
+      def method_missing(method, *args, &block)
+        m = method.to_s
+        if (name = highlight_name(m))
+          highlight(name)
+        elsif @attributes.key?(m)
+          @attributes[m]
+        elsif attribute_defined?(m)
+          nil
+        else
+          super
         end
-        return @attributes[method_name.to_s] if @attributes.key?(method_name.to_s)
-        return nil if attribute_defined?(method_name.to_s)
-        super
       end
 
-      def respond_to_missing?(method_name, include_private = false)
-        method_name.to_s.match(/_highlight\z/) { |m| highlight?(m.pre_match) } ||
-          @attributes.key?(method_name.to_s) ||
-          attribute_defined?(method_name.to_s) ||
-          super
+      def respond_to_missing?(method, include_private = false)
+        m = method.to_s
+        highlight_name(m) || @attributes.key?(m) || attribute_defined?(m) || super
       end
 
-      private
+    private
+
+      def highlight_name(method)
+        method.sub(/_highlight\z/, '') if method.end_with?('_highlight')
+      end
 
       def attribute_defined?(attribute)
         self.class.root_object && self.class.root_object.children.find { |a| a.name.to_s == attribute }.present?
       end
 
       def highlight(attribute)
-        _data["highlight"][attribute].first
+        _data['highlight'][attribute].first
       end
 
       def highlight?(attribute)
-        _data.key?("highlight") && _data["highlight"].key?(attribute)
+        _data.key?('highlight') && _data['highlight'].key?(attribute)
       end
     end
   end

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '0.8.4'
+  VERSION = '0.9.0'.freeze
 end

data/lib/generators/chewy/install_generator.rb

@@ -1,11 +1,11 @@
 module Chewy
   module Generators
     class InstallGenerator < Rails::Generators::Base
-      source_root File.expand_path("../../templates", __FILE__)
+      source_root File.expand_path('../../templates', __FILE__)
 
       def copy_configuration
-        template "chewy.yml", "config/chewy.yml"
+        template 'chewy.yml', 'config/chewy.yml'
       end
     end
   end
-end
+end

data/lib/tasks/chewy.rake

@@ -2,48 +2,53 @@ require 'chewy/rake_helper'
 
 namespace :chewy do
   desc 'Destroy, recreate and import data to specified index'
-  task :reset, [:index] => :environment do |task, args|
+  task reset: :environment do |_task, args|
     Chewy::RakeHelper.subscribed_task_stats do
+      indexes = args.extras
 
-      if args[:index].present?
-        Chewy::RakeHelper.reset_index(args[:index])
+      if indexes.empty? || indexes.first.tr!('-', '')
+        Chewy::RakeHelper.reset_all(indexes)
       else
-        Chewy::RakeHelper.reset_all
+        Chewy::RakeHelper.reset_index(indexes)
       end
     end
   end
 
-  namespace :reset do
-    desc 'Destroy, recreate and import data for all found indexes'
-    task all: :environment do
-      ActiveSupport::Deprecation.warn('`rake chewy:reset:all` is deprecated and will be removed soon. Use `rake chewy:reset` instead')
+  desc 'Updates data specified index'
+  task update: :environment do |_task, args|
+    Chewy::RakeHelper.subscribed_task_stats do
+      indexes = args.extras
 
-      Chewy::RakeHelper.subscribed_task_stats do
-        Chewy::RakeHelper.reset_all
+      if indexes.empty? || indexes.first.tr!('-', '')
+        Chewy::RakeHelper.update_all(indexes)
+      else
+        Chewy::RakeHelper.update_index(indexes)
       end
     end
   end
 
-  desc 'Updates data specified index'
-  task :update, [:index] => :environment do |task, args|
+  desc 'Applies changes that were done from specified moment (as a timestamp)'
+  task apply_changes_from: :environment do |_task, args|
     Chewy::RakeHelper.subscribed_task_stats do
+      params = args.extras
 
-      if args[:index].present?
-        Chewy::RakeHelper.update_index(args[:index])
+      if params.empty?
+        puts 'Please specify a timestamp like chewy:apply_changes_from[1469528705]'
       else
-        Chewy::RakeHelper.update_all
+        timestamp, retries = params
+        time = Time.at(timestamp.to_i)
+        Chewy::Journal::Apply.since(time, retries: (retries.to_i if retries))
       end
     end
   end
 
-  namespace :update do
-    desc 'Updates data for all found indexes'
-    task all: :environment do
-      ActiveSupport::Deprecation.warn('`rake chewy:update:all` is deprecated and will be removed soon. Use `rake chewy:update` instead')
-
-      Chewy::RakeHelper.subscribed_task_stats do
-        Chewy::RakeHelper.update_all
-      end
+  desc 'Cleans journal index. It accepts timestamp until which journal will be cleaned'
+  task clean_journal: :environment do |_task, args|
+    timestamp = args.extras.first
+    if timestamp
+      Chewy::Journal::Clean.until(Time.at(timestamp.to_i))
+    else
+      Chewy::Journal.delete!
     end
   end
 end