chewy 0.0.1 → 0.1.0

data/lib/chewy/query/context.rb

@@ -0,0 +1,174 @@
+require 'chewy/query/nodes/base'
+require 'chewy/query/nodes/expr'
+require 'chewy/query/nodes/field'
+require 'chewy/query/nodes/bool'
+require 'chewy/query/nodes/and'
+require 'chewy/query/nodes/or'
+require 'chewy/query/nodes/not'
+require 'chewy/query/nodes/raw'
+require 'chewy/query/nodes/exists'
+require 'chewy/query/nodes/missing'
+require 'chewy/query/nodes/range'
+require 'chewy/query/nodes/prefix'
+require 'chewy/query/nodes/regexp'
+require 'chewy/query/nodes/equal'
+require 'chewy/query/nodes/query'
+require 'chewy/query/nodes/script'
+
+module Chewy
+  class Query
+    # Context provides simplified DSL functionality for filters declaring.
+    # You can use logic operations <tt>&</tt> and <tt>|</tt> to concat
+    # expressions.
+    #
+    #   UsersIndex.filter{ (article.title =~ /Honey/) & (age < 42) & !rate }
+    #
+    #
+    class Context
+      def initialize &block
+        @block = block
+        @outer = eval('self', block.binding)
+      end
+
+      # Outer scope call
+      # Block evaluates in the external context
+      #
+      #   def name
+      #     'Friend'
+      #   end
+      #
+      #   UsersIndex.filter{ name == o{ name } } # => {filter: {term: {name: 'Friend'}}}
+      #
+      def o &block
+        @outer.instance_exec(&block)
+      end
+
+      # Returns field node
+      # Used if method_missing is not working by some reason.
+      # Additional expression options might be passed as second argument hash.
+      #
+      #   UsersIndex.filter{ f(:name) == 'Name' } == UsersIndex.filter{ name == 'Name' } # => true
+      #   UsersIndex.filter{ f(:name, execution: :bool) == ['Name1', 'Name2'] } ==
+      #     UsersIndex.filter{ name(execution: :bool) == ['Name1', 'Name2'] } # => true
+      #
+      # Supports block for getting field name from the outer scope
+      #
+      #   def field
+      #     :name
+      #   end
+      #
+      #   UsersIndex.filter{ f{ field } == 'Name' } == UsersIndex.filter{ name == 'Name' } # => true
+      #
+      def f name = nil, *args, &block
+        name = block ? o(&block) : name
+        Nodes::Field.new name, *args
+      end
+
+      # Returns script filter
+      # Just script filter. Supports additional params.
+      #
+      #   UsersIndex.filter{ s('doc["num1"].value > 1') }
+      #   UsersIndex.filter{ s('doc["num1"].value > param1', param1: 42) }
+      #
+      # Supports block for getting script from the outer scope
+      #
+      #   def script
+      #     'doc["num1"].value > param1 || 1'
+      #   end
+      #
+      #   UsersIndex.filter{ s{ script } } == UsersIndex.filter{ s('doc["num1"].value > 1') } # => true
+      #   UsersIndex.filter{ s(param1: 42) { script } } == UsersIndex.filter{ s('doc["num1"].value > 1', param1: 42) } # => true
+      #
+      def s *args, &block
+        params = args.extract_options!
+        script = block ? o(&block) : args.first
+        Nodes::Script.new script, params
+      end
+
+      # Returns query filter
+      #
+      #   UsersIndex.filter{ q(query_string: {query: 'name: hello'}) }
+      #
+      # Supports block for getting query from the outer scope
+      #
+      #   def query
+      #     {query_string: {query: 'name: hello'}}
+      #   end
+      #
+      #   UsersIndex.filter{ q{ query } } == UsersIndex.filter{ q(query_string: {query: 'name: hello'}) } # => true
+      #
+      def q query = nil, &block
+        Nodes::Query.new block ? o(&block) : query
+      end
+
+      # Returns raw expression
+      # Same as filter with arguments instead of block, but can participate in expressions
+      #
+      #   UsersIndex.filter{ r(term: {name: 'Name'}) }
+      #   UsersIndex.filter{ r(term: {name: 'Name'}) & (age < 42) }
+      #
+      # Supports block for getting raw filter from the outer scope
+      #
+      #   def filter
+      #     {term: {name: 'Name'}}
+      #   end
+      #
+      #   UsersIndex.filter{ r{ filter } } == UsersIndex.filter{ r(term: {name: 'Name'}) } # => true
+      #   UsersIndex.filter{ r{ filter } } == UsersIndex.filter(term: {name: 'Name'}) # => true
+      #
+      def r raw = nil, &block
+        Nodes::Raw.new block ? o(&block) : raw
+      end
+
+      # Bool filter chainable methods
+      # Used to create bool query. Nodes are passed as arguments.
+      #
+      #  UsersIndex.filter{ must(age < 42, name == 'Name') }
+      #  UsersIndex.filter{ should(age < 42, name == 'Name') }
+      #  UsersIndex.filter{ must(age < 42).should(name == 'Name1', name == 'Name2') }
+      #  UsersIndex.filter{ should_not(age >= 42).must(name == 'Name1') }
+      #
+      %w(must must_not should).each do |method|
+        define_method method do |*exprs|
+          Nodes::Bool.new.send(method, *exprs)
+        end
+      end
+
+      # Creates field or exists node
+      # Additional options for further expression might be passed as hash
+      #
+      #   UsersIndex.filter{ name == 'Name' } == UsersIndex.filter(term: {name: 'Name'}) # => true
+      #   UsersIndex.filter{ name? } == UsersIndex.filter(exists: {term: 'name'}) # => true
+      #   UsersIndex.filter{ name(execution: :bool) == ['Name1', 'Name2'] } ==
+      #     UsersIndex.filter(terms: {name: ['Name1', 'Name2'], execution: :bool}) # => true
+      #
+      # Also field names might be chained to use dot-notation for ES field names
+      #
+      #   UsersIndex.filter{ article.title =~ 'Hello' }
+      #   UsersIndex.filter{ article.tags? }
+      #
+      def method_missing method, *args, &block
+        method = method.to_s
+        if method =~ /\?\Z/
+          Nodes::Exists.new method.gsub(/\?\Z/, '')
+        else
+          f method, *args
+        end
+      end
+
+      # Evaluates context block, returns top node.
+      # For internal usage.
+      #
+      def __result__
+        instance_exec(&@block)
+      end
+
+      # Renders evaluated filters.
+      # For internal usage.
+      #
+      def __render__
+        __result__.__render__ # haha, wtf?
+      end
+    end
+  end
+end

