chewy_query 0.0.1

data/lib/chewy_query/builder/nodes/and.rb

@@ -0,0 +1,26 @@
+module ChewyQuery
+  class Builder
+    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/builder/nodes/base.rb

@@ -0,0 +1,17 @@
+module ChewyQuery
+  class Builder
+    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

data/lib/chewy_query/builder/nodes/bool.rb

@@ -0,0 +1,33 @@
+module ChewyQuery
+  class Builder
+    module Nodes
+      class Bool < Expr
+        METHODS = %w(must must_not should)
+
+        def initialize(options = {})
+          @options = options
+          @must, @must_not, @should = [], [], []
+        end
+
+        METHODS.each do |method|
+          define_method method do |*exprs|
+            instance_variable_get("@#{method}").push(*exprs)
+            self
+          end
+        end
+
+        def __render__
+          bool = METHODS.map do |method|
+            value = instance_variable_get("@#{method}")
+            [method.to_sym, value.map(&:__render__)] if value.any?
+          end.compact
+
+          bool = { bool: Hash[bool] }
+
+          bool[:bool][:_cache] = !!@options[:cache] if @options.key?(:cache)
+          bool
+        end
+      end
+    end
+  end
+end

data/lib/chewy_query/builder/nodes/equal.rb

@@ -0,0 +1,34 @@
+module ChewyQuery
+  class Builder
+    module Nodes
+      class Equal < Expr
+        EXECUTION = {
+          :| => :or,
+          :or => :or,
+          :& => :and,
+          :and => :and,
+          :b => :bool,
+          :bool => :bool,
+          :f => :fielddata,
+          :fielddata => :fielddata,
+        }
+
+        def initialize(name, value, *args)
+          @name = name.to_s
+          @value = value
+          @options = args.extract_options!
+          execution = EXECUTION[args.first.to_sym] if args.first
+          @options[:execution] = execution if execution
+        end
+
+        def __render__
+          filter = (@value.is_a?(Array) ? :terms : :term)
+          body = { @name => @value }
+          body.merge!(@options.slice(:execution)) if filter == :terms
+          body.merge!(_cache: !!@options[:cache]) if @options.key?(:cache)
+          { filter => body }
+        end
+      end
+    end
+  end
+end

data/lib/chewy_query/builder/nodes/exists.rb

@@ -0,0 +1,20 @@
+module ChewyQuery
+  class Builder
+    module Nodes
+      class Exists < Expr
+        def initialize(name, options = {})
+          @name = name.to_s
+          @options = options
+        end
+
+        def !
+          Nodes::Missing.new(@name, null_value: true)
+        end
+
+        def __render__
+          { exists: { field: @name } }
+        end
+      end
+    end
+  end
+end

data/lib/chewy_query/builder/nodes/expr.rb

@@ -0,0 +1,28 @@
+module ChewyQuery
+  class Builder
+    module Nodes
+      class Expr < Base
+        def &(other)
+          Nodes::And.new(self, other)
+        end
+
+        def |(other)
+          Nodes::Or.new(self, other)
+        end
+
+        def !
+          Nodes::Not.new(self)
+        end
+
+        def ~
+          @options[:cache] = true
+          self
+        end
+
+        def __render__
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/chewy_query/builder/nodes/field.rb

@@ -0,0 +1,106 @@
+module ChewyQuery
+  class Builder
+    module Nodes
+      class Field < Base
+        def initialize(name, *args)
+          @name = name.to_s
+          @args = args
+        end
+
+        def !
+          Nodes::Missing.new(@name)
+        end
+
+        def ~
+          __options_merge__!(cache: true)
+          self
+        end
+
+        def >(value)
+          Nodes::Range.new(@name, *__options_merge__(gt: value))
+        end
+
+        def <(value)
+          Nodes::Range.new(@name, *__options_merge__(lt: value))
+        end
+
+        def >=(value)
+          Nodes::Range.new(@name, *__options_merge__(gt: value, left_closed: true))
+        end
+
+        def <=(value)
+          Nodes::Range.new(@name, *__options_merge__(lt: value, right_closed: true))
+        end
+
+        def ==(value)
+          case value
+          when nil
+            Nodes::Missing.new(@name, existence: false, null_value: true)
+          when ::Regexp
+            Nodes::Regexp.new(@name, value, *@args)
+          when ::Range
+            Nodes::Range.new(@name, *__options_merge__(gt: value.first, lt: value.last))
+          else
+            if value.is_a?(Array) && value.first.is_a?(::Range)
+              Nodes::Range.new(@name, *__options_merge__(
+                gt: value.first.first, lt: value.first.last,
+                left_closed: true, right_closed: true
+              ))
+            else
+              Nodes::Equal.new(@name, value, *@args)
+            end
+          end
+        end
+
+        def !=(value)
+          case value
+          when nil
+            Nodes::Exists.new(@name)
+          else
+            Nodes::Not.new(self == value)
+          end
+        end
+
+        def =~(value)
+          case value
+          when ::Regexp
+            Nodes::Regexp.new(@name, value, *@args)
+          else
+            Nodes::Prefix.new(@name, value, @args.extract_options!)
+          end
+        end
+
+        def !~(value)
+          Not.new(self =~ value)
+        end
+
+        def method_missing(method, *args, &block)
+          method = method.to_s
+          if method =~ /\?\Z/
+            Nodes::Exists.new([@name, method.gsub(/\?\Z/, '')].join(?.))
+          else
+            self.class.new([@name, method].join(?.), *args)
+          end
+        end
+
+        def to_ary
+          nil
+        end
+
+        private
+
+        def __options_merge__!(additional = {})
+          options = @args.extract_options!
+          options = options.merge(additional)
+          @args.push(options)
+        end
+
+        def __options_merge__(additional = {})
+          options = @args.extract_options!
+          options = options.merge(additional)
+          @args + [options]
+        end
+      end
+    end
+  end
+end

