chewy 0.8.3 → 0.8.4

data/lib/chewy/type/witchcraft.rb

@@ -0,0 +1,208 @@
+def try_require lib
+  require lib
+rescue LoadError
+end
+
+%w[method_source parser/current unparser].each { |lib| try_require lib }
+
+module Chewy
+  class Type
+    module Witchcraft
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_witchcraft, instance_reader: false, instance_writer: false
+      end
+
+      module ClassMethods
+        def witchcraft!
+          self._witchcraft = true
+          check_requirements!
+        end
+
+        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 = messages.join("\n")
+
+          raise messages if messages.present?
+        end
+
+        def witchcraft?
+          !!_witchcraft
+        end
+
+        def cauldron
+          @cauldron ||= Cauldron.new(self)
+        end
+      end
+
+      class Cauldron
+        def initialize(type)
+          @type = type
+        end
+
+        def brew(object, crutches = nil)
+          alicorn.call(object, crutches).as_json
+        end
+
+      private
+
+        def alicorn
+          @alicorn ||= class_eval <<-RUBY
+            -> (object0, crutches) do
+              #{composed_values(@type.root_object, 0)}
+            end
+          RUBY
+        end
+
+        def composed_values(field, nesting)
+          source = <<-RUBY
+            non_proc_values#{nesting} = #{non_proc_values(field, nesting)}
+            proc_values#{nesting} = #{proc_values(field, nesting)}
+            non_proc_values#{nesting}.merge!(proc_values#{nesting})
+          RUBY
+          source.gsub("\n,", ',')
+        end
+
+        def composed_value(field, fetcher, nesting)
+          nesting = nesting.next
+          if field.children.present? && !field.multi_field?
+            <<-RUBY
+              (result#{nesting} = #{fetcher}
+              if result#{nesting}.respond_to?(:to_ary)
+                result#{nesting}.map do |object#{nesting}|
+                  #{composed_values(field, nesting)}
+                end
+              else
+                object#{nesting} = result#{nesting}
+                #{composed_values(field, nesting)}
+              end)
+            RUBY
+          else
+            fetcher
+          end
+        end
+
+        def non_proc_values(field, nesting)
+          non_proc_fields = non_proc_fields_for(field)
+          object = "object#{nesting}"
+
+          if non_proc_fields.present?
+            <<-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)}"
+                  end.join(', ')}
+                }
+              else
+                {
+                  #{non_proc_fields.map do |field|
+                    "#{field.name}: #{composed_value(field, "#{object}.#{field.name}", nesting)}"
+                  end.join(', ')}
+                }
+              end)
+            RUBY
+          else
+            "{}"
+          end
+        end
+
+        def proc_values(field, nesting)
+          proc_fields = proc_fields_for(field)
+
+          if proc_fields.present?
+            <<-RUBY
+              {
+                #{proc_fields.map do |field|
+                  "#{field.name}: (#{composed_value(field, source_for(field.value, nesting), nesting)})"
+                end.join(', ')}
+              }
+            RUBY
+          else
+            "{}"
+          end
+        end
+
+        def non_proc_fields_for(parent)
+          return [] unless parent
+          (parent.children || []).select { |field| !(field.value && field.value.is_a?(Proc)) }
+        end
+
+        def proc_fields_for(parent)
+          return [] unless parent
+          (parent.children || []).select { |field| field.value && field.value.is_a?(Proc) }
+        end
+
+        def source_for(proc, nesting)
+          ast = Parser::CurrentRuby.parse(proc.source)
+          lambdas = exctract_lambdas(ast)
+
+          raise "No lambdas found, try to reformat your code:\n`#{proc.source}`" unless lambdas
+
+          source = lambdas.first
+          if proc.arity == 0
+            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]
+            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)
+          if node.type == :block && node.children[0].type == :send && node.children[0].to_a == [nil, :lambda]
+            node.children[2]
+          else
+            node.children.map { |child| exctract_lambdas(child) }.flatten.compact
+          end if node.is_a?(Parser::AST::Node)
+        end
+
+        def replace_lvar(node, old_variable, new_variable)
+          if node.is_a?(Parser::AST::Node)
+            if node.type == :lvar && node.children.to_a == [old_variable]
+              node.updated(nil, [new_variable])
+            else
+              node.updated(nil, node.children.map { |child| replace_lvar(child, old_variable, new_variable) })
+            end
+          else
+            node
+          end
+        end
+
+        def replace_send(node, variable)
+          if node.is_a?(Parser::AST::Node)
+            if node.type == :send && node.children[0].nil?
+              node.updated(nil, [Parser::AST::Node.new(:lvar, [variable]), *node.children[1..-1]])
+            else
+              node.updated(nil, node.children.map { |child| replace_send(child, variable) })
+            end
+          else
+            node
+          end
+        end
+
+        def replace_self(node, variable)
+          if node.is_a?(Parser::AST::Node)
+            if node.type == :self
+              Parser::AST::Node.new(:lvar, [variable])
+            else
+              node.updated(nil, node.children.map { |child| replace_self(child, variable) })
+            end
+          else
+            node
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chewy/type/wrapper.rb

