elasticated 2.5.5 → 3.0.0

data/lib/elasticated/conditions/standard_condition.rb

@@ -2,9 +2,8 @@ module Elasticated
   module Conditions
     class StandardCondition
 
-      include Inspectionable
-
-      include Clonable
+      include Mixins::Inspectionable
+      include Mixins::Clonable
 
       attr_accessor :field, :opts
 
@@ -13,8 +12,8 @@ module Elasticated
         self.opts = opts
       end
 
-      def accept_visitor(visitor)
-        visitor.visit_condition(self)
+      def fill_delimiter(field_delimiter)
+        # nothing to do, by default
       end
 
     end

data/lib/elasticated/conditions/term_condition.rb

@@ -0,0 +1,22 @@
+module Elasticated
+  module Conditions
+    class TermCondition < StandardCondition
+
+      attr_accessor :value
+
+      def initialize(field, value, opts={})
+        super(field, opts)
+        self.value = value
+      end
+
+      def build
+        { term: { field => value }.merge(opts) }
+      end
+
+      def fill_delimiter(field_delimiter)
+        field_delimiter.add_term field, value
+      end
+
+    end
+  end
+end

data/lib/elasticated/conditions/terms_condition.rb

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

data/lib/elasticated/conditions_builder.rb

@@ -1,16 +1,20 @@
 module Elasticated
   module ConditionsBuilder
 
-    include BlockEvaluation
+    include Mixins::BlockEvaluation
 
     def custom(body)
       add Conditions::CustomCondition.new body
     end
 
-    def equal(field, values, opts={})
+    def term(field, value, opts={})
+      add Conditions::TermCondition.new field, value, opts
+    end
+
+    def terms(field, values, opts={})
       add Conditions::TermsCondition.new field, [*values], opts
     end
-    alias_method :terms, :equal
+    alias_method :equal, :terms
 
     def wildcard(field, value, opts={})
       add Conditions::WildcardCondition.new field, value, opts
@@ -28,9 +32,10 @@ module Elasticated
       add Conditions::MissingCondition.new field, opts
     end
 
-    def between(field, min_value, max_value, opts={})
+    def range(field, min_value, max_value, opts={})
       add Conditions::RangeCondition.new field, { lte: max_value, gte: min_value }, opts
     end
+    alias_method :between, :range
 
     def greater_than(field, value, opts={})
       add Conditions::RangeCondition.new field, { gt: value }, opts
@@ -71,5 +76,15 @@ module Elasticated
     end
     alias_method :bool, :boolean
 
+    # helper methods
+
+    def equal(field, value_or_values, opts={})
+      value_or_values.is_a?(Array) ? terms(field, value_or_values, opts) : term(field, value_or_values, opts)
+    end
+
+    def now
+      Elasticated::Enum::NOW
+    end
+
   end
 end

data/lib/elasticated/delimiters/date_field_delimiter.rb

@@ -1,30 +1,39 @@
 module Elasticated
   module Delimiters
-    class DateFieldDelimiter < StandardFieldDelimiter
+    class DateFieldDelimiter < TermFieldDelimiter
 
       attr_accessor :date_since, :date_until
 
-      def initialize(opts={})
-        super
-        self.date_since = opts[:date_since]
-        self.date_until = opts[:date_until]
+      def set_minimum(field, date)
+        return unless applies_to? field
+        raise("The date 'now' is not valid as minimum value of a range condition") if is_now?(date)
+        self.date_since = date unless date_since && date < date_since
+      end
+
+      def set_maximum(field, date)
+        return unless applies_to? field
+        return if is_now?(date)
+        self.date_until = date unless date_until && date > date_until
       end
 
       def build_strategy_params
         params = Hash.new
-        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
+        if values.empty?
+          raise "date_since is higher than date_until (#{date_since} - #{date_until})" \
+            if date_since && date_until && date_since > date_until
           params.merge! date_since: date_since if date_since
           params.merge! date_until: date_until if date_until
+        else
+          raise "Only one 'term' filter is allowed over the '#{field_name}' field" if values.count > 1
+          params.merge! date: values.first
         end
         params
       end
 
-      def completed_with(delimiters, opts={})
-        Elasticated.date_delimiter_factory.create(self, delimiters, opts)
+      protected
+
+      def is_now?(date)
+        date.to_s == Elasticated::Enum::NOW
       end
 
     end

data/lib/elasticated/delimiters/standard_field_delimiter.rb

@@ -8,8 +8,24 @@ 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)
+        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
       end
 
     end

data/lib/elasticated/delimiters/term_field_delimiter.rb

@@ -6,7 +6,12 @@ module Elasticated
 
       def initialize(opts={})
         super
-        self.values = opts[:values] || []
+        self.values = Array.new
+      end
+
+      def add_term(field, value)
+        return unless applies_to? field
+        values << value
       end
 
       def build_strategy_params
@@ -14,10 +19,6 @@ 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/document.rb

@@ -27,7 +27,8 @@ module Elasticated
 
     end
 
-    include BlockEvaluation
+    include Mixins::Inspectionable
+    include Mixins::BlockEvaluation
 
     attr_accessor :id, :type, :index, :score, :version, :document_source
 
@@ -43,5 +44,23 @@ module Elasticated
       self.document_source ||= Hash::Accessible.new
     end
 
