elasticated 2.4.0 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c21bce40f279a26bfc18215caed1f0e2869584d
-  data.tar.gz: b6b33eabf8cb3ea40a848b4ba012201c630c6b2b
+  metadata.gz: 6637480a40d6c018f1edc45efa103df9c836f81f
+  data.tar.gz: a65c27a00654dd7616e9f8086441f4365f616d24
 SHA512:
-  metadata.gz: 1f6b73bf87e1c6da918a9dcbe88ddec3f7cc2a0fa1dbe49133c3170908f58ecf095a197082846506b5dc8e23ef3be5cfd5be7f4a86bbf48f9196f98d6f3d2fd6
-  data.tar.gz: 51fdff057ce01cce2113d448c7426ec89fb0304e76b7fe646f28071730118b17b5805e1779b0843f153200bcf24d9e0a54e0fc68973a3c8aeba548a2580e765e
+  metadata.gz: 1cda536b17d2dddb5d62be83cb2f2ae15555569df1fe7086574f1605c379897f12f9952e0047be486d4fc5b59f35f891544d7d466975b87ab4068a57b1b4b553
+  data.tar.gz: 904e56da96d375422ac0951ffababf82f262e7afb68dd6a2cde125f1f9b2954bcc6d4eabb41bf4b3448132e352fcd451c462db4975cb597a5d9050acb07f396b

data/lib/elasticated.rb

@@ -30,6 +30,10 @@ require_relative 'elasticated/conditions/custom_condition'
 require_relative 'elasticated/delimiters/standard_field_delimiter'
 require_relative 'elasticated/delimiters/term_field_delimiter'
 require_relative 'elasticated/delimiters/date_field_delimiter'
+require_relative 'elasticated/term_delimiter_factory'
+require_relative 'elasticated/date_delimiter_factory'
+require_relative 'elasticated/delimiter_visitor'
+require_relative 'elasticated/strategy_params_for_query_service'
 
 # query components
 
@@ -112,4 +116,20 @@ module Elasticated
     block.call Configuration
   end
 
+  def self.date_delimiter_factory
+    @date_delimiter_factory ||= DateDelimiterFactory.new
+  end
+
+  def self.term_delimiter_factory
+    @term_delimiter_factory ||= TermDelimiterFactory.new
+  end
+
+  def self.delimiter_visitor
+    @delimiter_visitor ||= DelimiterVisitor.new
+  end
+
+  def self.strategy_params_for_query_service
+    @strategy_params_for_query_service ||= StrategyParamsForQueryService.new
+  end
+
 end

data/lib/elasticated/aggregation.rb

@@ -32,5 +32,9 @@ module Elasticated
       end
     end
 
+    def accept_visitor(visitor)
+      visitor.visit_aggregation(self)
+    end
+
   end
 end

data/lib/elasticated/aggregations/filter_aggregation.rb

@@ -36,5 +36,9 @@ module Elasticated
       end
     end
 
+    def accept_visitor(visitor)
+      visitor.visit_filter_aggregation(self)
+    end
+
   end
 end

data/lib/elasticated/boolean_clause.rb

@@ -11,10 +11,18 @@ module Elasticated
 
     # delimiters
 
+    def accept_visitor(visitor)
+      visitor.visit_boolean_clause(self)
+    end
+
     def fill_delimiter(field_delimiter)
       conditions.each{ |condition| condition.fill_delimiter field_delimiter }
     end
 
+    def delimiters
+      conditions.map(&:delimiter)
+    end
+
     # conditions
 
     def add(condition)

data/lib/elasticated/conditions/custom_condition.rb

@@ -14,8 +14,8 @@ module Elasticated
         body
       end
 
-      def fill_delimiter(field_delimiter)
-        # nothing to do
+      def accept_visitor(visitor)
+        visitor.visit_condition(self)
       end
 
     end

data/lib/elasticated/conditions/range_condition.rb

@@ -15,11 +15,8 @@ module Elasticated
         { range: { field => body }.merge(opts) }
       end
 
-      def fill_delimiter(field_delimiter)
-        minimum_value = body[:gt] || body[:gte]
-        field_delimiter.set_minimum field, minimum_value
-        maximum_value = body[:lt] || body[:lte]
-        field_delimiter.set_maximum field, maximum_value
+      def accept_visitor(visitor)
+        visitor.visit_range(self)
       end
 
     end

data/lib/elasticated/conditions/script_condition.rb

@@ -17,8 +17,8 @@ module Elasticated
         { script: body }
       end
 
-      def fill_delimiter(field_delimiter)
-        # nothing to do
+      def accept_visitor(visitor)
+        visitor.visit_condition(self)
       end
 
     end

