chewy 5.0.0 → 7.0.1

data/lib/chewy/query/compose.rb

@@ -1,68 +0,0 @@
-module Chewy
-  class Query
-    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][: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.present? && 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.present? && 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/criteria.rb

@@ -1,191 +0,0 @@
-require 'chewy/query/compose'
-
-module Chewy
-  class Query
-    class Criteria
-      include Compose
-      ARRAY_STORAGES = %i[queries filters post_filters sort fields types scores].freeze
-      HASH_STORAGES = %i[options search_options request_options facets aggregations suggest script_fields].freeze
-      STORAGES = ARRAY_STORAGES + HASH_STORAGES
-
-      def initialize(options = {})
-        @options = options.merge(
-          query_mode: Chewy.query_mode,
-          filter_mode: Chewy.filter_mode,
-          post_filter_mode: Chewy.post_filter_mode || Chewy.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(modifier)
-        options.merge!(modifier)
-      end
-
-      def update_request_options(modifier)
-        request_options.merge!(modifier)
-      end
-
-      def update_search_options(modifier)
-        search_options.merge!(modifier)
-      end
-
-      def update_facets(modifier)
-        facets.merge!(modifier)
-      end
-
-      def update_scores(modifier)
-        @scores = scores + Array.wrap(modifier).reject(&:blank?)
-      end
-
-      def update_aggregations(modifier)
-        aggregations.merge!(modifier)
-      end
-
-      def update_suggest(modifier)
-        suggest.merge!(modifier)
-      end
-
-      def update_script_fields(modifier)
-        script_fields.merge!(modifier)
-      end
-
-      %i[filters queries post_filters].each do |storage|
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def update_#{storage}(modifier)
-            @#{storage} = #{storage} + Array.wrap(modifier).reject(&:blank?)
-          end
-        RUBY
-      end
-
-      def update_sort(modifier, options = {})
-        @sort = nil if options[:purge]
-        modifier = Array.wrap(modifier).flatten.map do |element|
-          element.is_a?(Hash) ? element.map { |k, v| {k => v} } : element
-        end.flatten
-        @sort = sort + modifier
-      end
-
-      %w[fields types].each do |storage|
-        define_method "update_#{storage}" do |modifier, options = {}|
-          variable = "@#{storage}"
-          instance_variable_set(variable, nil) if options[:purge]
-          modifier = send(storage) | Array.wrap(modifier).flatten.map(&:to_s).reject(&:blank?)
-          instance_variable_set(variable, modifier)
-        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 = _filtered_query(_request_query, _request_filter, options.slice(:strategy))
-
-        if options[:simple]
-          {body: body.presence || {query: {match_all: {}}}}
-        else
-          body[:post_filter] = _request_post_filter if post_filters?
-          body[:facets] = facets if facets?
-          body[:aggregations] = aggregations if aggregations?
-          body[:suggest] = suggest if suggest?
-          body[:sort] = sort if sort?
-          body[:_source] = fields if fields?
-          body[:script_fields] = script_fields if script_fields?
-
-          body = _boost_query(body)
-
-          {body: body.merge!(_request_options)}.merge!(search_options)
-        end
-      end
-
-    protected
-
-      def storages
-        STORAGES.map { |storage| send(storage) }
-      end
-
-      def initialize_clone(origin)
-        STORAGES.each do |storage|
-          value = origin.send(storage)
-          instance_variable_set("@#{storage}", value.deep_dup)
-        end
-      end
-
-      def _boost_query(body)
-        return body unless scores?
-        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
-        Hash[request_options.map do |key, value|
-          [key, value.is_a?(Proc) ? value.call : value]
-        end]
-      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/filters.rb

@@ -1,244 +0,0 @@
-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'
-require 'chewy/query/nodes/has_child'
-require 'chewy/query/nodes/has_parent'
-require 'chewy/query/nodes/match_all'
-
-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.
-    #
-    # @example
-    #   UsersIndex.filter{ (article.title =~ /Honey/) & (age < 42) & !rate }
-    #
-    #
-    class Filters
-      def initialize(outer = nil, &block)
-        @block = block
-        @outer = outer || eval('self', block.binding, __FILE__, __LINE__)
-      end
-
-      # Outer scope call
-      # Block evaluates in the external context
-      #
-      # @example
-      #   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.
-      #
-      # @example
-      #   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
-      #
-      # @example
-      #   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.
-      #
-      # @example
-      #   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
-      #
-      # @example
-      #   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
-      #
-      # @example
-      #   UsersIndex.filter{ q(query_string: {query: 'name: hello'}) }
-      #
-      # Supports block for getting query from the outer scope
-      #
-      # @example
-      #   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
-      #
-      # @example
-      #   UsersIndex.filter{ r(term: {name: 'Name'}) }
-      #   UsersIndex.filter{ r(term: {name: 'Name'}) & (age < 42) }
-      #
-      # Supports block for getting raw filter from the outer scope
-      #
-      # @example
-      #   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.
-      #
-      # @example
-      #   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
-
-      # 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.
-      #
-      # @example
-      #   UsersIndex.filter{ has_child('user').filter(term: {role: 'Admin'}) }
-      #   UsersIndex.filter{ has_child('user').filter{ role == 'Admin' } }
-      #   UsersIndex.filter{ has_child('user').query(match: {name: 'borogoves'}) }
-      #
-      # Filters and queries might be combined and filter_mode and query_mode are configurable:
-      #
-      # @example
-      #   UsersIndex.filter do
-      #     has_child('user')
-      #       .filter{ name: 'Peter' }
-      #       .query(match: {name: 'Peter'})
-      #       .filter{ age > 42 }
-      #       .filter_mode(:or)
-      #   end
-      #
-      def has_child(type) # rubocop:disable Naming/PredicateName
-        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.
-      #
-      # @example
-      #   UsersIndex.filter{ has_parent('user').filter(term: {role: 'Admin'}) }
-      #   UsersIndex.filter{ has_parent('user').filter{ role == 'Admin' } }
-      #   UsersIndex.filter{ has_parent('user').query(match: {name: 'borogoves'}) }
-      #
-      # Filters and queries might be combined and filter_mode and query_mode are configurable:
-      #
-      # @example
-      #   UsersIndex.filter do
-      #     has_parent('user')
-      #       .filter{ name: 'Peter' }
-      #       .query(match: {name: 'Peter'})
-      #       .filter{ age > 42 }
-      #       .filter_mode(:or)
-      #   end
-      #
-      def has_parent(type) # rubocop:disable Naming/PredicateName
-        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
-      #
-      # @example
-      #   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
-      #
-      # @example
-      #   UsersIndex.filter{ article.title =~ 'Hello' }
-      #   UsersIndex.filter{ article.tags? }
-      #
-      def method_missing(method, *args) # rubocop:disable Style/MethodMissing
-        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