stretchy 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 28c98af055eaf32fb6c23460780f168e66c894bb
-  data.tar.gz: 54af860b9fca236b64c2d95f3acbd13bde7b5f47
+  metadata.gz: 02cee68659326cb0fcbb36e25b584efd846149cc
+  data.tar.gz: 4af82a79df5998f4bf7beface88f4467425fd86a
 SHA512:
-  metadata.gz: b1a8077918cd57cb1294f9340716d2b20d14ce4ebaf01c96eb6e535011ebe4dafcccc013ae4ce201120f5fabe75498c823b29825a1471bf8cdc11cbe99204b23
-  data.tar.gz: ab509f01cfc5f0a97dd522a3ad1bd9ba34bd1c0bbdc4b863d81b78ec386f8f86fc1d3d947d53c748af5ba71f4e27ed195b80f5000e64da8be8ec8c098381064a
+  metadata.gz: 432060e10838aa8438d545ff402214d9b4048d5848f1dbefde4d0a4fff4be366b51dfe52642d02628b61462679c0a7ee513035acd9dd2cd6c5604cb2ac1b64ec
+  data.tar.gz: 98a4e9114c0b8a99687773994ab45bbc32a07621cb48a7cb41f6e132e0d3dc975211ed091a99a686739efee9010742219ede298b3d0402da75a92e353f718e90

data/lib/stretchy/boosts/base.rb

@@ -4,6 +4,8 @@ module Stretchy
 
       include Stretchy::Utils::Contract
 
+      DEFAULT_WEIGHT = 1.2
+
       def initialize
         raise "Override this in subclass"
       end

data/lib/stretchy/boosts/filter_boost.rb

@@ -2,14 +2,14 @@ module Stretchy
   module Boosts
     class FilterBoost < Base
 
-      DEFAULT_WEIGHT = 1.2
+      attr_reader :filter, :weight
 
       contract filter: {type: Stretchy::Filters::Base},
                weight: {type: Numeric}
 
-      def initialize(filter:, weight: DEFAULT_WEIGHT)
-        @filter = filter
-        @weight = weight
+      def initialize(options = {})
+        @filter = options[:filter]
+        @weight = options[:weight] || DEFAULT_WEIGHT
         validate!
       end
 

data/lib/stretchy/boosts/random_boost.rb

@@ -10,9 +10,9 @@ module Stretchy
       # randomizes order (somewhat) consistently per-user
       # http://www.elastic.co/guide/en/elasticsearch/guide/current/random-scoring.html
 
-      def initialize(seed, weight = DEFAULT_WEIGHT)
+      def initialize(seed, weight = nil)
         @seed   = seed
-        @weight = weight
+        @weight = weight || DEFAULT_WEIGHT
         validate!
       end
 

data/lib/stretchy/builders/boost_builder.rb

@@ -0,0 +1,36 @@
+module Stretchy
+  module Builders
+    class BoostBuilder
+
+      attr_accessor :functions, :overall_boost, :max_boost, :score_mode, :boost_mode
+
+      def initialize
+        @functions      = []
+        @overall_boost  = nil
+        @max_boost      = nil
+        @score_mode     = 'sum'
+        @boost_mode     = 'sum'
+      end
+
+      def any?
+        @functions.any?
+      end
+
+      def build(query_or_filter)
+        options = { 
+          functions:  @functions,
+          score_mode: @score_mode,
+          boost_mode: @boost_mode
+        }
+        
+        options[:overall_boost] = @overall_boost if @overall_boost
+        options[:max_boost]     = @max_boost if @max_boost
+        options[:query]         = query_or_filter if query_or_filter.is_a?(Stretchy::Queries::Base)
+        options[:filter]        = query_or_filter if query_or_filter.is_a?(Stretchy::Filters::Base)
+        
+        Stretchy::Queries::FunctionScoreQuery.new(options)
+      end
+
+    end
+  end
+end

data/lib/stretchy/builders/match_builder.rb