data/lib/elasticated/conditions/standard_condition.rb

@@ -13,8 +13,8 @@ module Elasticated
         self.opts = opts
       end
 
-      def fill_delimiter(field_delimiter)
-        # nothing to do, by default
+      def accept_visitor(visitor)
+        visitor.visit_condition(self)
       end
 
     end

data/lib/elasticated/conditions/terms_condition.rb

@@ -13,8 +13,8 @@ module Elasticated
         { terms: { field => values }.merge(opts) }
       end
 
-      def fill_delimiter(field_delimiter)
-        values.each{ |value| field_delimiter.add_term field, value }
+      def accept_visitor(visitor)
+        visitor.visit_terms(self)
       end
 
     end

data/lib/elasticated/date_delimiter_factory.rb

@@ -0,0 +1,123 @@
+module Elasticated
+  class DateDelimiterFactory
+
+    def create(empty_delimiter, query_delimiters, opts={})
+      klass = Delimiters::DateFieldDelimiter
+      field = empty_delimiter.field_name
+      filter_name = empty_delimiter.filter_name
+      field_since = "#{field}_since".to_sym
+      field_until = "#{field}_until".to_sym
+      filter_since = "#{filter_name}_since".to_sym
+      filter_until = "#{filter_name}_until".to_sym
+      field_term = field.to_sym
+      delimit_by = opts.fetch(:delimit_by, [:conditions])
+
+      case delimit_by
+      when []
+        _since = nil
+        _until = nil
+      when [:conditions]
+        if has_terms?(query_delimiters, :conditions, field_term)
+          _since = since_condition_delimiters(query_delimiters.fetch(:conditions, []), field_term)
+          _until = until_condition_delimiters(query_delimiters.fetch(:conditions, []), field_term)
+        else
+          _since = since_condition_delimiters(query_delimiters.fetch(:conditions, []), field_since)
+          _until = until_condition_delimiters(query_delimiters.fetch(:conditions, []), field_until)
+        end
+      when [:aggregations]
+        if has_terms?(query_delimiters, :aggregations, field_term)
+          _since = since_aggregation_delimiters(query_delimiters.fetch(:aggregations, []), field_term)
+          _until = until_aggregation_delimiters(query_delimiters.fetch(:aggregations, []), field_term)
+        else
+          _since = since_aggregation_delimiters(query_delimiters.fetch(:aggregations, []), field_since)
+          _until = until_aggregation_delimiters(query_delimiters.fetch(:aggregations, []), field_until)
+        end
+      when [:conditions, :aggregations]
+        if has_terms?(query_delimiters, :conditions, field_term)
+          _since = since_condition_delimiters(query_delimiters.fetch(:conditions, []), field_term)
+          _until = until_condition_delimiters(query_delimiters.fetch(:conditions, []), field_term)
+          _since = since_aggregation_delimiters(query_delimiters.fetch(:aggregations, []), field_term) if _since.empty?
+          _until = until_aggregation_delimiters(query_delimiters.fetch(:aggregations, []), field_term) if _until.empty?
+        else
+          condition_since = since_condition_delimiters(query_delimiters.fetch(:conditions, []), field_since)
+          condition_until = until_condition_delimiters(query_delimiters.fetch(:conditions, []), field_until)
+          aggregation_since = since_aggregation_delimiters(query_delimiters.fetch(:aggregations, []), field_since)
+          aggregation_until = until_aggregation_delimiters(query_delimiters.fetch(:aggregations, []), field_until)
+          _since = condition_since || aggregation_since
+          _until = condition_until || aggregation_until
+        end
+      end
+
+      filtered_empty_delimiter = {
+        filter_since => _since,
+        filter_until => _until
+      }.select { |_, v| not v.nil? }
+
+      klass.new(filtered_empty_delimiter.merge(field: field, as: filter_name))
+    end
+
+    private
+
+    def since_aggregation_delimiters(all_aggregation_delimiters, field_since)
+      return nil if missing_field?(all_aggregation_delimiters, field_since)
+      return min_since_delimiter(all_aggregation_delimiters, field_since) if all_aggregation_delimiters.any? { |delimiter| delimiter[field_since].is_a? Array }
+      since_delimiters = all_aggregation_delimiters.min_by { |delimiter| delimiter[field_since] }
+      since_delimiters.nil? ? nil : since_delimiters[field_since]
+    end
+
+    def since_condition_delimiters(all_condition_delimiters, field_since)
+      condition_delimiterts_with_field = all_condition_delimiters.select { |delimiter| delimiter[field_since] }
+      return min_since_delimiter(condition_delimiterts_with_field, field_since) if condition_delimiterts_with_field.any? { |delimiter| delimiter[field_since].is_a? Array }
+      since_delimiters = condition_delimiterts_with_field.min_by { |delimiter| delimiter[field_since] }
+      since_delimiters.nil? ? nil : since_delimiters[field_since]
+    end
+
+    def min_since_delimiter(delimiters, field)
+      array_delimiters = delimiters.select { |delimiter| delimiter[field].is_a? Array }
+      min_array_delimiter = array_delimiters.min_by { |delimiter| delimiter[field].min }
+      individual_delimiters = delimiters.select { |delimiter| not delimiter[field].is_a? Array }
+      min_individual_delimiter = individual_delimiters.min_by { |delimiter| delimiter[field] }
+      if not (min_array_delimiter.nil? or min_individual_delimiter.nil?)
+        min_array_delimiter > min_individual_delimiter ? min_individual_delimiter : min_array_delimiter
+      else
+        return min_array_delimiter[field].min if min_array_delimiter and min_array_delimiter[field].min
+        min_individual_delimiter
+      end
+    end
+
+    def until_aggregation_delimiters(all_aggregation_delimiters, field_until)
+      return nil if missing_field?(all_aggregation_delimiters, field_until)
+      return max_until_delimiter(all_aggregation_delimiters, field_until) if all_aggregation_delimiters.any? { |delimiter| delimiter[field_until].is_a? Array }
+      until_delimiters = all_aggregation_delimiters.max_by { |delimiter| delimiter[field_until] }
+      until_delimiters.nil? ? nil : until_delimiters[field_until]
+    end
+
+    def until_condition_delimiters(all_condition_delimiters, field_until)
+      condition_delimiterts_with_field = all_condition_delimiters.select { |delimiter| delimiter[field_until] }
+      return max_until_delimiter(condition_delimiterts_with_field, field_until) if condition_delimiterts_with_field.any? { |delimiter| delimiter[field_until].is_a? Array }
+      until_delimiters = condition_delimiterts_with_field.max_by { |delimiter| delimiter[field_until] }
+      until_delimiters.nil? ? nil : until_delimiters[field_until]
+    end
+
+    def max_until_delimiter(delimiters, field)
+      array_delimiters = delimiters.select { |delimiter| delimiter[field].is_a? Array }
+      max_array_delimiter = array_delimiters.max_by { |delimiter| delimiter[field].max }
+      individual_delimiters = delimiters.select { |delimiter| not delimiter[field].is_a? Array }
+      max_individual_delimiter = individual_delimiters.max_by { |delimiter| delimiter[field] }
+      if not (max_array_delimiter.nil? or max_individual_delimiter.nil?)
+        max_array_delimiter > max_individual_delimiter ? max_individual_delimiter : max_array_delimiter
+      else
+        return max_array_delimiter[field].max if max_array_delimiter and max_array_delimiter[field].max
+        max_individual_delimiter
+      end
+    end
+
+    def missing_field?(delimiters, field)
+      delimiters.any? { |delimiter| not delimiter.has_key?(field) }
+    end
+
+    def has_terms?(delimiters, condition_or_agg, field)
+      delimiters.fetch(condition_or_agg, []).any? { |delimiter| delimiter[field] }
+    end
+  end
+end