@@ -19,16 +19,34 @@ module Chewy
         end
       end
 
-      def method_missing(method, *args, &block)
-        if @attributes.key?(method.to_s)
-          @attributes[method.to_s]
-        else
-          nil
+      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)
         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
+      end
+
+      private
+
+      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
       end
 
-      def respond_to_missing?(method, _)
-        @attributes.key?(method.to_s) || super
+      def highlight?(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.3'
+  VERSION = '0.8.4'
 end

data/lib/tasks/chewy.rake

@@ -3,39 +3,47 @@ require 'chewy/rake_helper'
 namespace :chewy do
   desc 'Destroy, recreate and import data to specified index'
   task :reset, [:index] => :environment do |task, args|
-    Chewy::RakeHelper.subscribe_task_stats!
+    Chewy::RakeHelper.subscribed_task_stats do
 
-    if args[:index].present?
-      Chewy::RakeHelper.reset_index(args[:index])
-    else
-      Chewy::RakeHelper.reset_all
+      if args[:index].present?
+        Chewy::RakeHelper.reset_index(args[:index])
+      else
+        Chewy::RakeHelper.reset_all
+      end
     end
   end
 
   namespace :reset do
     desc 'Destroy, recreate and import data for all found indexes'
     task all: :environment do
-      Chewy::RakeHelper.subscribe_task_stats!
-      Chewy::RakeHelper.reset_all
+      ActiveSupport::Deprecation.warn('`rake chewy:reset:all` is deprecated and will be removed soon. Use `rake chewy:reset` instead')
+
+      Chewy::RakeHelper.subscribed_task_stats do
+        Chewy::RakeHelper.reset_all
+      end
     end
   end
 
   desc 'Updates data specified index'
   task :update, [:index] => :environment do |task, args|
-    Chewy::RakeHelper.subscribe_task_stats!
+    Chewy::RakeHelper.subscribed_task_stats do
 
-    if args[:index].present?
-      Chewy::RakeHelper.update_index(args[:index])
-    else
-      Chewy::RakeHelper.update_all
+      if args[:index].present?
+        Chewy::RakeHelper.update_index(args[:index])
+      else
+        Chewy::RakeHelper.update_all
+      end
     end
   end
 
   namespace :update do
     desc 'Updates data for all found indexes'
     task all: :environment do
-      Chewy::RakeHelper.subscribe_task_stats!
-      Chewy::RakeHelper.update_all
+      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
     end
   end
 end

data/spec/chewy/fields/base_spec.rb

@@ -11,6 +11,10 @@ describe Chewy::Fields::Base do
     specify { expect(field.compose(double(value: ['hello', 'world']))).to eq({name: ['hello', 'world']}) }
 
     specify { expect(described_class.new(:name).compose(double(name: 'hello'))).to eq({name: 'hello'}) }
+    specify { expect(described_class.new(:false_value).compose({false_value: false})).to eq({false_value: false}) }
+    specify { expect(described_class.new(:true_value).compose({true_value: true})).to eq({true_value: true}) }
+    specify { expect(described_class.new(:nil_value).compose({nil_value: nil})).to eq({nil_value: nil}) }
+
 
     context 'nested fields' do
       before do
@@ -62,14 +66,14 @@ describe Chewy::Fields::Base do
 
     context 'hash values' do
       let(:field) { described_class.new(:name, type: 'object') }
-      let(:object) { double(name: { key1: 'value1', key2: 'value2' }) }
+      let(:object) { double(name: { key1: 'value1', key2: 'value2'}) }
 
       before do
         field.children.push(described_class.new(:key1, value: ->(h){ h[:key1] }))
         field.children.push(described_class.new(:key2, value: ->(h){ h[:key2] }))
       end
 
-      specify{ expect(field.compose(object)).to eq({ name: { 'key1' => 'value1', 'key2' => 'value2' } }) }
+      specify{ expect(field.compose(object)).to eq({ name: { 'key1' => 'value1', 'key2' => 'value2'} }) }
     end
   end
 

data/spec/chewy/fields/time_fields_spec.rb

@@ -12,7 +12,7 @@ describe 'Time fields' do
   end
 
   before { PostsIndex::Post.import(
-    double(published_at: ActiveSupport::TimeZone[-28800].parse('2014/12/18 18:00')),
+    double(published_at: ActiveSupport::TimeZone[-28800].parse('2014/12/18 19:00')),
     double(published_at: ActiveSupport::TimeZone[-21600].parse('2014/12/18 20:00')),
     double(published_at: ActiveSupport::TimeZone[-21600].parse('2014/12/17 20:00')),
   ) }
@@ -21,7 +21,7 @@ describe 'Time fields' do
   let(:range) { (time - 1.minute)..(time + 1.minute) }
 
   specify { expect(PostsIndex.total).to eq(3) }
-  specify { expect(PostsIndex.filter { published_at == o{range} }.count).to eq(2) }
-  specify { expect(PostsIndex.filter { published_at == o{range.min.utc..range.max.utc} }.count).to eq(2) }
-  specify { expect(PostsIndex.filter { published_at == o{[range.min.to_date..range.max.to_date]} }.count).to eq(1) }
+  specify { expect(PostsIndex.filter { published_at == o{range} }.count).to eq(1) }
+  specify { expect(PostsIndex.filter { published_at == o{range.min.utc..(range.max + 1.hour).utc} }.count).to eq(2) }
+  specify { expect(PostsIndex.filter { published_at == o{[range.min..range.max]} }.count).to eq(1) }
 end

data/spec/chewy/index/actions_spec.rb

@@ -15,8 +15,8 @@ describe Chewy::Index::Actions do
   end
 
   describe '.create' do
-    specify { expect(DummiesIndex.create["acknowledged"]).to eq(true) }
-    specify { expect(DummiesIndex.create('2013')["acknowledged"]).to eq(true) }
+    specify { expect(DummiesIndex.create['acknowledged']).to eq(true) }
+    specify { expect(DummiesIndex.create('2013')['acknowledged']).to eq(true) }
 
     context do
       before { DummiesIndex.create }
@@ -31,7 +31,7 @@ describe Chewy::Index::Actions do
       specify { expect(DummiesIndex.aliases).to eq([]) }
       specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
       specify { expect(DummiesIndex.create('2013')).to eq(false) }
-      specify { expect(DummiesIndex.create('2014')["acknowledged"]).to eq(true) }
+      specify { expect(DummiesIndex.create('2014')['acknowledged']).to eq(true) }
 
       context do
         before { DummiesIndex.create '2014' }
@@ -49,12 +49,19 @@ describe Chewy::Index::Actions do
   end
 
   describe '.create!' do
-    specify { expect(DummiesIndex.create!["acknowledged"]).to eq(true) }
-    specify { expect(DummiesIndex.create!('2013')["acknowledged"]).to eq(true) }
+    specify { expect(DummiesIndex.create!['acknowledged']).to eq(true) }
+    specify { expect(DummiesIndex.create!('2013')['acknowledged']).to eq(true) }
 
     context do
       before { DummiesIndex.create }
-      specify { expect { DummiesIndex.create! }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/\[\[dummies\] already exists\]/) }
+      specify do
+        skip_on_version_gte('2.0', 'format of exception changed in 2.x')
+        expect { DummiesIndex.create! }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/\[\[dummies\] already exists\]/)
+      end
+      specify do
+        skip_on_version_lt('2.0', 'format of exception was changed')
+        expect { DummiesIndex.create! }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/index_already_exists_exception.*dummies/)
+      end
       specify { expect { DummiesIndex.create!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/Invalid alias name \[dummies\]/) }
     end
 
