elasticquery 0.1.2 → 0.1.3

data/lib/elasticquery/builder.rb

@@ -1,7 +1,10 @@
 require "elasticquery/filters/term"
-require "elasticquery/filters/search"
 require "elasticquery/filters/not"
+require "elasticquery/filters/terms"
 require "elasticquery/filters/range"
+require "elasticquery/filters/exists"
+
+require "elasticquery/queries/multi_match"
 
 require "active_support/concern"
 require "active_support/core_ext/string/inflections"
@@ -10,23 +13,77 @@ module Elasticquery
   module Builder
     extend ActiveSupport::Concern
 
-    filters = [
-      Filters::Term,
-      Filters::Search,
-      Filters::Not,
-      Filters::Range
-    ]
-
-    included do
-      filters.each do |filter_class|
-        filter_name = filter_class.to_s.split("::").last.underscore
-
-        define_method filter_name do |*args|
-          filter = filter_class.new *args
-          query << filter
-          self
-        end
+    def filters
+      @namespace = "Filters"
+      if block_given?
+        yield
+        @namespace = nil
+      end
+      self
+    end
+
+    def queries
+      @namespace = "Queries"
+      if block_given?
+        yield
+        @namespace = nil
+      end
+      self
+    end
+
+    def execute(method, *args)
+      filter_class = "Elasticquery::#{@namespace}::#{method.camelize}".constantize
+      instance = filter_class.new *args
+      case @namespace
+      when "Filters"
+        query.push_filter instance
+      when "Queries" 
+        query.push_query instance
+      else
+        raise "Please specify block. Queries and Filters are supported"
       end
+      self
+    end
+    private :execute
+
+    def term(*args)
+      execute "term", *args
+    end
+
+    def terms(*args)
+      execute "terms", *args
+    end
+    def where(*args)
+      terms *args
+    end
+
+    def not(*args)
+      execute "not", *args
+    end
+
+    def range(*args)
+      execute "range", *args
+    end
+
+    def multi_match(*args)
+      execute "multi_match", *args
+    end
+    def search(*args) 
+      multi_match *args
+    end
+
+    def exists(*args)
+      execute "exists", *args
+    end
+    def with(*args)
+      exists *args
+    end
+
+    def missing(*args)
+      exists.not *args
+    end
+    def without(*args)
+      missing *args
     end
   end
 end

data/lib/elasticquery/es.rb

@@ -0,0 +1,32 @@
+module Elasticquery
+  EsNotSupported = Class.new(StandardError)
+
+  class BaseChain < Elasticquery::Base
+    def initialize(klass)
+      @klass = klass
+      super
+    end
+
+    delegate :each, :empty?, :size, :slice, :[], :to_ary, to: :results
+
+    def records
+      results.records
+    end
+
+    def results
+      @klass.__elasticsearch__.search(build)
+    end
+  end
+
+  module Es
+    def self.extended(base)
+      unless base.ancestors.include? Elasticsearch::Model
+        raise EsNotSupported.new("Can't extend. It's not Elasticsearch::Model")
+      end
+    end
+
+    def es
+      BaseChain.new(self)
+    end
+  end
+end

data/lib/elasticquery/filters/base.rb

@@ -12,6 +12,10 @@ module Elasticquery
         !valid?
       end
 
+      def to_not_hash
+        {not: {filter: to_hash}}
+      end
+
       def dup_with(*args)
         self.class.new *args
       end

data/lib/elasticquery/filters/exists.rb

@@ -0,0 +1,24 @@
+require_relative "base"
+
+module Elasticquery
+  module Filters
+    class Exists < Base
+
+      def initialize(field = nil)
+        @field = field
+      end
+
+      def valid?
+        @field.present?
+      end
+
+      def to_hash
+        {exists: {field: @field}}
+      end
+
+      def to_not_hash
+        {missing: {field: @field}}
+      end
+    end
+  end
+end

data/lib/elasticquery/filters/not.rb

@@ -5,25 +5,21 @@ module Elasticquery
     class Not < Base
 
       def initialize(*args)
-        @args = args
+        @args = Marshal.load(Marshal.dump(args))
       end
 
       def dup_with(*args)
         raise StandardError, "Cannot use Filters::Not twice"
       end
 
+      def valid?
+        args = @args
+        -> { filters[-2].dup_with(*args).valid? }
+      end
+
       def to_hash
         args = @args
-        -> do
-          filter = filters.last.dup_with *args
-          if filter.valid?
-            subquery = filter.to_hash
-            q = subquery[:query][:filtered][:filter][:and][0]
-            {query: {filtered: {filter: {and: [{not: {filter: q}}]}}}}
-          else
-            {}
-          end
-        end
+        -> { filters[-2].dup_with(*args).to_not_hash }
       end
     end
   end

data/lib/elasticquery/filters/range.rb

@@ -5,8 +5,8 @@ module Elasticquery
     class Range < Base
       OPTIONS = %i(_cache execution)
 
-      def initialize(field=nil, gte: nil, lte: nil, **options)
-        @options = options.extract! *OPTIONS
+      def initialize(field = nil, gte: nil, lte: nil, **options)
+        @options = options.slice *OPTIONS
         @field, @gte, @lte = field, gte, lte
       end
 
@@ -15,11 +15,7 @@ module Elasticquery
       end
 
       def to_hash
-        if valid?
-          {query: {filtered: {filter: {and: [{range: range_with_options}]}}}}
-        else
-          {}
-        end
+        {range: range_with_options}
       end
 
       private

data/lib/elasticquery/filters/term.rb

@@ -5,41 +5,17 @@ module Elasticquery
     class Term < Base
       OPTIONS = %i(_cache)
 
