chewy_query 0.0.1

data/lib/chewy_query/builder/compose.rb

@@ -0,0 +1,64 @@
+module ChewyQuery
+  class Builder
+    module Compose
+
+      protected
+
+      def _filtered_query(query, filter, options = {})
+        query = { match_all: {} } if !query.present? && filter.present?
+
+        if filter.present?
+          filtered = if query.present?
+            { query: { filtered: { query: query, filter: filter } } }
+          else
+            { query: { filtered: { filter: filter } } }
+          end
+          filtered[:query][:filtered].merge!(strategy: options[:strategy].to_s) if options[:strategy].present?
+          filtered
+        elsif query.present?
+          { query: query }
+        else
+          { }
+        end
+      end
+
+      def _queries_join(queries, logic)
+        queries = queries.compact
+
+        if queries.many? || (queries.any? && logic == :must_not)
+          case logic
+          when :dis_max
+            { dis_max: { queries: queries } }
+          when :must, :should, :must_not
+            { 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? || (filters.any? && logic == :must_not)
+          case logic
+          when :and, :or
+            { logic => filters }
+          when :must, :should, :must_not
+            { bool: { logic => filters } }
+          else
+            { bool: { should: filters, minimum_should_match: logic } }
+          end
+        else
+          filters.first
+        end
+      end
+    end
+  end
+end

data/lib/chewy_query/builder/criteria.rb

@@ -0,0 +1,182 @@
+require 'chewy_query/builder/compose'
+
+module ChewyQuery
+  class Builder
+    class Criteria
+      include Compose
+
+      ARRAY_STORAGES = [:queries, :filters, :post_filters, :sort, :fields, :types, :scores]
+      HASH_STORAGES = [:options, :request_options, :facets, :aggregations, :suggest]
+      STORAGES = ARRAY_STORAGES + HASH_STORAGES
+
+      def initialize(options = {})
+        @options = { query_mode: :must, filter_mode: :and, post_filter_mode: nil }.merge(options)
+        @options[:post_filter_mode] = @options[:filter_mode] unless @options[:post_filter_mode]
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && storages == other.storages
+      end
+
+      { ARRAY_STORAGES => '[]', HASH_STORAGES => '{}' }.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|
+        define_method "#{storage}?" do
+          send(storage).any?
+        end
+      end
+
+      def none?
+        !!options[:none]
+      end
+
+      def update_options(modifer)
+        options.merge!(modifer)
+      end
+
+      def update_request_options(modifer)
+        request_options.merge!(modifer)
+      end
+
+      def update_facets(modifer)
+        facets.merge!(modifer)
+      end
+
+      def update_scores(modifer)
+        @scores = scores + Array.wrap(modifer).reject(&:blank?)
+      end
+
+      def update_aggregations(modifer)
+        aggregations.merge!(modifer)
+      end
+
+      def update_suggest(modifier)
+        suggest.merge!(modifier)
+      end
+
+      [:filters, :queries, :post_filters].each do |storage|
+        class_eval <<-RUBY
+          def update_#{storage}(modifer)
+            @#{storage} = #{storage} + Array.wrap(modifer).reject(&:blank?)
+          end
+        RUBY
+      end
+
+      def update_sort(modifer, options = {})
+        @sort = nil if options[:purge]
+        modifer = Array.wrap(modifer).flatten.map do |element|
+          element.is_a?(Hash) ? element.map{|k, v| { k => v } } : element
+        end.flatten
+        @sort = sort + modifer
+      end
+
+      %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).reject(&: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 = {}
+
+        body.merge!(_filtered_query(_request_query, _request_filter, options.slice(:strategy)))
+        body.merge!(post_filter: _request_post_filter) if post_filters?
+        body.merge!(facets: facets) if facets?
+        body.merge!(aggregations: aggregations) if aggregations?
+        body.merge!(suggest: suggest) if suggest?
+        body.merge!(sort: sort) if sort?
+        body.merge!(_source: fields) if fields?
+
+        body = _boost_query(body)
+
+        { body: body.merge!(request_options) }
+      end
+
+      def delete_all_request_body
+        filtered_query = _filtered_query(_request_query, _request_filter, options.slice(:strategy))
+        { body: filtered_query.presence || { query: { match_all: {} } } }
+      end
+
+      protected
+
+      def storages
+        STORAGES.map{|storage| send(storage) }
+      end
+
+      def initialize_clone(other)
+        STORAGES.each do |storage|
+          value = other.send(storage)
+          instance_variable_set("@#{storage}", value.deep_dup)
+        end
+      end
+
+      def _boost_query(body)
+        scores? or return body
+        query = body.delete(:query)
+        filter = body.delete(:filter)
+
+        if query && filter
+          query = { filtered: { query: query, filter: filter } }
+          filter = nil
+        end
+
+        score = { }
+        score[:functions] = scores
+        score[:boost_mode] = options[:boost_mode] if options[:boost_mode]
+        score[:score_mode] = options[:score_mode] if options[:score_mode]
+        score[:query] = query if query
+        score[:filter] = filter if filter
+        body.tap{|b| b[:query] = { function_score: score } }
+      end
+
+      def _request_options
+        options.slice(:size, :from, :explain, :highlight, :rescore)
+      end
+
+      def _request_query
+        _queries_join(queries, options[:query_mode])
+      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 _request_post_filter
+        _filters_join(post_filters, options[:post_filter_mode])
+      end
+    end
+  end
+end

data/lib/chewy_query/builder/filters.rb

@@ -0,0 +1,227 @@
+require 'chewy_query/builder/nodes/base'
+require 'chewy_query/builder/nodes/expr'
+require 'chewy_query/builder/nodes/field'
+require 'chewy_query/builder/nodes/bool'
+require 'chewy_query/builder/nodes/and'
+require 'chewy_query/builder/nodes/or'
+require 'chewy_query/builder/nodes/not'
+require 'chewy_query/builder/nodes/raw'
+require 'chewy_query/builder/nodes/exists'
+require 'chewy_query/builder/nodes/missing'
+require 'chewy_query/builder/nodes/range'
+require 'chewy_query/builder/nodes/prefix'
+require 'chewy_query/builder/nodes/regexp'
+require 'chewy_query/builder/nodes/equal'
+require 'chewy_query/builder/nodes/query'
+require 'chewy_query/builder/nodes/script'
+require 'chewy_query/builder/nodes/has_child'
+require 'chewy_query/builder/nodes/has_parent'
+require 'chewy_query/builder/nodes/match_all'
+
+module ChewyQuery
+  class Builder
+    # Context provides simplified DSL functionality for filters declaring.
+    # You can use logic operations <tt>&</tt> and <tt>|</tt> to concat
+    # expressions.
+    #
+    #   builder.filter{ (article.title =~ /Honey/) & (age < 42) & !rate }
+    #
+    #
+    class Filters
+      def initialize(outer = nil, &block)
+        @block = block
+        @outer = outer || eval('self', block.binding)
+      end
+
+      # Outer scope call
+      # Block evaluates in the external context
+      #
+      #   def name
+      #     'Friend'
+      #   end
+      #
+      #   builder.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.
+      #
+      #   builder.filter{ f(:name) == 'Name' } == builder.filter{ name == 'Name' } # => true
+      #   builder.filter{ f(:name, execution: :bool) == ['Name1', 'Name2'] } ==
+      #     builder.filter{ name(execution: :bool) == ['Name1', 'Name2'] } # => true
+      #
+      # Supports block for getting field name from the outer scope
+      #
+      #   def field
+      #     :name
+      #   end
+      #
+      #   builder.filter{ f{ field } == 'Name' } == builder.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.
+      #
+      #   builder.filter{ s('doc["num1"].value > 1') }
+      #   builder.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
+      #
+      #   builder.filter{ s{ script } } == builder.filter{ s('doc["num1"].value > 1') } # => true
+      #   builder.filter{ s(param1: 42) { script } } == builder.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
+      #
+      #   builder.filter{ q(query_string: {query: 'name: hello'}) }
+      #
+      # Supports block for getting query from the outer scope
+      #
+      #   def query
+      #     {query_string: {query: 'name: hello'}}
+      #   end
+      #
+      #   builder.filter{ q{ query } } == builder.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
+      #
+      #   builder.filter{ r(term: {name: 'Name'}) }
+      #   builder.filter{ r(term: {name: 'Name'}) & (age < 42) }
+      #
+      # Supports block for getting raw filter from the outer scope
+      #
+      #   def filter
+      #     {term: {name: 'Name'}}
+      #   end
+      #
+      #   builder.filter{ r{ filter } } == builder.filter{ r(term: {name: 'Name'}) } # => true
+      #   builder.filter{ r{ filter } } == builder.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.
+      #
+      #   builder.filter{ must(age < 42, name == 'Name') }
+      #   builder.filter{ should(age < 42, name == 'Name') }
+      #   builder.filter{ must(age < 42).should(name == 'Name1', name == 'Name2') }
+      #   builder.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
+
+      # Initializes has_child filter.
+      # Chainable interface acts the same as main query interface. You can pass plain
+      # filters or plain queries or filter with DSL block.
+      #
+      #   builder.filter{ has_child('user').filter(term: {role: 'Admin'}) }
+      #   builder.filter{ has_child('user').filter{ role == 'Admin' } }
+      #   builder.filter{ has_child('user').query(match: {name: 'borogoves'}) }
+      #
+      # Filters and queries might be combined and filter_mode and query_mode are configurable:
+      #
+      #   builder.filter do
+      #     has_child('user')
+      #       .filter{ name: 'Peter' }
+      #       .query(match: {name: 'Peter'})
+      #       .filter{ age > 42 }
+      #       .filter_mode(:or)
+      #   end
+      #
+      def has_child(type)
+        Nodes::HasChild.new(type, @outer)
+      end
+
+      # Initializes has_parent filter.
+      # Chainable interface acts the same as main query interface. You can pass plain
+      # filters or plain queries or filter with DSL block.
+      #
+      #   builder.filter{ has_parent('user').filter(term: {role: 'Admin'}) }
+      #   builder.filter{ has_parent('user').filter{ role == 'Admin' } }
+      #   builder.filter{ has_parent('user').query(match: {name: 'borogoves'}) }
+      #
+      # Filters and queries might be combined and filter_mode and query_mode are configurable:
+      #
+      #   builder.filter do
+      #     has_parent('user')
+      #       .filter{ name: 'Peter' }
+      #       .query(match: {name: 'Peter'})
+      #       .filter{ age > 42 }
+      #       .filter_mode(:or)
+      #   end
+      #
+      def has_parent(type)
+        Nodes::HasParent.new(type, @outer)
+      end
+
+      # Just simple match_all filter.
+      #
+      def match_all
+        Nodes::MatchAll.new
+      end
+
+      # Creates field or exists node
+      # Additional options for further expression might be passed as hash
+      #
+      #   builder.filter{ name == 'Name' } == builder.filter(term: {name: 'Name'}) # => true
+      #   builder.filter{ name? } == builder.filter(exists: {term: 'name'}) # => true
+      #   builder.filter{ name(execution: :bool) == ['Name1', 'Name2'] } ==
+      #     builder.filter(terms: {name: ['Name1', 'Name2'], execution: :bool}) # => true
+      #
+      # Also field names might be chained to use dot-notation for ES field names
+      #
+      #   builder.filter{ article.title =~ 'Hello' }
+      #   builder.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