@@ -0,0 +1,44 @@
+module Stretchy
+  module Builders
+    class MatchBuilder
+
+      attr_accessor :matches, :antimatches
+
+      def initialize
+        @matches      = Hash.new { [] }
+        @antimatches  = Hash.new { [] }
+      end
+
+      def any?
+        @matches.any? || @antimatches.any?
+      end
+
+      def build
+        return Stretchy::Queries::MatchAllQuery.new unless any?
+
+        if @matches.count > 1 || @antimatches.any?
+          bool_query
+        else
+          field, strings = @matches.first
+          Stretchy::Queries::MatchQuery.new(field: field, string: strings.join(' '))
+        end
+      end
+
+      def bool_query
+        Stretchy::Queries::BoolQuery.new(
+          must:     to_queries(@matches),
+          must_not: to_queries(@antimatches)
+        )
+      end
+
+      private
+
+        def to_queries(matches)
+          matches.map do |field, strings|
+            Stretchy::Queries::MatchQuery.new(field: field, string: strings.join(' '))
+          end
+        end
+
+    end
+  end
+end

data/lib/stretchy/builders/where_builder.rb

@@ -0,0 +1,126 @@
+module Stretchy
+  module Builders
+    class WhereBuilder
+
+      attr_accessor :terms, :antiterms, :exists, :empties, 
+                    :ranges, :antiranges, :geos, :antigeos
+
+      def initialize(options = {})
+        @terms        = Hash.new { [] }
+        @antiterms    = Hash.new { [] }
+        @ranges       = {}
+        @antiranges   = {}
+        @geos         = {}
+        @antigeos     = {}
+
+        @exists       = []
+        @empties      = []
+      end
+
+      def build
+        if use_bool?
+          bool_filter
+        elsif musts?
+          and_filter
+        elsif must_nots?
+          not_filter
+        else
+          nil
+        end
+      end
+
+      def musts?
+        @terms.any? || @exists.any? || @ranges.any? || @geos.any?
+      end
+
+      def must_nots?
+        @antiterms.any?   || @empties.any?    || 
+        @antiranges.any?  || @antigeos.any?
+      end
+
+      def use_bool?
+        musts? && must_nots?
+      end
+
+      def any?
+        musts? || must_nots?
+      end
+
+      def bool_filter
+        Stretchy::Filters::BoolFilter.new(
+          must: build_filters(
+            terms: @terms,
+            exists: @exists,
+            ranges: @ranges,
+            geos: @geos
+          ),
+          must_not: build_filters(
+            terms: @antiterms,
+            exists: @empties,
+            ranges: @antiranges,
+            geos: @antigeos
+          )
+        )
+      end
+
+      def and_filter
+        filter = nil
+        filters = build_filters(
+          terms:  @terms,
+          exists: @exists,
+          ranges: @ranges,
+          geos:   @geos
+        )
+        if filters.count > 1
+          filter = Stretchy::Filters::AndFilter.new(filters)
+        else
+          filter = filters.first
+        end
+        filter
+      end
+
+      def not_filter
+        filter = build_filters(
+          terms:    @antiterms,
+          exists:   @empties,
+          ranges:   @antiranges,
+          geos:     @antigeos
+        )
+        filter = Stretchy::Filters::AndFilter.new(filter) if filter.count > 1
+        Stretchy::Filters::NotFilter.new(filter)
+      end
+
+      def build_filters(options = {})
+        filters = []
+        terms   = Hash(options[:terms])
+        ranges  = Hash(options[:ranges])
+        geos    = Hash(options[:geos])
+        exists  = Array(options[:exists])
+        
+        filters << Stretchy::Filters::TermsFilter.new(terms) if terms.any?
+        
+        filters += exists.map do |field|
+          Stretchy::Filters::ExistsFilter.new(field)
+        end
+
+        filters += ranges.map do |field, values|
+          Stretchy::Filters::RangeFilter.new(
+            field:  field,
+            min:    values[:min],
+            max:    values[:max]
+          )
+        end
+
+        filters += geos.map do |field, values|
+          Stretchy::Filters::GeoFilter.new(
+            field: field,
+            distance: values[:distance],
+            lat: values[:lat],
+            lng: values[:lng]
+          )
+        end
+        filters
+      end
+    end
+  end
+end