+    def text_for_inspect
+      text = "#{index}/#{type}/#{id}"
+      text = "#{text} v#{version}" if version
+      text = "#{text} scoring #{score}" if score
+      text
+    end
+
+    def to_h
+      {
+        _id: id,
+        _type: type,
+        _index: index,
+        _score: score,
+        _version: version,
+        _source: source.to_h
+      }
+    end
+
   end
 end

data/lib/elasticated/enum.rb

@@ -0,0 +1,17 @@
+module Elasticated
+  module Enum
+
+    NOW = 'now'.freeze
+
+    module Mapping
+      module Dynamic
+
+        ACCEPT_NEW_FIELDS = true
+        IGNORE_NEW_FIELDS = false
+        STRICT = 'strict'.freeze
+
+      end
+    end
+
+  end
+end

data/lib/elasticated/index_selector.rb

@@ -1,39 +1,38 @@
 module Elasticated
   class IndexSelector
 
+    # abstract class
+    # child must implement 'delimiters()'
+    # child must implement 'strategy()'
     # child can override 'strategy_params_for(document)'
 
-    include BlockEvaluation
+    include Mixins::BlockEvaluation
 
-    attr_reader :strategy, :delimiters
-
-    # params will not be optionals in the next version
-    def initialize(strategy=nil, delimiters=nil)
-      @strategy = strategy
-      @delimiters = delimiters
+    def index_for_params(params)
+      indices = indices_for_params params
+      raise "Only one index can be affected" if indices.count > 1
+      indices.first
     end
 
-    def indices_for_query(query, opts={})
-      params = strategy_params_for_query(query, opts)
+    def indices_for_params(params)
       indices = strategy.call params
-      raise "At least one index should be affected for a search" if indices.count < 1
+      raise "At least one index should be affected" if indices.count < 1
       indices
     end
 
+    def indices_for_query(query)
+      params = strategy_params_for_query query
+      indices_for_params params
+    end
+
     def index_for_document(document)
       params = strategy_params_for_document document
-      indices = strategy.call params
-      raise "Only one index can be affected for a document indexation" if indices.count > 1
-      raise "At least one index should be affected for a document indexation" if indices.count < 1
-      indices.first
+      index_for_params params
     end
 
-    def index_for_percolator(query)
-      params = strategy_params_for_percolator query
-      indices = strategy.call params
-      raise "Only one index can be affected for a percolator indexation" if indices.count > 1
-      raise "At least one index should be affected for a percolator indexation" if indices.count < 1
-      indices.first
+    def index_for_percolator
+      params = strategy_params_for_percolator
+      index_for_params params
     end
 
     protected
@@ -46,13 +45,15 @@ module Elasticated
       end
     end
 
-    def strategy_params_for_percolator(query)
-      { date: DateTime.now.iso8601 }
+    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_query(query, opts={})
-      service = Elasticated.strategy_params_for_query_service
-      service.strategy_params_for_query(delimiters, query, opts)
+    def strategy_params_for_percolator
+      { date: DateTime.now.iso8601 }
     end
 
   end

data/lib/elasticated/mapping.rb

@@ -4,13 +4,11 @@ module Elasticated
     class << self
 
       def partial(&block)
-        Partial.new &block
+        Partial.new(&block)
       end
 
       def build(&block)
-        instance = Builder.new
-        instance.evaluate block
-        instance.build
+        Builder.build(&block)
       end
 
     end

data/lib/elasticated/mapping/builder.rb

@@ -6,11 +6,11 @@ module Elasticated
         def build(&block)
           instance = new
           instance.evaluate block
-          instance.build
+          instance
         end
       end
 
-      include BlockEvaluation
+      include Mixins::BlockEvaluation
 
       attr_accessor :mapping_types
 
@@ -30,6 +30,7 @@ module Elasticated
           hash.merge mapping_type.build
         end
       end
+      alias_method :to_h, :build
 
     end
   end

data/lib/elasticated/mapping/fields_builder.rb

@@ -2,7 +2,7 @@ module Elasticated
   module Mapping
     class FieldsBuilder
 
-      include BlockEvaluation
+      include Mixins::BlockEvaluation
 
       attr_accessor :hash, :name, :sub_objects, :nesteds
 
@@ -13,36 +13,40 @@ module Elasticated
         self.name = name
       end
 
+      def add_property(name, value)
+        hash[name] = value
+      end
+
       def date(field_name)
-        hash[field_name] = build_date_field
+        add_property field_name, build_date_field
       end
 
       def string(field_name)
-        hash[field_name] = build_string_field
+        add_property field_name, build_string_field
       end
 
       def float(field_name)
-        hash[field_name] = build_float_field
+        add_property field_name, build_float_field
       end
 
       def double(field_name)
-        hash[field_name] = build_double_field
+        add_property field_name, build_double_field
       end
 
       def integer(field_name)
-        hash[field_name] = build_integer_field
+        add_property field_name, build_integer_field
       end
 
       def long(field_name)
-        hash[field_name] = build_long_field
+        add_property field_name, build_long_field
       end
 
       def analyzed_string(field_name)
-        hash[field_name] = build_analyzed_string_field field_name
+        add_property field_name, build_analyzed_string_field(field_name)
       end
 
       def bool(field_name)
-        hash[field_name] = build_bool_field
+        add_property field_name, build_bool_field
       end
 
       def object(object_name, &block)