@@ -64,8 +71,15 @@ describe Chewy::Index::Actions do
       specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
       specify { expect(DummiesIndex.aliases).to eq([]) }
       specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
-      specify { expect { DummiesIndex.create!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/\[\[dummies_2013\] already exists\]/) }
-      specify { expect(DummiesIndex.create!('2014')["acknowledged"]).to eq(true) }
+      specify do
+        skip_on_version_gte('2.0', 'format of exception changed in 2.x')
+        expect { DummiesIndex.create!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/\[\[dummies_2013\] already exists\]/)
+      end
+      specify do
+        skip_on_version_lt('2.0', 'format of exception was changed')
+        expect { DummiesIndex.create!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/index_already_exists_exception.*dummies_2013/)
+      end
+      specify { expect(DummiesIndex.create!('2014')['acknowledged']).to eq(true) }
 
       context do
         before { DummiesIndex.create! '2014' }
@@ -88,7 +102,7 @@ describe Chewy::Index::Actions do
 
     context do
       before { DummiesIndex.create }
-      specify { expect(DummiesIndex.delete["acknowledged"]).to eq(true) }
+      specify { expect(DummiesIndex.delete['acknowledged']).to eq(true) }
 
       context do
         before { DummiesIndex.delete }
@@ -98,7 +112,7 @@ describe Chewy::Index::Actions do
 
     context do
       before { DummiesIndex.create '2013' }
