stretchy 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ef5c2486425a691f1be06b65dd0fde00c1d17da
-  data.tar.gz: 2bdbed13f48c91a300da4e246ac95bbb21515d81
+  metadata.gz: 90bdaff51a1aaeb776e881571be1b4a0c54da5a3
+  data.tar.gz: 47f7feae0e64d75661da159d2930c2995524240a
 SHA512:
-  metadata.gz: 6774e7ae30ac2517dbcb588f8791a6af765f23c5f9923259470634254640a785a8456b5a565cb5af00c077113127dc6a7133f2fd54587c6d7bacb6d168df5e5e
-  data.tar.gz: 441b5aa1b2bfb77f41d42105e9744e0815fd7f95ed2887e5d56f4c6bd133ee1d2220427a46e77bc0e345dd16e9f81d9c9201d8551b1d4d11ffa27d1cfafe9b70
+  metadata.gz: 181d7b11c8b58f9d816a3243d3289f02e7e3511bab007d7ea17a2c931ce121c6bc9391d4e23e3d7eb20a16ade4c0a68acde6dfa4d0c55c9a23aeeecfd7c1134c
+  data.tar.gz: 357a659413a79aaa882bb7f6d7b702425eed047c752be9090a0145e3232228030c1f0c04b8fcbaf155186b7aee5199085c403fefea390b6274d368fa1f962c2e

data/README.md