data/lib/stretchy/clauses/base.rb

@@ -0,0 +1,95 @@
+module Stretchy
+  module Clauses
+    class Base
+
+      extend Forwardable
+
+      DEFAULT_LIMIT   = 30
+      DEFAULT_OFFSET  = 0
+
+      attr_accessor :match_builder, :where_builder, :boost_builder, 
+                    :aggregate_builder, :inverse, :type, :index_name
+
+      alias :inverse? :inverse
+
+      delegate [:response, :results, :ids, :hits, :took, :shards, :total, :max_score] => :query_results
+
+      def initialize(base_or_opts = nil, options = {})
+        if base_or_opts && !base_or_opts.is_a?(Hash)
+          base                = base_or_opts
+          @index_name         = base.index_name
+          @type               = base.type
+          @match_builder      = base.match_builder
+          @where_builder      = base.where_builder
+          @boost_builder      = base.boost_builder
+          @aggregate_builder  = base.aggregate_builder
+          @inverse            = options[:inverse] || base.inverse
+          @limit              = base.get_limit
+          @offset             = base.get_offset
+        else
+          options = Hash(base_or_opts).merge(options)
+          @index_name         = options[:index] || Stretchy.index_name
+          @type               = options[:type]
+          @match_builder      = Stretchy::Builders::MatchBuilder.new
+          @where_builder      = Stretchy::Builders::WhereBuilder.new
+          @boost_builder      = Stretchy::Builders::BoostBuilder.new
+          @aggregate_builder  = nil
+          @inverse            = options[:inverse]
+          @limit              = DEFAULT_LIMIT
+          @offset             = DEFAULT_OFFSET
+        end
+      end
+
+      def limit(num)
+        @limit = num
+        self
+      end
+
+      def get_limit
+        @limit
+      end
+
+      def offset(num)
+        @offset = num
+        self
+      end
+
+      def get_offset
+        @offset
+      end
+
+      def match(options = {})
+        MatchClause.new(self, options)
+      end
+
+      def where(options = {})
+        WhereClause.new(self, options)
+      end
+
+      def boost(options = {})
+        BoostClause.new(self, options)
+      end
+
+      def to_search
+        return @to_search if @to_search
+        
+        @to_search = if @where_builder.any?
+          Stretchy::Queries::FilteredQuery.new(
+            query:  @match_builder.build,
+            filter: @where_builder.build
+          )
+        else
+          @match_builder.build
+        end
+
+        @to_search = @boost_builder.build(@to_search) if @boost_builder.any?
+        @to_search = @to_search.to_search
+      end
+
+      def query_results
+        @query_results ||= Stretchy::Results::Base.new(to_search.merge(from: @limit, size: @offset), type: @type)
+      end
+
+    end
+  end
+end

data/lib/stretchy/clauses/boost_clause.rb

@@ -0,0 +1,50 @@
+module Stretchy
+  module Clauses
+    class BoostClause < Base
+
+      def initialize(base, options = {})
+        super(base)
+        @inverse = options.delete(:inverse)
+      end
+
+      def match(options = {})
+        BoostMatchClause.new(self, options)
+      end
+
+      def where(options = {})
+        BoostWhereClause.new(self, options)
+      end
+
+      def random(*args)
+        @boost_builder.functions << Stretchy::Boosts::RandomBoost.new(*args)
+        self
+      end
+
+      def all(num)
+        @boost_builder.overall_boost = num
+        self
+      end
+
+      def max(num)
+        @boost_builder.max_boost = num
+        self
+      end
+
+      def score_mode(mode)
+        @boost_builder.score_mode = mode
+        self
+      end
+
+      def boost_mode(mode)
+        @boost_builder.boost_mode = mode
+        self
+      end
+
+      def not(options = {})
+        inst = self.class.new(self, options.merge(inverse: !inverse?))
+        inst
+      end
+
+    end
+  end
+end