-      specify { expect(DummiesIndex.delete('2013')["acknowledged"]).to eq(true) }
+      specify { expect(DummiesIndex.delete('2013')['acknowledged']).to eq(true) }
 
       context do
         before { DummiesIndex.delete('2013') }
@@ -108,7 +122,7 @@ describe Chewy::Index::Actions do
 
       context do
         before { DummiesIndex.create '2014' }
-        specify { expect(DummiesIndex.delete["acknowledged"]).to eq(true) }
+        specify { expect(DummiesIndex.delete['acknowledged']).to eq(true) }
 
         context do
           before { DummiesIndex.delete }
@@ -133,7 +147,7 @@ describe Chewy::Index::Actions do
 
     context do
       before { DummiesIndex.create }
-      specify { expect(DummiesIndex.delete!["acknowledged"]).to eq(true) }
+      specify { expect(DummiesIndex.delete!['acknowledged']).to eq(true) }
 
       context do
         before { DummiesIndex.delete! }
@@ -143,7 +157,7 @@ describe Chewy::Index::Actions do
 
     context do
       before { DummiesIndex.create '2013' }
-      specify { expect(DummiesIndex.delete!('2013')["acknowledged"]).to eq(true) }
+      specify { expect(DummiesIndex.delete!('2013')['acknowledged']).to eq(true) }
 
       context do
         before { DummiesIndex.delete!('2013') }
@@ -153,7 +167,7 @@ describe Chewy::Index::Actions do
 
       context do
         before { DummiesIndex.create '2014' }
-        specify { expect(DummiesIndex.delete!["acknowledged"]).to eq(true) }
+        specify { expect(DummiesIndex.delete!['acknowledged']).to eq(true) }
 
         context do
           before { DummiesIndex.delete! }
@@ -173,8 +187,8 @@ describe Chewy::Index::Actions do
   end
 
   describe '.purge' do
-    specify { expect(DummiesIndex.purge["acknowledged"]).to eq(true) }
-    specify { expect(DummiesIndex.purge('2013')["acknowledged"]).to eq(true) }
+    specify { expect(DummiesIndex.purge['acknowledged']).to eq(true) }
+    specify { expect(DummiesIndex.purge('2013')['acknowledged']).to eq(true) }
 
     context do
       before { DummiesIndex.purge }
@@ -220,8 +234,8 @@ describe Chewy::Index::Actions do
   end
 
   describe '.purge!' do
-    specify { expect(DummiesIndex.purge!["acknowledged"]).to eq(true) }
-    specify { expect(DummiesIndex.purge!('2013')["acknowledged"]).to eq(true) }
+    specify { expect(DummiesIndex.purge!['acknowledged']).to eq(true) }
+    specify { expect(DummiesIndex.purge!('2013')['acknowledged']).to eq(true) }
 
     context do
       before { DummiesIndex.purge! }