elasticsearch-dsl 0.0.0 → 0.1.0

data/lib/elasticsearch/dsl/search/queries/bool.rb

@@ -0,0 +1,75 @@
+module Elasticsearch
+  module DSL
+    module Search
+      module Queries
+
+        # A compound query which matches documents based on combinations of queries
+        #
+        # @example Defining a bool query with multiple conditions
+        #
+        #     search do
+        #       query do
+        #         bool do
+        #           must do
+        #             term category: 'men'
+        #           end
+        #
+        #           must do
+        #             term size:  'xxl'
+        #           end
+        #
+        #           should do
+        #             term color: 'red'
+        #           end
+        #
+        #           must_not do
+        #             term manufacturer: 'evil'
+        #           end
+        #         end
+        #       end
+        #     end
+        #
+        # See the integration test for a working example.
+        #
+        # @see http://elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-bool-query.html
+        #
+        class Bool
+          include BaseComponent
+
+          def must(*args, &block)
+            @hash[name][:must] ||= []
+            value = Query.new(*args, &block).to_hash
+            @hash[name][:must].push(value).flatten! unless @hash[name][:must].include?(value)
+            self
+          end
+
+          def must_not(*args, &block)
+            @hash[name][:must_not] ||= []
+            value = Query.new(*args, &block).to_hash
+            @hash[name][:must_not].push(value).flatten! unless @hash[name][:must_not].include?(value)
+            self
+          end
+
+          def should(*args, &block)
+            @hash[name][:should] ||= []
+            value = Query.new(*args, &block).to_hash
+            @hash[name][:should].push(value).flatten! unless @hash[name][:should].include?(value)
+            self
+          end
+
+          def to_hash
+            @hash[name].update(@args.to_hash) if @args.respond_to?(:to_hash)
+
+            if @block
+              call
+            else
+              @hash[name] = @args unless @args.nil? || @args.empty?
+            end
+
+            @hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/dsl/search/queries/boosting.rb

@@ -0,0 +1,33 @@
+module Elasticsearch
+  module DSL
+    module Search
+      module Queries
+
+        # A query which will decrease the score of documents matching the `negative` query
+        #
+        # @example
+        #
+        #     search do
+        #       query do
+        #         boosting do
+        #           positive terms: { amenities: ['wifi', 'pets'] }
+        #           negative terms: { amenities: ['pool'] }
+        #           negative_boost 0.5
+        #         end
+        #       end
+        #     end
+        #
+        # @see http://elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-boosting-query.html
+        #
+        class Boosting
+          include BaseComponent
+
+          option_method :positive
+          option_method :negative
+          option_method :negative_boost
+        end
+
+      end
+    end
+  end
+end

data/lib/elasticsearch/dsl/search/queries/common.rb

@@ -0,0 +1,38 @@
+module Elasticsearch
+  module DSL
+    module Search
+      module Queries
+
+        # A query which executes the search for low frequency terms first, and high frequency ("common")
+        # terms second
+        #
+        # @example
+        #
+        #     search do
+        #       query do
+        #         common :body do
+        #           query 'shakespeare to be or not to be'
+        #         end
+        #       end
+        #     end
+        #
+        # This query is frequently used when a stopwords-based approach loses too much recall and/or precision.
+        #
+        # @see http://elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-common-terms-query.html
+        #
+        class Common
+          include BaseComponent
+
+          option_method :query
+          option_method :cutoff_frequency
+          option_method :low_freq_operator
+          option_method :minimum_should_match
+          option_method :boost
+          option_method :analyzer
+          option_method :disable_coord
+        end
+
+      end
+    end
+  end
+end

data/lib/elasticsearch/dsl/search/queries/constant_score.rb

@@ -0,0 +1,66 @@
+module Elasticsearch
+  module DSL
+    module Search
+      module Queries
+
+        # A query which wraps another query or filter and returns a constant score for matching documents
+        #
+        # @example
+        #
+        #     search do
+        #       query do
+        #         constant_score do
+        #           query do
+        #             match content: 'Twitter'
+        #           end
+        #         end
+        #       end
+        #     end
+        #
+        # @see http://elasticsearch.org/guide/en/elasticsearch/guide/current/ignoring-tfidf.html
+        #
+        class ConstantScore
+          include BaseComponent
+
+          option_method :boost
+
+          # DSL method for building the `query` part of the query definition
+          #
+          # @return [self]
+          #
+          def query(*args, &block)
+            @query = block ? @query = Query.new(*args, &block) : args.first
+            self
+          end
+
+          # DSL method for building the `filter` part of the query definition
+          #
+          # @return [self]
+          #
+          def filter(*args, &block)
+            @filter = block ? Filter.new(*args, &block) : args.first
+            self
+          end
+
+          # Converts the query definition to a Hash
+          #
+          # @return [Hash]
+          #
+          def to_hash
+            hash = super
+            if @query
+              _query = @query.respond_to?(:to_hash) ? @query.to_hash : @query
+              hash[self.name].update(query: _query)
+            end
+            if @filter
+              _filter = @filter.respond_to?(:to_hash) ? @filter.to_hash : @filter
+              hash[self.name].update(filter: _filter)
+            end
+            hash
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/elasticsearch/dsl/search/queries/dis_max.rb

@@ -0,0 +1,35 @@
+module Elasticsearch
+  module DSL
+    module Search
+      module Queries
+
+        # A query which will score the documents based on the highest score of any individual specified query,
+        # not by summing the scores (as eg. a `bool` query would)
+        #
+        # @example
+        #
+        #     search do
+        #       query do
+        #         dis_max do
+        #           queries [
+        #            { match: { title:   'albino' } },
+        #            { match: { content: 'elephant' } }
+        #           ]
+        #         end
+        #       end
+        #     end
+        #
+        # @see http://elasticsearch.org/guide/en/elasticsearch/guide/current/_best_fields.html
+        #
+        class DisMax
+          include BaseComponent
+
+          option_method :queries
+          option_method :boost
+          option_method :tie_breaker
+        end
+
+      end
+    end
+  end
+end