-      # Create term filter for elasticsearch builder
-      #
-      # @param [Hash] condition passed to define
-      #
-      # @see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-filtered-query.html#_filtering_without_a_query
-      def initialize(data={})
-        @options = data.extract! *OPTIONS
-        @condition = data
+      def initialize(data = {})
+        @options = data.slice *OPTIONS
+        @condition = data.except *OPTIONS
       end
 
-      # Is passed condition valid. Passed condition must have
-      # one key and present value
-      # 
-      # @return [Boolean] is condition have at least one key
-      #
-      # @example
-      #   rule = Elasticquery::Rules::Term.new
-      #   rule.valid? #=> false
       def valid?
         @condition.keys.size == 1 && @condition.values[0].present?
       end
 
-      # Hash presentation of query.
-      #
-      # @return [Hash] presentation of filter.
-      #
-      # @example
-      #   valid = Elasticquery::Filters::Term.new {name: "John"}
-      #   valid.to_hash #=> {query: {filtered: {filter: {and: [{term: {name: 'John'}}]}}}
       def to_hash
-        if valid?
-          {query: {filtered: {filter: {and: [{term: @condition.merge(@options)}]}}}}
-        else
-          {}
-        end
+        {term: @condition.merge(@options)}
       end
     end
   end

data/lib/elasticquery/filters/terms.rb

@@ -0,0 +1,23 @@
+require "active_support/core_ext/array/wrap"
+require_relative "base"
+
+module Elasticquery
+  module Filters
+    class Terms < Base
+      OPTIONS = %i(_cache execution)
+
+      def initialize(data = {})
+        @options = data.slice *OPTIONS
+        @conditions = data.except(*OPTIONS).delete_if{ |_, value| value.blank? }
+      end
+
+      def valid?
+        @conditions.keys.any?
+      end
+
+      def to_hash
+        {terms: @conditions.merge(@options)}
+      end
+    end
+  end
+end

data/lib/elasticquery/queries/base.rb

@@ -0,0 +1,16 @@
+require 'active_support/core_ext/object/blank'
+
+module Elasticquery
+  module Queries
+    class Base
+
+      def valid?
+        true
+      end
+
+      def invalid?
+        !valid?
+      end
+    end
+  end
+end

data/lib/elasticquery/queries/multi_match.rb

@@ -0,0 +1,34 @@
+require_relative "base"
+
+module Elasticquery
+  module Queries
+    class MultiMatch < Base
+      OPERATORS = %w(and or)
+      TYPES = %w(best_fields most_fields cross_fields phrase pharse_prefix)
+
+      def initialize(query, fields: "_all", operator: "and", type: "best_fields")
+        @fields = fields
+        @operator = operator
+        @type = type
+        @query = query
+      end
+
+      def valid?
+        OPERATORS.include?(@operator) &&
+          TYPES.include?(@type) &&
+          @query.present? &&
+          ( Array === @fields || @fields == "_all" )
+      end
+      
+      def to_hash
+        {multi_match: subquery}
+      end
+
+      private
+
+      def subquery
+        {fields: @fields, operator: @operator, type: @type, query: @query}
+      end
+    end
+  end
+end

data/lib/elasticquery/query.rb

@@ -1,64 +1,53 @@
-require "deep_merge/rails_compat"
-
 module Elasticquery
   class Query
 
-    attr_reader :filters
+    attr_reader :filters, :queries
 
     DEFAULT = {query: {filtered: {query: {match_all:{}}}}}
 
-    # Create new query from hash.
-    #
-    # @param [Hash] query passed as hash. When it not passed use default es 'match_all' query
-    #
-    # @example
-    #   Elasticsearch::Query.new.to_hash #=> {query: {filtered: {query: {match_all:{}}}}}
     def initialize(query = DEFAULT)
       @query = query
-      @filters = []
+      @filters, @queries = [], []
     end
 
-    # Convery query object ot hash
-    #
-    # @return [Hash] hash presentation of query
     def to_hash
-      return DEFAULT if @query == {}
       @query
     end
 
-    # Merge filter to query. If current query is `matche_all`ed
-    # then clear it and use new value. Populate #filters array
-    # with given classes
-    #
-    # @param [Elasticquery::filter::Base] filter passed
-    #
-    # @see #match_all?
-    def <<(filter)
-      @query = {} if match_all?
-      merge filter
+    def push_filter(filter)
       @filters << filter
+      merge_filter filter
     end
 
-    # Ckeck current object to default elasticsearch param
-    #
-    # @return [Boolean] is passed query undefined
-    def match_all?
-      @query == DEFAULT
+    def push_query(query)
+      @queries << query
+      merge_query query
     end
 
     private
 
-    def merge(filter)
+    def merge_filter(filter)
+      return unless filter_valid?(filter)
+
       hash = filter.to_hash
       subquery = hash.respond_to?(:call) ? instance_exec(&hash) : hash
-      @query.deeper_merge! subquery
+      @query = {query: {filtered: {}}} if @query == DEFAULT
+
+      @query[:query][:filtered][:filter] ||= {and: []}
+      @query[:query][:filtered][:filter][:and] << subquery
     end
 
-    def _filters
-      @query[:query] &&
-        @query[:query][:filtered] &&
-        @query[:query][:filtered][:filter] &&
-        @query[:query][:filtered][:filter][:and]
+    def filter_valid?(filter)
+      validation = filter.valid?
+      validation.respond_to?(:call) ? instance_exec(&validation) : validation
+    end
+
+    def merge_query(query)
+      return unless query.valid?
+      @query = {query: {filtered: {}}} if @query == DEFAULT
+
+      @query[:query][:filtered][:query] ||= {bool: {must: []}}
+      @query[:query][:filtered][:query][:bool][:must] << query.to_hash
     end
   end
 end