chewy 0.8.4 → 7.3.4

data/gemfiles/rails.5.0.0.beta3.activerecord.will_paginate.gemfile

@@ -1,15 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-gem "activerecord", "~> 5.0.0.beta3"
-gem "activesupport", "~> 5.0.0.beta3"
-gem "activejob", "~> 5.0.0.beta3"
-gem "will_paginate", :require => false
-
-group :test do
-  gem "guard"
-  gem "guard-rspec"
-end
-
-gemspec :path => "../"

data/gemfiles/sequel.4.31.gemfile

@@ -1,13 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-gem "sequel", "~> 4.31.0"
-gem "activesupport", "~> 4.2.0"
-
-group :test do
-  gem "guard"
-  gem "guard-rspec"
-end
-
-gemspec :path => "../"

data/lib/chewy/backports/deep_dup.rb

@@ -1,46 +0,0 @@
-require 'chewy/backports/duplicable'
-
-class Object
-  # Returns a deep copy of object if it's duplicable. If it's
-  # not duplicable, returns +self+.
-  #
-  #   object = Object.new
-  #   dup    = object.deep_dup
-  #   dup.instance_variable_set(:@a, 1)
-  #
-  #   object.instance_variable_defined?(:@a) # => false
-  #   dup.instance_variable_defined?(:@a)    # => true
-  def deep_dup
-    duplicable? ? dup : self
-  end
-end
-
-class Array
-  # Returns a deep copy of array.
-  #
-  #   array = [1, [2, 3]]
-  #   dup   = array.deep_dup
-  #   dup[1][2] = 4
-  #
-  #   array[1][2] # => nil
-  #   dup[1][2]   # => 4
-  def deep_dup
-    map { |it| it.deep_dup }
-  end
-end
-
-class Hash
-  # Returns a deep copy of hash.
-  #
-  #   hash = { a: { b: 'b' } }
-  #   dup  = hash.deep_dup
-  #   dup[:a][:c] = 'c'
-  #
-  #   hash[:a][:c] # => nil
-  #   dup[:a][:c]  # => "c"
-  def deep_dup
-    each_with_object(dup) do |(key, value), hash|
-      hash[key.deep_dup] = value.deep_dup
-    end
-  end
-end

data/lib/chewy/backports/duplicable.rb

@@ -1,90 +0,0 @@
-#--
-# Most objects are cloneable, but not all. For example you can't dup +nil+:
-#
-#   nil.dup # => TypeError: can't dup NilClass
-#
-# Classes may signal their instances are not duplicable removing +dup+/+clone+
-# or raising exceptions from them. So, to dup an arbitrary object you normally
-# use an optimistic approach and are ready to catch an exception, say:
-#
-#   arbitrary_object.dup rescue object
-#
-# Rails dups objects in a few critical spots where they are not that arbitrary.
-# That rescue is very expensive (like 40 times slower than a predicate), and it
-# is often triggered.
-#
-# That's why we hardcode the following cases and check duplicable? instead of
-# using that rescue idiom.
-#++
-class Object
-  # Can you safely dup this object?
-  #
-  # False for +nil+, +false+, +true+, symbol, and number objects;
-  # true otherwise.
-  def duplicable?
-    true
-  end
-end
-
-class NilClass
-  # +nil+ is not duplicable:
-  #
-  #   nil.duplicable? # => false
-  #   nil.dup         # => TypeError: can't dup NilClass
-  def duplicable?
-    false
-  end
-end
-
-class FalseClass
-  # +false+ is not duplicable:
-  #
-  #   false.duplicable? # => false
-  #   false.dup         # => TypeError: can't dup FalseClass
-  def duplicable?
-    false
-  end
-end
-
-class TrueClass
-  # +true+ is not duplicable:
-  #
-  #   true.duplicable? # => false
-  #   true.dup         # => TypeError: can't dup TrueClass
-  def duplicable?
-    false
-  end
-end
-
-class Symbol
-  # Symbols are not duplicable:
-  #
-  #   :my_symbol.duplicable? # => false
-  #   :my_symbol.dup         # => TypeError: can't dup Symbol
-  def duplicable?
-    false
-  end
-end
-
-class Numeric
-  # Numbers are not duplicable:
-  #
-  #  3.duplicable? # => false
-  #  3.dup         # => TypeError: can't dup Fixnum
-  def duplicable?
-    false
-  end
-end
-
-require 'bigdecimal'
-class BigDecimal
-  begin
-    BigDecimal.new('4.56').dup
-
-    def duplicable?
-      true
-    end
-  rescue TypeError
-    # can't dup, so use superclass implementation
-  end
-end

data/lib/chewy/query/compose.rb

@@ -1,69 +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].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.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,181 +0,0 @@
-require 'chewy/query/compose'
-
-module Chewy
-  class Query
-    class Criteria
-      include Compose
-      ARRAY_STORAGES = [:queries, :filters, :post_filters, :sort, :fields, :types, :scores]
-      HASH_STORAGES = [:options, :request_options, :facets, :aggregations, :suggest, :script_fields]
-      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).present?
-        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_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
-
-      [: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.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.merge!(script_fields: script_fields) if script_fields?
-
-          body = _boost_query(body)
-
-          { body: body.merge!(request_options) }
-        end
-      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)
-        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_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,227 +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.
-    #
-    #   UsersIndex.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
-      #
-      #   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
-
-      # 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.
-      #
-      #   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:
-      #
-      #   UsersIndex.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.
-      #
-      #   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:
-      #
-      #   UsersIndex.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
-      #
-      #   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