data/lib/elasticated/delimiter_visitor.rb

@@ -0,0 +1,51 @@
+module Elasticated
+  class DelimiterVisitor
+
+    def visit_query(query)
+      {
+        conditions: query._conditions.accept_visitor(self) + query._filter_conditions.accept_visitor(self),
+        aggregations: query._aggregations.accept_visitor(self)
+      }
+    end
+
+    def visit_query_conditions(query_conditions)
+      query_conditions._must.accept_visitor(self)
+    end
+
+    def visit_boolean_clause(boolean_clause)
+      boolean_clause.conditions.map { |c| c.accept_visitor(self) }
+    end
+
+    def visit_condition(condition)
+      {}
+    end
+
+    def visit_terms(terms_condition)
+      { terms_condition.field => terms_condition.values }
+    end
+
+    def visit_range(range_condition)
+      field = range_condition.field
+      minimum_value = range_condition.body[:gt] || range_condition.body[:gte]
+      maximum_value = range_condition.body[:lt] || range_condition.body[:lte]
+
+      {}.tap do |h|
+        h["#{field}_since".to_sym] = minimum_value if minimum_value
+        h["#{field}_until".to_sym] = maximum_value if maximum_value
+      end
+    end
+
+    def visit_query_aggregations(query_aggregations)
+      query_aggregations._aggregations.flat_map { |agg| agg.accept_visitor(self) }
+    end
+
+    def visit_aggregation(aggregation)
+      []
+    end
+
+    def visit_filter_aggregation(filter_aggregation)
+      filter_aggregation._subaggregations._conditions.accept_visitor(self)
+    end
+
+  end
+end