data/lib/chewy/query/criteria.rb

@@ -1,53 +1,44 @@
 module Chewy
   class Query
     class Criteria
-      STORAGES = [:search, :query, :facets, :filters, :sort, :fields]
+      STORAGES = [:options, :queries, :facets, :filters, :sort, :fields, :types]
 
-      def ==(other)
-        storages == other.storages
+      def initialize options = {}
+        @options = options.merge(query_mode: Chewy.query_mode, filter_mode: Chewy.filter_mode)
       end
 
-      def storages
-        STORAGES.map { |storage| send(storage) }
+      def == other
+        other.is_a?(self.class) && storages == other.storages
       end
 
-      [:search, :query, :facets].each do |storage|
-        class_eval <<-METHODS, __FILE__, __LINE__ + 1
-          def #{storage}
-            @#{storage} ||= {}
-          end
-        METHODS
-      end
-
-      [:filters, :sort, :fields].each do |storage|
-        class_eval <<-METHODS, __FILE__, __LINE__ + 1
-          def #{storage}
-            @#{storage} ||= []
-          end
-        METHODS
+      { (STORAGES - [:options, :facets]) => '[]', [:options, :facets] => '{}' }.each do |storages, default|
+        storages.each do |storage|
+          class_eval <<-METHODS, __FILE__, __LINE__ + 1
+            def #{storage}
+              @#{storage} ||= #{default}
+            end
+          METHODS
+        end
       end
 
       STORAGES.each do |storage|
-        class_eval <<-METHODS, __FILE__, __LINE__ + 1
-          def #{storage}?
-            #{storage}.any?
-          end
-        METHODS
-      end
-
-      def update_search(modifer)
-        search.merge!(modifer)
+        define_method "#{storage}?" do
+          send(storage).any?
+        end
       end
 
-      def update_query(modifer)
-        query.merge!(modifer)
+      def update_options(modifer)
+        options.merge!(modifer)
       end
 
-
       def update_facets(modifer)
         facets.merge!(modifer)
       end
 
+      def update_queries(modifer)
+        @queries = queries + Array.wrap(modifer).delete_if(&:blank?)
+      end
+
       def update_filters(modifer)
         @filters = filters + Array.wrap(modifer).delete_if(&:blank?)
       end
@@ -60,13 +51,42 @@ module Chewy
         @sort = sort + modifer
       end
 