data/lib/chewy_query/builder/nodes/has_child.rb

@@ -0,0 +1,14 @@
+require 'chewy_query/builder/nodes/has_relation'
+
+module ChewyQuery
+  class Builder
+    module Nodes
+      class HasChild < HasRelation
+        private
+        def _relation
+          :has_child
+        end
+      end
+    end
+  end
+end

data/lib/chewy_query/builder/nodes/has_parent.rb

@@ -0,0 +1,14 @@
+require 'chewy_query/builder/nodes/has_relation'
+
+module ChewyQuery
+  class Builder
+    module Nodes
+      class HasParent < HasRelation
+        private
+        def _relation
+          :has_parent
+        end
+      end
+    end
+  end
+end

data/lib/chewy_query/builder/nodes/has_relation.rb

@@ -0,0 +1,61 @@
+require 'chewy_query/builder/compose'
+
+module ChewyQuery
+  class Builder
+    module Nodes
+      class HasRelation < Expr
+        include Compose
+
+        def initialize(type, outer = nil)
+          @type = type.to_s
+          @outer = outer
+          @query_mode = :must
+          @filter_mode = :and
+          @queries = []
+          @filters = []
+        end
+
+        def query_mode(mode)
+          @query_mode = mode
+          self
+        end
+
+        def filter_mode(mode)
+          @filter_mode = mode
+          self
+        end
+
+        def query(params = nil, &block)
+          if block
+            raise 'Query DLS is not supported yet'
+          else
+            @queries.push(params)
+          end
+          self
+        end
+
+        def filter(params = nil, &block)
+          if block
+            @filters.push(ChewyQuery::Builder::Filters.new(@outer, &block).__render__)
+          else
+            @filters.push(params)
+          end
+          self
+        end
+
+        def __render__
+          queries = _queries_join(@queries, @query_mode)
+          filters = _filters_join(@filters, @filter_mode)
+
+          body = if filters && !queries
+            { filter: filters }
+          else
+            _filtered_query(queries, filters)
+          end || {}
+
+          { _relation => body.merge(type: @type) } if body
+        end
+      end
+    end
+  end
+end

data/lib/chewy_query/builder/nodes/match_all.rb

@@ -0,0 +1,11 @@
+module ChewyQuery
+  class Builder
+    module Nodes
+      class MatchAll < Expr
+        def __render__
+          { match_all: {} }
+        end
+      end
+    end
+  end
+end

data/lib/chewy_query/builder/nodes/missing.rb

@@ -0,0 +1,20 @@
+module ChewyQuery
+  class Builder
+    module Nodes
+      class Missing < Expr
+        def initialize(name, options = {})
+          @name = name.to_s
+          @options = options.reverse_merge(existence: true, null_value: false)
+        end
+
+        def !
+          Nodes::Exists.new(@name)
+        end
+
+        def __render__
+          { missing: { field: @name }.merge(@options.slice(:existence, :null_value)) }
+        end
+      end
+    end
+  end
+end

data/lib/chewy_query/builder/nodes/not.rb

@@ -0,0 +1,26 @@
+module ChewyQuery
+  class Builder
+    module Nodes
+      class Not < Expr
+        def initialize(expr, options = {})
+          @expr = expr
+          @options = options
+        end
+
+        def !
+          @expr
+        end
+
+        def __render__
+          expr = @expr.__render__
+
+          if @options.key?(:cache)
+            { not: { filter: expr, _cache: !!@options[:cache] } }
+          else
+            { not: expr }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chewy_query/builder/nodes/or.rb

@@ -0,0 +1,26 @@
+module ChewyQuery
+  class Builder
+    module Nodes
+      class Or < 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)
+            { or: { filters: nodes, _cache: !!@options[:cache] } }
+          else
+            { or: nodes }
+          end
+        end
+      end
+    end
+  end
+end