data/lib/elasticated/delimiters/date_field_delimiter.rb

@@ -1,37 +1,32 @@
 module Elasticated
   module Delimiters
-    class DateFieldDelimiter < TermFieldDelimiter
+    class DateFieldDelimiter < StandardFieldDelimiter
 
       attr_accessor :date_since, :date_until
 
-      def set_minimum(field, date)
-        return unless applies_to? field
-        self.date_since = date unless date_since && date < date_since
-      end
-
-      def set_maximum(field, date)
-        return unless applies_to? field
-        self.date_until = date unless date_until && date > date_until
+      def initialize(opts={})
+        super
+        self.date_since = opts[:date_since]
+        self.date_until = opts[:date_until]
       end
 
       def build_strategy_params
         params = Hash.new
-        if values.empty?
-          raise "date_since is higher than date_until (#{date_since} - #{date_until})" \
-            if date_since && date_until && date_since > date_until
+        raise "date_since is higher than date_until (#{date_since} - #{date_until})" \
+          if date_since && date_until && date_since > date_until
+        if date_since == date_until and not date_since.nil?
+          params.merge! date: date_since
+        else
           params.merge! date_since: date_since if date_since
           params.merge! date_until: date_until if date_until
-        else
-          if values.count > 1
-            params.merge! date_since: values.min
-            params.merge! date_until: values.max
-          else
-            params.merge! date: values.first
-          end
         end
         params
       end
 
+      def completed_with(delimiters, opts={})
+        Elasticated.date_delimiter_factory.create(self, delimiters, opts)
+      end
+
     end
   end
 end

data/lib/elasticated/delimiters/standard_field_delimiter.rb

@@ -8,24 +8,8 @@ module Elasticated
       attr_accessor :field_name, :filter_name
 
       def initialize(opts={})
-        self.field_name = opts.fetch :field
-        self.filter_name = opts.fetch :as, field_name
-      end
-
-      def applies_to?(condition_field)
-        field_name.to_s == condition_field.to_s
-      end
-
-      def add_term(field, value)
-        # nothing to do, by default
-      end
-
-      def set_minimum(field, value)
-        # nothing to do, by default
-      end
-
-      def set_maximum(field, value)
-        # nothing to do, by default
+        self.field_name = opts.fetch(:field)
+        self.filter_name = opts.fetch(:as, field_name)
       end
 
     end

data/lib/elasticated/delimiters/term_field_delimiter.rb

@@ -6,12 +6,7 @@ module Elasticated
 
       def initialize(opts={})
         super
-        self.values = Array.new
-      end
-
-      def add_term(field, value)
-        return unless applies_to? field
-        values << value
+        self.values = opts[:values] || []
       end
 
       def build_strategy_params
@@ -19,6 +14,10 @@ module Elasticated
         { filter_name => values.uniq }
       end
 
+      def completed_with(delimiters, opts={})
+        Elasticated.term_delimiter_factory.create(self, delimiters, opts)
+      end
+
     end
   end
 end

data/lib/elasticated/index_selector.rb

@@ -1,15 +1,20 @@
 module Elasticated
   class IndexSelector
 
-    # abstract class
-    # child must implement 'delimiters()'
-    # child must implement 'strategy()'
     # child can override 'strategy_params_for(document)'
 
     include BlockEvaluation
 
-    def indices_for_query(query)
-      strategy_params = strategy_params_for_query query
+    attr_reader :strategy, :delimiters
+
+    # params will not be optionals in the next version
+    def initialize(strategy=nil, delimiters=nil)
+      @strategy = strategy
+      @delimiters = delimiters
+    end
+
+    def indices_for_query(query, opts={})
+      strategy_params = Elasticated.strategy_params_for_query_service.strategy_params_for_query delimiters, query, opts
       indices = strategy.call strategy_params
       raise "At least one index should be affected for a search" if indices.count < 1
       indices
@@ -41,13 +46,6 @@ module Elasticated
       end
     end
 
-    def strategy_params_for_query(query)
-      delimiters.inject Hash.new do |params, delimiter|
-        query.fill_delimiter delimiter
-        params.merge delimiter.build_strategy_params
-      end
-    end
-
     def strategy_params_for_percolator(query)
       { date: DateTime.now.iso8601 }
     end