-      def update_fields(modifer, options = {})
-        @fields = nil if options[:purge]
-        @fields = (fields + Array.wrap(modifer).flatten.map(&:to_s).delete_if(&:blank?)).uniq
+      %w(fields types).each do |storage|
+        define_method "update_#{storage}" do |modifer, options = {}|
+          variable = "@#{storage}"
+          instance_variable_set(variable, nil) if options[:purge]
+          modifer = send(storage) | Array.wrap(modifer).flatten.map(&:to_s).delete_if(&:blank?)
+          instance_variable_set(variable, modifer)
+        end
+      end
+
+      def merge! other
+        STORAGES.each do |storage|
+          send("update_#{storage}", other.send(storage))
+        end
+        self
+      end
+
+      def merge other
+        clone.merge!(other)
+      end
+
+      def request_body
+        body = (_request_query || {}).tap do |body|
+          body.merge!(facets: facets) if facets?
+          body.merge!(sort: sort) if sort?
+          body.merge!(fields: fields) if fields?
+        end
+
+        {body: body.merge!(_request_options)}
       end
 
     protected
 
+      def storages
+        STORAGES.map { |storage| send(storage) }
+      end
+
       def initialize_clone(other)
         STORAGES.each do |storage|
           value = other.send(storage)
@@ -76,6 +96,79 @@ module Chewy
           end
         end
       end
+
+      def _request_options
+        options.slice(:size, :from, :explain)
+      end
+
+      def _request_query
+        request_filter = _request_filter
+        request_query = _queries_join(queries, options[:query_mode])
+
+        if request_filter
+          {query: {
+            filtered: {
+              query: request_query ? request_query : {match_all: {}},
+              filter: request_filter
+            }
+          }}
+        elsif request_query
+          {query: request_query}
+        end
+      end
+
+      def _request_filter
+        filter_mode = options[:filter_mode]
+        request_filter = if filter_mode == :and
+          filters
+        else
+          [_filters_join(filters, filter_mode)]
+        end
+
+        _filters_join([_request_types, *request_filter], :and)
+      end
+
+      def _request_types
+        _filters_join(types.map { |type| {type: {value: type}} }, :or)
+      end
+
+      def _queries_join queries, logic
+        queries = queries.compact
+
+        if queries.many?
+          case logic
+          when :dis_max
+            {dis_max: {queries: queries}}
+          when :must, :should
+            {bool: {logic => queries}}
+          else
+            if logic.is_a?(Float)
+              {dis_max: {queries: queries, tie_breaker: logic}}
+            else
+              {bool: {should: queries, minimum_should_match: logic}}
+            end
+          end
+        else
+          queries.first
+        end
+      end
+
+      def _filters_join filters, logic
+        filters = filters.compact
+
+        if filters.many?
+          case logic
+          when :and, :or
+            {logic => filters}
+          when :must, :should
+            {bool: {logic => filters}}
+          else
+            {bool: {should: filters, minimum_should_match: logic}}
+          end
+        else
+          filters.first
+        end
+      end
     end
   end
 end

data/lib/chewy/query/loading.rb

@@ -4,23 +4,23 @@ module Chewy
       extend ActiveSupport::Concern
 
       def load(options = {})
-        ::Kaminari.paginate_array(_load_objects(options),
-          limit: limit_value, offset: offset_value, total_count: total_count)
+        if defined?(::Kaminari)
+          ::Kaminari.paginate_array(_load_objects(options),
+            limit: limit_value, offset: offset_value, total_count: total_count)
+        else
+          _load_objects(options)
+        end
       end
 
     private
 
       def _load_objects(options)
         loaded_objects = Hash[_results.group_by(&:class).map do |type, objects|
-          model = type.adapter.model
-          scope = model.where(id: objects.map(&:id))
-          additional_scope = options[:scopes][type.type_name.to_sym] if options[:scopes]
-          scope = scope.instance_eval(&additional_scope) if additional_scope
-
-          [type, scope.index_by(&:id)]
+          loaded = type.adapter.load(objects, options[type.type_name.to_sym] || {})
+          [type, loaded.index_by.with_index { |loaded, i| objects[i] }]
         end]
 
-        _results.map { |result| loaded_objects[result.class][result.id.to_i] }.compact
+        _results.map { |result| loaded_objects[result.class][result] }
       end
     end
   end

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

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

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

@@ -0,0 +1,17 @@
+module Chewy
+  class Query
+    module Nodes
+      class Base
+        def render
+          raise NotImplementedError
+        end
+
+        def eql? other
+          other.is_a?(self.class) && instance_variables.all? do |ivar|
+            instance_variable_get(ivar).eql? other.instance_variable_get(ivar)
+          end
+        end
+      end
+    end
+  end
+end