data/lib/stretchy/clauses/boost_match_clause.rb

@@ -0,0 +1,31 @@
+module Stretchy
+  module Clauses
+    class BoostMatchClause < BoostClause
+
+      def initialize(base, opts_or_string = {}, options = {})
+        super(base)
+        if opts_or_string.is_a?(Hash)
+          @inverse = opts_or_string.delete(:inverse) || options.delete(:inverse)
+          match_function(opts_or_string.merge(options))
+        else
+          @inverse = options.delete(:inverse)
+          match_function(options.merge('_all' => opts_or_string))
+        end
+      end
+
+      def not(opts_or_string = {}, options = {})
+        self.class.new(self, opts_or_string, options.merge(inverse: !inverse?))
+      end
+
+      private
+
+        def match_function(options = {})
+          weight = options.delete(:weight)
+          clause = MatchClause.tmp(options)
+          boost  = clause.to_boost(weight)
+          @boost_builder.functions << boost if boost
+        end
+
+    end
+  end
+end

data/lib/stretchy/clauses/boost_where_clause.rb

@@ -0,0 +1,44 @@
+module Stretchy
+  module Clauses
+    class BoostWhereClause < BoostClause
+
+      def initialize(base, options = {})
+        super(base, options)
+        where_function(:init, options)
+        self
+      end
+
+      def range(*args)
+        where_function(:range, *args)
+        self
+      end
+
+      def geo(*args)
+        where_function(:geo, *args)
+        self
+      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)
+
+          @boost_builder.functions << boost if boost
+        end
+    end
+  end
+end

data/lib/stretchy/clauses/match_clause.rb

@@ -0,0 +1,57 @@
+module Stretchy
+  module Clauses
+    class MatchClause < Base
+
+      def self.tmp(options = {})
+        self.new(Base.new, options)
+      end
+
+      def initialize(base, opts_or_str = {}, options = {})
+        super(base)
+        if opts_or_str.is_a?(Hash)
+          @inverse     = opts_or_str.delete(:inverse) || options.delete(:inverse)
+          add_params(options.merge(opts_or_str))
+        else
+          @inverse     = options.delete(:inverse)
+          add_params(options.merge('_all' => opts_or_str))
+        end
+      end
+
+      def not(opts_or_str = {}, options = {})
+        self.class.new(self, opts_or_str, options.merge(inverse: !@inverse))
+      end
+
+      def to_boost(weight = nil)
+        weight ||= Stretchy::Boosts::FilterBoost::DEFAULT_WEIGHT
+        Stretchy::Boosts::FilterBoost.new(
+          filter: Stretchy::Filters::QueryFilter.new(
+            @match_builder.build
+          ),
+          weight: weight
+        )
+      end
+
+      private
+
+        def add_params(params = {})
+          case params
+          when Hash
+            params.each do |field, params|
+              add_param(field, params)
+            end
+          else
+            add_param('_all', params)
+          end
+        end
+
+        def add_param(field, param)
+          if inverse?
+            @match_builder.antimatches[field] += Array(param)
+          else
+            @match_builder.matches[field]     += Array(param)
+          end
+        end
+
+    end
+  end
+end

data/lib/stretchy/clauses/where_clause.rb