data/lib/elasticsearch/dsl/search/queries/filtered.rb

@@ -0,0 +1,77 @@
+module Elasticsearch
+  module DSL
+    module Search
+      module Queries
+
+        # A query which allows to combine a query with a filter
+        #
+        # @note It's possible and common to define just the `filter` part of the search definition,
+        #       for a structured search use case.
+        #
+        # @example Find documents about Twitter published last month
+        #
+        #     search do
+        #       query do
+        #         filtered do
+        #           query do
+        #             multi_match do
+        #               query 'twitter'
+        #               fields [ :title, :abstract, :content ]
+        #             end
+        #           end
+        #           filter do
+        #             range :published_on do
+        #               gte 'now-1M/M'
+        #             end
+        #           end
+        #         end
+        #       end
+        #     end
+        #
+        # @see http://elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-filtered-query.html
+        #
+        class Filtered
+          include BaseComponent
+
+          option_method :strategy
+
+          # DSL method for building the `query` part of the query definition
+          #
+          # @return [self]
+          #
+          def query(*args, &block)
+            @query = block ? @query = Query.new(*args, &block) : args.first
+            self
+          end
+
+          # DSL method for building the `filter` part of the query definition
+          #
+          # @return [self]
+          #
+          def filter(*args, &block)
+            @filter = block ? Filter.new(*args, &block) : args.first
+            self
+          end
+
+          # Converts the query definition to a Hash
+          #
+          # @return [Hash]
+          #
+          def to_hash
+            hash = super
+            if @query
+              _query = @query.respond_to?(:to_hash) ? @query.to_hash : @query
+              hash[self.name].update(query: _query)
+            end
+            if @filter
+              _filter = @filter.respond_to?(:to_hash) ? @filter.to_hash : @filter
+              hash[self.name].update(filter: _filter)
+            end
+            hash
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/elasticsearch/dsl/search/queries/function_score.rb

@@ -0,0 +1,102 @@
+module Elasticsearch
+  module DSL
+    module Search
+      module Queries
+
+        # A query which allows to modify the score of documents matching the query,
+        # either via built-in functions or a custom script
+        #
+        # @example Find documents with specific amenities, boosting documents within a certain
+        #          price range and geogprahical location
+        #
+        #     search do
+        #       query do
+        #         function_score do
+        #           filter do
+        #             terms amenities: ['wifi', 'pets']
+        #           end
+        #           functions << { gauss: { price:    { origin: 100, scale: 200 } } }
+        #           functions << { gauss: { location: { origin: '50.090223,14.399590', scale: '5km' } } }
+        #         end
+        #       end
+        #     end
+        #
+        # @see http://elasticsearch.org/guide/en/elasticsearch/guide/current/function-score-query.html
+        #
+        class FunctionScore
+          include BaseComponent
+
+          option_method :script_score
+          option_method :boost
+          option_method :max_boost
+          option_method :score_mode
+          option_method :boost_mode
+
+          def initialize(*args, &block)
+            super
+            @functions = []
+          end
+
+          # DSL method for building the `query` part of the query definition
+          #
+          # @return [self]
+          #
+          def query(*args, &block)
+            @query = block ? @query = Query.new(*args, &block) : args.first
+            self
+          end
+
+          # DSL method for building the `filter` part of the query definition
+          #
+          # @return [self]
+          #
+          def filter(*args, &block)
+            @filter = block ? Filter.new(*args, &block) : args.first
+            self
+          end
+
+          # DSL method for building the `functions` part of the query definition
+          #
+          # @return [Array]
+          #
+          def functions(value=nil)
+            if value
+              @functions = value
+            else
+              @functions
+            end
+          end
+
+          # Set the `functions` part of the query definition
+          #
+          # @return [Array]
+          #
+          def functions=(value)
+            @functions = value
+          end
+
+          # Converts the query definition to a Hash
+          #
+          # @return [Hash]
+          #
+          def to_hash
+            hash = super
+            if @query
+              _query = @query.respond_to?(:to_hash) ? @query.to_hash : @query
+              hash[self.name].update(query: _query)
+            end
+            if @filter
+              _filter = @filter.respond_to?(:to_hash) ? @filter.to_hash : @filter
+              hash[self.name].update(filter: _filter)
+            end
+            unless @functions.empty?
+              hash[self.name].update(functions: @functions)
+            end
+            hash
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/elasticsearch/dsl/search/queries/fuzzy.rb

@@ -0,0 +1,45 @@
+module Elasticsearch
+  module DSL
+    module Search
+      module Queries
+
+        # A query which uses a Levenshtein distance on string fields and plus-minus margin on numerical
+        # fields to match documents
+        #
+        # @example
+        #
+        #     search do
+        #       query do
+        #         fuzzy :name do
+        #           value 'Eyjafjallajökull'
+        #         end
+        #       end
+        #     end
+        #
+        # @example
+        #
+        #     search do
+        #       query do
+        #         fuzzy :published_on do
+        #           value '2014-01-01'
+        #           fuzziness '7d'
+        #         end
+        #       end
+        #     end
+        #
+        # @see http://elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-fuzzy-query.html
+        #
+        class Fuzzy
+          include BaseComponent
+
+          option_method :value
+          option_method :boost
+          option_method :fuzziness
+          option_method :prefix_length
+          option_method :max_expansions
+        end
+
+      end
+    end
+  end
+end