@@ -178,6 +178,18 @@ The `:scale` param determines how quickly the value falls off. In the example ab
 
 See the [Function Score Query](http://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html) section on Decay Functions for more info.
 
+### Field
+
+```ruby
+query = query.boost.field(:popularity)
+             .boost.field(:timestamp, factor: 0.5, modifier: :sqrt)
+             .boost.field(:votes, :bookmarks, :comments)
+```
+
+Boosts a document by a numeric value contained in the specified fields. You can also specify a `factor` (an amount to multiply the field value by) and a `modifier` (a function for normalizing values).
+
+See the [Boosting By Popularity Guide](https://www.elastic.co/guide/en/elasticsearch/guide/current/boosting-by-popularity.html) and the [Field Value Factor documentation](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html#_field_value_factor) for more info.
+
 ### Random
 
 ```ruby

data/lib/stretchy/boosts/field_value_boost.rb

@@ -0,0 +1,36 @@
+module Stretchy
+  module Boosts
+    class FieldValueBoost < Base
+
+      MODIFIERS = [:none, :log, :log1p, :log2p, :ln, :ln1p, :ln2p, :square, :sqrt, :reciprocal]
+
+      attribute :field
+      attribute :modifier
+      attribute :factor
+
+      validations do
+        rule :field, :field
+        rule :modifier, inclusion: {in: MODIFIERS}
+        rule :factor, type: {classes: Numeric}
+      end
+
+      def initialize(field, options = {})
+        @field    = field
+        @modifier = options[:modifier]
+        @factor   = options[:factor]
+        validate!
+      end
+
+      def to_search
+        json = { field: field }
+        json[:modifier] = modifier if modifier
+        json[:factor] = factor if factor
+        
+        {
+          field_value_factor: json
+        }
+      end
+
+    end
+  end
+end

data/lib/stretchy/boosts.rb

@@ -1,4 +1,5 @@
 require 'stretchy/boosts/base'
 require 'stretchy/boosts/field_decay_boost'
+require 'stretchy/boosts/field_value_boost'
 require 'stretchy/boosts/filter_boost'
 require 'stretchy/boosts/random_boost'

data/lib/stretchy/builders/boost_builder.rb

@@ -2,6 +2,10 @@ module Stretchy
   module Builders
     class BoostBuilder
 
+      extend Forwardable
+
+      delegate [:any?, :count, :length] => :functions
+
       attr_accessor :functions, :overall_boost, :max_boost, :score_mode, :boost_mode
 
       def initialize
@@ -12,8 +16,8 @@ module Stretchy
         @boost_mode     = 'sum'
       end
 
-      def any?
-        @functions.any?
+      def add_boost(boost)
+        @functions << boost
       end
 
       def to_search(query_or_filter)

data/lib/stretchy/builders/where_builder.rb

@@ -38,7 +38,6 @@ module Stretchy
         else
           geo_point = Types::GeoPoint.new(options)
         end
-        
         builder_from_options(options).add_geo(field, distance, geo_point)
       end
 

data/lib/stretchy/clauses/base.rb

@@ -21,32 +21,32 @@ module Stretchy
       delegate [:request, :response, :results, :ids, :hits, :query,
                 :took, :shards, :total, :max_score, :total_pages] => :query_results
       delegate [:to_search] => :base
-      delegate [:range, :geo, :terms] => :where
-      delegate [:fulltext] => :match
+      delegate [:where, :range, :geo, :terms, :not] => :build_where
+      delegate [:match, :fulltext] => :build_match
 
       #
       # Generates a chainable query. The only required option for the
       # first initialization is `:type` , which specifies what type
       # to query on your index.
       # 
-      # @overload initialize(base_or_opts, options)
+      # @overload initialize(base_or_opts, params)
       #   @param base [Base] another clause to copy attributes from
-      #   @param options [Hash] options to set on the new state
+      #   @param params [Hash] params to set on the new state
       # 
       # @overload initialize(base_or_opts)
       #   @option base_or_opts [String] :index        The Elastic index to query
       #   @option base_or_opts [String] :type         The Lucene type to query on
       #   @option base_or_opts [true, false] :inverse Whether we are in a `not` context
-      def initialize(base = nil, options = {})
+      def initialize(base = nil, params = {})
         if base.is_a?(Builders::ShellBuilder)
           @base = base
         elsif base.nil?
           @base = Builders::ShellBuilder.new
+          @base.index ||= params[:index] || Stretchy.index_name
+          @base.type    = params[:type]  if params[:type]
         else
           @base = Builders::ShellBuilder.new(base)
         end
-        @base.index ||= options[:index] || Stretchy.index_name
-        @base.type    = options[:type]  if options[:type]
       end
 
       # 
@@ -101,8 +101,8 @@ module Stretchy
       # @option per_page [Integer] :per_page (DEFAULT_LIMIT) Number of results per page
       # 
       # @return [self] Allows continuing the query chain
-      def page(num, options = {})
-        base.limit  = options[:limit] || options[:per_page] || get_limit
+      def page(num, params = {})
+        base.limit  = params[:limit] || params[:per_page] || get_limit
         base.offset = [(num - 1), 0].max.ceil * get_limit
         self
       end
@@ -160,36 +160,13 @@ module Stretchy
         !!base.explain
       end
 
-      # 
-      # Used for fulltext searching. Works similarly
-      # to {#where} .
-      # 
-      # @param options = {} [Hash] Options to be passed to 
-      #   the MatchClause
-      # 
-      # @return [MatchClause] query state with fulltext matches
-      # 
-      # @see MatchClause#initialize
-      # 
-      # @see http://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-query.html Elastic Docs - Match Query
-      def match(options = {})
-        MatchClause.new(base, options)
-      end
-
-      # 
-      # Used for filtering results. Works similarly to
-      # ActiveRecord's `where` method.
-      # 
-      # @param options = {} [Hash] Options to be passed to
-      #   the {WhereClause}
-      # 
-      # @return [WhereClause] query state with filters
-      # 
-      # @see  WhereClause#initialize
-      def where(options = {})
-        WhereClause.new(base, options)
+      def not(params = {}, options = {})
+        if params.is_a?(String)
+          build_match.not(params, options)
+        else
+          build_where.not(params, options)
+        end
       end
-      alias :filter :where
 
       # 
       # Used for boosting the relevance score of
@@ -210,40 +187,17 @@ module Stretchy
         BoostClause.new(base)
       end
 
-      # 
-      # Inverts the current context - the next method
-      # called, such as {#where} or {#match} will generate
-      # a filter specifying the document **does not**
-      # match the specified filter.
-      # 
-      # @overload not(string)
-      #   @param [String] A string that must not be anywhere
-      #                   in the document
-      # 
-      # @overload not(opts_or_string)
-      #   @param [Hash] Options to be passed to an inverted {WhereClause}
-      # 
-      # @return [Base] A {WhereClause}, or a {MatchClause} if only a string 
-      #   is given (ie, doing a full-text search across the whole document)
-      def not(opts_or_string = {})
-        if opts_or_string.is_a?(Hash)
-          WhereClause.new(base).not(opts_or_string)
-        else
-          MatchClause.new(base).not(opts_or_string)
-        end
-      end
-
       # 
       # Adds filters in the `should` context. Operates just like
       # {#where}, but these filters only serve to add to the 
       # relevance score of the returned documents, rather than
       # being required to match.
       # 
-      # @overload  should(opts_or_string)
+      # @overload  should(params)
       #   @param [String] A string to match via full-text search 
       #     anywhere in the document.
       # 
-      # @overload should(opts_or_string)
+      # @overload should(params)
       #   @param [Hash] Options to generate filters.
       # 
       # @return [WhereClause] current query state with should clauses applied
@@ -251,22 +205,22 @@ module Stretchy
       # @see http://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-bool-query.html Elastic Docs - Bool Query
       # 
       # @see http://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-bool-filter.html Elastic Docs - Bool Filter
-      def should(opts_or_string = {})
-        if opts_or_string.is_a?(Hash)
-          WhereClause.new(base).should(opts_or_string)
+      def should(params = {}, options = {})
+        if params.is_a?(Hash)
+          WhereClause.new(base).should(params, options)
         else
-          MatchClause.new(base).should(opts_or_string)
+          MatchClause.new(base).should(params, options)
         end
       end
 
       # 
       # Allows adding raw aggregation JSON to your
       # query
-      # @param opts = {} [Hash] JSON to aggregate on
+      # @param params = {} [Hash] JSON to aggregate on
       # 
       # @return [self] Allows continuing the query chain
-      def aggregations(opts = {})
-        base.aggregate_builder = base.aggregate_builder.merge(opts)
+      def aggregations(params = {})
+        base.aggregate_builder = base.aggregate_builder.merge(params)
         self
       end
       alias :aggs :aggregations
@@ -294,6 +248,20 @@ module Stretchy
         @query_results ||= Stretchy::Results::Base.new(base)
       end
 
+      protected
+
+        def build_match
+          MatchClause.new(base)
+        end
+
+        def build_where
+          WhereClause.new(base)
+        end
+
+        def hashify_params(params)
+          params.is_a?(String) ? { '_all' => params } : params
+        end
+
     end
   end
 end

data/lib/stretchy/clauses/boost_clause.rb

@@ -22,32 +22,18 @@ module Stretchy
 
       delegate [:geo, :range] => :where
 
-      # 
-      # Switch to the boost state, specifying that
-      # the next where / range / etc will be a boost
-      # instead of a regular filter / range / etc.
-      # 
-      # @param base [Base] a clause to copy query state from
-      # @param options = {} [Hash] Options for the boost clause
-      # @option options [true, false] :inverse (nil) If this boost should also be in the inverse state
-      # 
-      def initialize(base)
-        super(base)
-      end
-
       # 
       # Changes query state to "match" in the context
       # of boosting. Options here work the same way as
       # {MatchClause#initialize}, but the combined query
       # will be applied as a boost function.
       # 
-      # @param options = {} [Hash] options for full text matching
+      # @param params = {} [Hash] params for full text matching
       # 
       # @return [BoostMatchClause] query with boost match state
-      def match(options = {})
-        BoostMatchClause.new(base, options)
+      def match(params = {}, options = {})
+        BoostMatchClause.new(base).boost_match(params, options)
       end
-      alias :fulltext :match
 
       # 
       # Changes query state to "where" in the context
@@ -55,15 +41,51 @@ module Stretchy
       # but applies the generated filters as a boost
       # function. 
       # 
-      # @param options = {} [Hash] Filters to use in this boost.
+      # @param params = {} [Hash] Filters to use in this boost.
       # 
       # @return [BoostWhereClause] Query state with boost filters applied
       # 
-      def where(options = {})
-        BoostWhereClause.new(base, options)
+      def where(params = {}, options = {})
+        BoostWhereClause.new(base).boost_where(params, options)
       end
       alias :filter :where
 
+
+      # 
+      # Adds a boost based on the value in the specified field.
+      # You can pass more than one field as arguments, and
+      # you can also pass the `factor` and `modifier` options
+      # as an options hash.
+      #
+      # **CAUTION:** All documents in the index _must_ have
+      # a numeric value for any fields specified here, or
+      # the query will fail.
+      #
+      # @example Adding two fields with options
+      #   query = query.boost.field(:numeric_field, :other_field, factor: 7, modifier: :log2p)
+      # 
+      # @param *args [Arguments] Fields to add to the document score
+      # @param options = {} [Hash] Options to pass to the field_value_factor boost
+      # 
+      # @return [self] Query state with field boosts applied
+      #
+      # @see https://www.elastic.co/guide/en/elasticsearch/guide/current/boosting-by-popularity.html Elasticsearch guide on boosting by popularity
+      #
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html#_field_value_factor Elasticsearch field value factor reference
+      # 
+      def field(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        args.each do |field|
+          pp 
+          base.boost_builder.add_boost(Boosts::FieldValueBoost.new(field, options))
+        end
+        self
+      end
+
+      def not(*args)
+        raise Errors::InvalidQueryError.new("Cannot call .not directly after boost - use .where.not or .match.not instead")
+      end
+
       # 
       # Adds a {Boosts::FieldDecayBoost}, which boosts
       # a search result based on how close it is to a 
@@ -76,18 +98,18 @@ module Stretchy
       # * `:origin` or `:lat` & `:lng` combo
       # * `:scale`
       # 
-      # @option options [Numeric] :field What field to check with this boost
-      # @option options [Date, Time, Numeric, Types::GeoPoint] :origin Boost score based on how close the field is to this value. Required unless {Types::GeoPoint} is present (:lat, :lng, etc)
-      # @option options [Numeric] :lat Latitude, for a geo point
-      # @option options [Numeric] :latitude Latitude, for a geo point
-      # @option options [Numeric] :lng Longitude, for a geo point
-      # @option options [Numeric] :lon Longitude, for a geo point
-      # @option options [Numeric] :longitude Longitude, for a geo point
-      # @option options [String] :scale When the field is this distance from origin, the boost will be multiplied by `:decay` . Default is 0.5, so when `:origin` is a geo point and `:scale` is '10mi', then this boost will be twice as much for a point at the origin as for one 10 miles away
-      # @option options [String] :offset Anything within this distance of the origin is boosted as if it were at the origin
-      # @option options [Symbol] :type (:gauss) What type of decay to use. One of `:linear`, `:exp`, or `:gauss` 
-      # @option options [Numeric] :decay_amount (0.5) How much the boost falls off when it is `:scale` distance from `:origin`
-      # @option options [Numeric] :weight (1.2) How strongly to weight this boost compared to others
+      # @option params [Numeric] :field What field to check with this boost
+      # @option params [Date, Time, Numeric, Types::GeoPoint] :origin Boost score based on how close the field is to this value. Required unless {Types::GeoPoint} is present (:lat, :lng, etc)
+      # @option params [Numeric] :lat Latitude, for a geo point
+      # @option params [Numeric] :latitude Latitude, for a geo point
+      # @option params [Numeric] :lng Longitude, for a geo point
+      # @option params [Numeric] :lon Longitude, for a geo point
+      # @option params [Numeric] :longitude Longitude, for a geo point
+      # @option params [String] :scale When the field is this distance from origin, the boost will be multiplied by `:decay` . Default is 0.5, so when `:origin` is a geo point and `:scale` is '10mi', then this boost will be twice as much for a point at the origin as for one 10 miles away
+      # @option params [String] :offset Anything within this distance of the origin is boosted as if it were at the origin
+      # @option params [Symbol] :type (:gauss) What type of decay to use. One of `:linear`, `:exp`, or `:gauss` 
+      # @option params [Numeric] :decay_amount (0.5) How much the boost falls off when it is `:scale` distance from `:origin`
+      # @option params [Numeric] :weight (1.2) How strongly to weight this boost compared to others
       # 
       # @example Boost near a geo point
       #   query.boost.near(
@@ -105,7 +127,7 @@ module Stretchy
       #     scale: '3d'
       #   )
       # 
-      # @example Boost near a number (with options)
+      # @example Boost near a number (with params)
       #   query.boost.near(
       #     field: :followers,
       #     origin: 100,
@@ -119,13 +141,13 @@ module Stretchy
       # @return [Base] Query with field decay filter added
       # 
       # @see http://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html Elastic Docs - Function Score Query
-      def near(options = {})
-        if options[:lat] || options[:latitude]  ||
-           options[:lng] || options[:longitude] || options[:lon]
+      def near(params = {}, options = {})
+        if params[:lat] || params[:latitude]  ||
+           params[:lng] || params[:longitude] || params[:lon]
 
-          options[:origin] = Stretchy::Types::GeoPoint.new(options)
+          params[:origin] = Stretchy::Types::GeoPoint.new(params)
         end
-        base.boost_builder.functions << Stretchy::Boosts::FieldDecayBoost.new(options)
+        base.boost_builder.add_boost Stretchy::Boosts::FieldDecayBoost.new(params)
         Base.new(base)
       end
       alias :geo :near
@@ -191,17 +213,6 @@ module Stretchy
         self
       end
 
-      # 
-      # Switches to inverse context - boosts added with {#where} 
-      # and #{match} will be applied to documents which *do not*
-      # match said filters.
-      # 
-      # @return [BoostClause] Boost clause in inverse context
-      def not(options = {})
-        @inverse = true
-        self
-      end
-
     end
   end
 end

data/lib/stretchy/clauses/boost_match_clause.rb

@@ -15,46 +15,36 @@ module Stretchy
 
       delegate [:range, :geo] => :where
 
-      # 
-      # Adds a match query to the boost functions.
-      # 
-      # @overload initialize(base, opts_or_string)
-      #   @param base [Base] Base query to copy data from
-      #   @param opts_or_string [String] String to do a free-text match across the document
-      # 
-      # @overload initialize(base, opts_or_string)
-      #   @param base [Base] Base query to copy data from
-      #   @param options = {} [Hash] Fields and values to match via full-text search
-      # 
-      # @return [BoostMatchClause] Boost clause in match context, with queries applied
-      def initialize(base, opts_or_string = {}, options = {})
-        super(base)
-        if opts_or_string.is_a?(Hash)
-          match_function(opts_or_string.merge(options))
-        else
-          match_function(options.merge('_all' => opts_or_string))
-        end
-      end
-
       # 
       # Switches to inverse context, and applies filters as inverse
       # options (ie, documents that *do not* match the query will
       # be boosted)
       # 
-      # @overload not(opts_or_string)
+      # @overload not(params)
       #   @param [String] String that must not match anywhere in the document
       # 
-      # @overload not(opts_or_string)
-      #   @param opts_or_string [Hash] Fields and values that should not match in the document
+      # @overload not(params)
+      #   @param params [Hash] Fields and values that should not match in the document
       # 
       # @return [BoostMatchClause] Query with inverse matching boost function applied
-      def not(opts_or_string = {})
+      def not(params = {})
         @inverse = true
-        if opts_or_string.is_a?(Hash)
-          match_function(opts_or_string)
-        else
-          match_function('_all' => opts_or_string)
-        end
+        match_function(hashify_params(params))
+        self
+      end
+
+      def boost_match(params = {}, options = {})
+        match_function(hashify_params(params), options)
+        self
+      end
+
+      def fulltext(params = {}, options = {})
+        weight = params.delete(:weight) || options[:weight]
+        options[:min] = 1
+        options[:slop] = MatchClause::FULLTEXT_SLOP
+        clause = MatchClause.new.match(params, options)
+        boost  = clause.to_boost(weight)
+        base.boost_builder.add_boost(boost) if boost
         self
       end
 
@@ -72,7 +62,7 @@ module Stretchy
       # 
       # @return [WhereClause] Query with where clause applied
       def where(*args)
-        WhereClause.new(base, *args)
+        WhereClause.new(base).where(*args)
       end
 
       # 
@@ -89,16 +79,16 @@ module Stretchy
       # 
       # @return [MatchClause] Base context with match queries applied
       def match(*args)
-        MatchClause.new(base, *args)
+        MatchClause.new(base).match(*args)
       end
 
       private
 
-        def match_function(options = {})
-          weight = options.delete(:weight)
-          clause = MatchClause.tmp(options)
+        def match_function(params = {}, options = {})
+          weight = params.delete(:weight) || options[:weight]
+          clause = MatchClause.new.match(params, options)
           boost  = clause.to_boost(weight)
-          base.boost_builder.functions << boost if boost
+          base.boost_builder.add_boost(boost) if boost
         end
 
     end

data/lib/stretchy/clauses/boost_where_clause.rb

@@ -11,18 +11,12 @@ module Stretchy
       # 
     class BoostWhereClause < BoostClause
 
-      # 
-      # Generates a boost that matches a set of filters.
-      # 
-      # @param base [Base] Query to copy data from.
-      # @param options = {} [Hash] Fields and values to filter on.
-      # 
-      # @see {WhereClause#initialize}
-      # 
-      # @return [BoostWhereClause] Query with filter boosts applied
-      def initialize(base, options = {})
-        super(base)
-        where_function(:init, options) if options.any?
+      def boost_where(params = {}, options = {})
+        weight = params.delete(:weight) || options[:weight]
+        options[:inverse] = true if inverse?
+        clause = WhereClause.new.where(params, options)
+        boost  = clause.to_boost(weight)
+        base.boost_builder.add_boost(boost) if boost
         self
       end
 
@@ -40,7 +34,12 @@ module Stretchy
       # 
       # @return [WhereClause] Query with where clause applied
       def where(*args)
-        WhereClause.new(base, *args)
+        WhereClause.new(base).where(*args)
+      end
+
+      def not(params = {}, options = {})
+        @inverse = true
+        boost_where(params, options)
       end
 
       # 
@@ -57,7 +56,7 @@ module Stretchy
       # 
       # @return [MatchClause] Base context with match queries applied
       def match(*args)
-        MatchClause.new(base, *args)
+        MatchClause.new(base).match(*args)
       end
 
       # 
@@ -71,8 +70,14 @@ module Stretchy
       # @see http://www.elastic.co/guide/en/elasticsearch/guide/master/_ranges.html Elastic Guides - Ranges
       # 
       # @return [Base] Query in base context with range boost applied
-      def range(*args)
-        where_function(:range, *args)
+      def range(field, options = {})
+        weight = options[:weight]
+        options[:inverse] = true if inverse?
+        
+        clause = WhereClause.new.range(field, options)
+        boost  = clause.to_boost(weight)
+        base.boost_builder.add_boost(boost) if boost
+        
         Base.new(base)
       end
 
@@ -91,32 +96,15 @@ module Stretchy
       # @see http://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-geo-distance-filter.html Elastic Docs - Geo Distance Filter
       # 
       # @return [Base] Query in base context with geo filter boost applied
-      def geo(*args)
-        where_function(:geo, *args)
+      def geo(field, options = {})
+        weight = options[:weight]
+        options[:inverse] = true if inverse?
+        
+        clause = WhereClause.new.geo(field, options)
+        boost  = clause.to_boost(weight)
+        base.boost_builder.add_boost(boost) if boost
         Base.new(base)
       end
-
-      private
-
-        def add_params(params = {})
-          where_function(:init, params)
-        end
-
-        def where_function(method, *args)
-          options   = args.last.is_a?(Hash) ? args.pop : {}
-          weight    = options.delete(:weight)
-
-          clause    = nil
-          if method == :init
-            clause  = WhereClause.tmp(options.merge(inverse: inverse?))
-          else
-            args.push(options)
-            clause  = WhereClause.tmp(inverse: inverse?).send(method, *args)
-          end
-          boost     = clause.to_boost(weight)
-
-          base.boost_builder.functions << boost if boost
-        end
     end
   end
 end

data/lib/stretchy/clauses/match_clause.rb

@@ -11,56 +11,13 @@ module Stretchy
       # 
     class MatchClause < Base
 
-      # 
-      # Creates a temporary MatchClause outside the main
-      # query scope by using a new {Base}. Primarily
-      # used in {BoostClause} for boosting on full-text
-      # matches.
-      # 
-      # @param options = {} [Hash] Options to pass to the full-text match
-      # 
-      # @return [MatchClause] Temporary clause outside current state
-      def self.tmp(options = {})
-        if options.delete(:inverse)
-          self.new(Builders::ShellBuilder.new).not(options)
-        else
-          self.new(Builders::ShellBuilder.new, options)
-        end
-      end
+      FULLTEXT_SLOP = 50
+      FULLTEXT_MIN  = 1
 
-      # 
-      # Creates a new state with a match query applied.
-      # 
-      # @overload initialize(base, opts_or_string)
-      #   @param [Base] Base clause to copy data from
-      #   @param [String] Performs a full-text query for this string on all fields in the document.
-      # 
-      # @overload initialize(base, opts_or_string)
-      #   @param [Base] Base clause to copy data from
-      #   @param [Hash] A hash of fields and values to perform full-text matches with
-      #   @option opts_or_string [String] :operator ('and') Allows switching from the default 'and' 
-      #      operator to 'or', for all the specified fields
-      # 
-      # @example A basic full-text match
-      #   query.match("anywhere in document")
-      # 
-      # @example A full-text search on specific fields
-      #   query.match(
-      #     my_field: "match in my_field",
-      #     other_field: "match in other_field"
-      #   )
-      # 
-      # @example A full-text search using the 'or' operator
-      #   query.match(
-      #     my_field: 'match any of these',
-      #     other_field: 'other words',
-      #     operator: 'or'
-      #   )
-      # 
-      # @see http://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-query.html Elastic Docs - Match Query
-      def initialize(base, opts_or_str = {})
-        super(base)
-        add_params(opts_or_str)
+      def match(params = {}, options = {})
+        @inverse = false unless should?
+        add_params(hashify_params(params), options)
+        self
       end
 
       # 
@@ -79,12 +36,12 @@ module Stretchy
       # * "the quick dog jumped over"
       # * "the adoreable puppy jumped over" **not returned**
       # 
-      # @overload phrase(opts_or_str)
-      #   @param opts_or_str = {} [String] A phrase that will 
+      # @overload phrase(params)
+      #   @param params = {} [String] A phrase that will 
       #     be matched anywhere in the document
       # 
-      # @overload phrase(opts_or_str)
-      #   @param opts_or_str = {} [Hash] A hash of fields and phrases
+      # @overload phrase(params)
+      #   @param params = {} [Hash] A hash of fields and phrases
       #     that should be matched in those fields
       # 
       # @example Matching multiple words together
@@ -96,9 +53,9 @@ module Stretchy
       # @return [self] Allows continuing the query chain
       # 
       # @see https://www.elastic.co/guide/en/elasticsearch/guide/current/proximity-relevance.html Elasticsearch guide: proximity for relevance
-      def fulltext(opts_or_str = {})
-        add_params(opts_or_str, min: 1)
-        add_params(opts_or_str, should: true, slop: 50)
+      def fulltext(params = {})
+        add_params(params, min: FULLTEXT_MIN)
+        add_params(params, should: true, slop: FULLTEXT_SLOP)
         self
       end
 
@@ -106,9 +63,9 @@ module Stretchy
       # Switches to inverted context. Matches applied here work the same way as
       # {#initialize}, but returned documents must **not** match these filters.
       # 
-      # @overload not(opts_or_str)
+      # @overload not(params)
       #   @param [String] A string that must not be matched anywhere in the document
-      # @overload not(opts_or_str)
+      # @overload not(params)
       #   @param [Hash] A hash of fields and strings that must not be matched in those fields
       # 
       # @return [MatchClause] inverted query state with match filters applied
@@ -121,9 +78,9 @@ module Stretchy
       #     my_field: "not_match_1",
       #     other_field: "not_match_2"
       #   )
-      def not(opts_or_str = {})
+      def not(params = {}, options = {})
         @inverse = true
-        add_params(opts_or_str)
+        add_params(params, options)
         self
       end
 
@@ -134,9 +91,9 @@ module Stretchy
       # 
       # Can be chained with {#not}
       # 
-      # @overload should(opts_or_str)
+      # @overload should(params)
       #   @param [String] A string that should be matched anywhere in the document
-      # @overload should(opts_or_str)
+      # @overload should(params)
       #   @param [Hash] A hash of fields and strings that should be matched in those fields
       # 
       # @return [MatchClause] query state with should filters added
@@ -157,10 +114,10 @@ module Stretchy
       #   )
       # 
       # @see http://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-bool-query.html Elastic Docs - Bool Query
-      def should(opts_or_str = {})
+      def should(params = {}, options = {})
         @should  = true
         @inverse = false
-        add_params(opts_or_str)
+        add_params(params, options)
         self
       end
 
@@ -204,8 +161,8 @@ module Stretchy
         end
 
         def add_param(field, param, options = {})
-          options[:inverse] = true if inverse?
-          options[:should]  = true if should?
+          options[:inverse] = true if inverse? || options[:inverse]
+          options[:should]  = true if should?  || options[:should]
           base.match_builder.add_matches(field, param, options)
         end
 

data/lib/stretchy/clauses/where_clause.rb

@@ -23,30 +23,15 @@ module Stretchy
       # 
     class WhereClause < Base
 
-      # 
-      # Creates a temporary context by initializing a new Base object.
-      # Used primarily in {BoostWhereClause}
-      # 
-      # @param options = {} [Hash] Options to filter on
-      # 
-      # @return [WhereClause] A clause outside the main query context
-      def self.tmp(options = {})
-        if options.delete(:inverse)
-          self.new(Builders::ShellBuilder.new).not(options)
-        else
-          self.new(Builders::ShellBuilder.new, options)
-        end
-      end
-
       # 
       # Options passed to the initializer will be interpreted as filters
       # to be added to the query. This is similar to ActiveRecord's `where`
       # method.
       # 
       # @param base [Base] Used to intialize the new state from the previous clause
-      # @param options = {} [Hash] filters to be applied to the new state
-      # @option  options [true, false] :inverted (nil) Whether the new state is inverted
-      # @option  options [true, false] :should (nil) Whether the new state is should
+      # @param params = {} [Hash] filters to be applied to the new state
+      # @option  params [true, false] :inverted (nil) Whether the new state is inverted
+      # @option  params [true, false] :should (nil) Whether the new state is should
       # 
       # @example Apply ActiveRecord-like filters
       #   query.where(
@@ -62,9 +47,11 @@ module Stretchy
       # 
       # @see http://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-range-filter.html Elastic Docs - Range Filter
       # 
-      def initialize(base = nil, options = {})
-        super(base)
-        add_params(options)
+      def where(params = {}, options = {})
+        @inverse = false
+        @should  = false
+        add_params(params, options)
+        self
       end
 
       # 
@@ -172,8 +159,9 @@ module Stretchy
       #   )
       # 
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-terms-filter.html Elasticsearch Terms Filter
-      def terms(params = {})
-        add_params(params, exact: true)
+      def terms(params = {}, options = {})
+        options[:exact] = true
+        add_params(params, options)
         self
       end
       alias :exact :terms
@@ -185,7 +173,7 @@ module Stretchy
       # 
       # Can be chained with {#should} to produce inverted should queries
       # 
-      # @param options = {} [Hash] Options to filter on
+      # @param params = {} [Hash] params to filter on
       # 
       # @return [WhereClause] inverted query state with not filters applied.
       # 
@@ -199,11 +187,11 @@ module Stretchy
       # 
       # @example Inverted should filters
       #   query.should.not(
-      #     match_field: [:these, "options"]
+      #     match_field: [:these, "params"]
       #   )
-      def not(options = {})
+      def not(params = {}, options = {})
         @inverse = true
-        add_params(options)
+        add_params(params, options)
         self
       end
 
@@ -218,25 +206,25 @@ module Stretchy
       # **CAUTION:** Documents that don't match at least one `should`
       # clause will not be returned.
       # 
-      # @param options = {} [Hash] Options to filter on
+      # @param params = {} [Hash] params to filter on
       # 
       # @return [WhereClause] should query state with should filters applied
       # 
-      # @example Specifying should options
+      # @example Specifying should params
       #   query.should(
       #     field: [99, 27]
       #   )
       # 
-      # @example Inverted should options
+      # @example Inverted should params
       #   query.should.not(
       #     exists_field: nil
       #   ) 
       # 
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/1.4/query-dsl-bool-query.html Elasticsearch Bool Query docs (bool filter just references this)
-      def should(options = {})
+      def should(params = {}, options = {})
         @inverse = false
         @should  = true
-        add_params(options)
+        add_params(params, options)
         self
       end
 

data/lib/stretchy/errors/invalid_query_error.rb

@@ -0,0 +1,6 @@
+module Stretchy
+  module Errors
+    class InvalidQueryError < StandardError
+    end
+  end
+end

data/lib/stretchy/errors.rb

@@ -1 +1,2 @@
-require 'stretchy/errors/validation_error.rb'
+require 'stretchy/errors/validation_error.rb'
+require 'stretchy/errors/invalid_query_error.rb'

data/lib/stretchy/version.rb

@@ -1,3 +1,3 @@
 module Stretchy
-  VERSION = "0.4.2"
+  VERSION = "0.4.3"
 end

data/stretchy.gemspec

@@ -21,8 +21,8 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "elasticsearch",  "~> 1.0"
   spec.add_dependency "excon",          "~> 0.45"
-  spec.add_dependency "valid"
-  spec.add_dependency "virtus"
+  spec.add_dependency "valid",          "~> 0.5"
+  spec.add_dependency "virtus",         "~> 1.0"
 
   spec.add_development_dependency "bundler",        "~> 1.8"
   spec.add_development_dependency "rake",           "~> 10.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stretchy
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - agius
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-06-04 00:00:00.000000000 Z
+date: 2015-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: elasticsearch
@@ -42,30 +42,30 @@ dependencies:
   name: valid
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: virtus
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -184,6 +184,7 @@ files:
 - lib/stretchy/boosts.rb
 - lib/stretchy/boosts/base.rb
 - lib/stretchy/boosts/field_decay_boost.rb
+- lib/stretchy/boosts/field_value_boost.rb
 - lib/stretchy/boosts/filter_boost.rb
 - lib/stretchy/boosts/random_boost.rb
 - lib/stretchy/builders.rb
@@ -201,6 +202,7 @@ files:
 - lib/stretchy/clauses/match_clause.rb
 - lib/stretchy/clauses/where_clause.rb
 - lib/stretchy/errors.rb
+- lib/stretchy/errors/invalid_query_error.rb
 - lib/stretchy/errors/validation_error.rb
 - lib/stretchy/filters.rb
 - lib/stretchy/filters/and_filter.rb