@@ -0,0 +1,113 @@
+module Stretchy
+  module Clauses
+    class WhereClause < Base
+
+      def self.tmp(options = {})
+        self.new(Base.new, options)
+      end
+
+      def initialize(base, options = {})
+        super(base)
+        @inverse = options.delete(:inverse)
+        add_params(options)
+      end
+
+      def range(field, options = {})
+        min = max = nil
+        
+        case options
+        when Hash
+          min   = options[:min]
+          max   = options[:max]
+          store = inverse? ? @where_builder.antiranges : @where_builder.ranges
+          store[field] = { min: min, max: max }
+        when Range
+          add_param(field, options)
+        end
+
+        self
+      end
+
+      def geo(field, options = {})
+        add_geo(field, options)
+        self
+      end
+
+      def not(options = {})
+        self.class.new(self, options.merge(inverse: !@inverse))
+      end
+
+      def to_boost(weight = nil)
+        weight ||= Stretchy::Boosts::FilterBoost::DEFAULT_WEIGHT
+        
+        if @match_builder.any? && @where_builder.any?
+          Stretchy::Boosts::FilterBoost.new(
+            filter: Stretchy::Filters::QueryFilter.new(
+              Stretchy::Queries::FilteredQuery.new(
+                query:  @match_builder.build,
+                filter: @where_builder.build
+              )
+            ),
+            weight: weight
+          )
+        
+        elsif @match_builder.any?
+          Stretchy::Boosts::FilterBoost.new(
+            filter: Stretchy::Filters::QueryFilter.new(
+              @match_builder.build
+            ),
+            weight: weight
+          )
+
+        elsif @where_builder.any?
+          Stretchy::Boosts::FilterBoost.new(
+            filter: @where_builder.build,
+            weight: weight
+          )
+        end
+      end
+
+      private
+        
+        def add_params(options = {})
+          options.each do |field, param|
+            # if it is an array, process each param
+            # separately - ensures string & symbols
+            # always go into .match_builder
+            
+            if param.is_a?(Array)
+              param.each{|p| add_param(field, p) }
+            else
+              add_param(field, param)
+            end
+          end
+        end
+
+        def add_geo(field, options = {})
+          store = inverse? ? @where_builder.antigeos : @where_builder.geos
+          store[field] = options
+        end
+
+        def add_param(field, param)
+          case param
+          when nil
+            store = inverse? ? @where_builder.exists : @where_builder.empties
+            store << field
+          when String, Symbol
+            if inverse?
+              @match_builder.antimatches[field] += Array(param)
+            else
+              @match_builder.matches[field] += Array(param)
+            end
+          when Range
+            store = inverse? ? @where_builder.antiranges : @where_builder.ranges
+            store[field] = { min: param.min, max: param.max }
+          else
+            store = inverse? ? @where_builder.antiterms : @where_builder.terms
+            store[field] += Array(param)
+          end
+        end
+
+    end
+  end
+end

data/lib/stretchy/filters/and_filter.rb

@@ -4,8 +4,12 @@ module Stretchy
 
       contract filters: {type: Stretchy::Filters::Base, array: true}
 
-      def initialize(filters)
-        @filters = Array(filters)
+      def initialize(*args)
+        if args.count == 1 && args.first.is_a?(Array)
+          @filters = args.first
+        else
+          @filters = args
+        end
         validate!
       end
 

data/lib/stretchy/filters/bool_filter.rb

@@ -6,18 +6,19 @@ module Stretchy
            must_not: {type: Base, array: true},
              should: {type: Base, array: true}
 
-      def initialize(must:, must_not:, should: nil)
-        @must     = Array(must)
-        @must_not = Array(must_not)
-        @should   = Array(should)
+      def initialize(options = {})
+        @must     = Array(options[:must])
+        @must_not = Array(options[:must_not])
+        @should   = Array(options[:should])
         validate!
+        require_one(must: @must, must_not: @must_not, should: @should)
       end
 
       def to_search
         json = {}
-        json[:must]     = @must.map(&:to_search)      if @must
-        json[:must_not] = @must_not.map(&:to_search)  if @must_not
-        json[:should]   = @should.map(&:to_search)    if @should
+        json[:must]     = @must.map(&:to_search)      if @must.any?
+        json[:must_not] = @must_not.map(&:to_search)  if @must_not.any?
+        json[:should]   = @should.map(&:to_search)    if @should.any?
         { bool: json }
       end
     end