elasticated 1.0.0

data/lib/elasticated/clonable.rb

@@ -0,0 +1,58 @@
+module Elasticated
+  module Clonable
+
+    def clone
+      ret = super
+      instance_variables.each do |instance_variable|
+        value = instance_variable_get instance_variable
+        value = case value.class
+        when Array
+          clone_array value
+        when Hash
+          Helpers.hash_deep_dup value
+        else
+          value.clone
+        end
+        ret.instance_variable_set instance_variable, value
+      end
+      ret
+    end
+
+    def ==(other_entity)
+      other_entity.class == self.class &&
+      instance_variables.all? do |instance_variable|
+        next true if instance_variable == :@_subaggregations # Subaggregated
+        value = instance_variable_get instance_variable
+        other_value = other_entity.instance_variable_get instance_variable
+        case other_value.class
+        when Array
+          compare_arrays value, other_value
+        else
+          other_value == value
+        end
+      end
+    end
+
+    private
+
+    def clone_array(array)
+      array.map do |element|
+        case element.class
+        when Hash
+          Helpers.hash_deep_dup element
+        when Array
+          clone_array element
+        else
+          element.clone
+        end
+      end
+    end
+
+    def compare_arrays(array_a, array_b)
+      array_a.all? do |element|
+        array_b.include? element
+      end && array_a.size == array_b.size
+    end
+
+  end
+end

data/lib/elasticated/conditions/custom_condition.rb

@@ -0,0 +1,19 @@
+module Elasticated
+  module Conditions
+    class CustomCondition
+
+      include Inspectionable
+
+      attr_accessor :body
+
+      def initialize(body)
+        self.body = body
+      end
+
+      def build
+        body
+      end
+
+    end
+  end
+end

data/lib/elasticated/conditions/exists_condition.rb

@@ -0,0 +1,11 @@
+module Elasticated
+  module Conditions
+    class ExistsCondition < StandardCondition
+
+      def build
+        { exists: { field: field }.merge(opts) }
+      end
+
+    end
+  end
+end

data/lib/elasticated/conditions/missing_condition.rb

@@ -0,0 +1,11 @@
+module Elasticated
+  module Conditions
+    class MissingCondition < StandardCondition
+
+      def build
+        { missing: { field: field }.merge(opts) }
+      end
+
+    end
+  end
+end

data/lib/elasticated/conditions/nested_condition.rb

@@ -0,0 +1,19 @@
+module Elasticated
+  module Conditions
+    class NestedCondition < StandardCondition
+
+      attr_accessor :inner_conditions
+
+      def initialize(field, inner_conditions, opts={})
+        super(field, opts)
+        self.inner_conditions = inner_conditions
+      end
+
+      def build
+        body = inner_conditions.build
+        { nested: { path: field, filter: body }.merge(opts) }
+      end
+
+    end
+  end
+end

data/lib/elasticated/conditions/range_condition.rb

@@ -0,0 +1,27 @@
+module Elasticated
+  module Conditions
+    class RangeCondition < StandardCondition
+
+      # example: RangeCondition.new :age, gte: 18, lt: 40
+
+      attr_accessor :body
+
+      def initialize(field, body, opts={})
+        super(field, opts)
+        self.body = Hash::Indifferent.new body
+      end
+
+      def build
+        { 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
+      end
+
+    end
+  end
+end

data/lib/elasticated/conditions/script_condition.rb

@@ -0,0 +1,22 @@
+module Elasticated
+  module Conditions
+    class ScriptCondition
+
+      include Inspectionable
+
+      attr_accessor :script, :params
+
+      def initialize(script, params={})
+        self.script = script
+        self.params = params
+      end
+
+      def build
+        body = { script: script }
+        body.merge! params: params unless params.empty?
+        { script: body }
+      end
+
+    end
+  end
+end

data/lib/elasticated/conditions/standard_condition.rb

@@ -0,0 +1,26 @@
+module Elasticated
+  module Conditions
+    class StandardCondition
+
+      include Inspectionable
+
+      include Clonable
+
+      attr_accessor :field, :opts
+
+      def initialize(field, opts={})
+        self.field = field
+        self.opts = opts
+      end
+
+      def fill_date_delimiter(dfd)
+        # nothing to do, by default
+      end
+
+      def fill_term_delimiter(tfd)
+        # nothing to do, by default
+      end
+
+    end
+  end
+end

data/lib/elasticated/conditions/terms_condition.rb

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

data/lib/elasticated/conditions/wildcard_condition.rb

@@ -0,0 +1,18 @@
+module Elasticated
+  module Conditions
+    class WildcardCondition < StandardCondition
+
+      attr_accessor :regex
+
+      def initialize(field, regex, opts={})
+        super(field, opts)
+        self.regex = regex
+      end
+
+      def build
+        { wildcard: { field => regex }.merge(opts) }
+      end
+
+    end
+  end
+end

data/lib/elasticated/conditions_builder.rb

@@ -0,0 +1,75 @@
+module Elasticated
+  module ConditionsBuilder
+
+    include BlockEvaluation
+
+    def custom(body)
+      add Conditions::CustomCondition.new body
+    end
+
+    def equal(field, values, opts={})
+      add Conditions::TermsCondition.new field, [*values], opts
+    end
+    alias_method :terms, :equal
+
+    def wildcard(field, value, opts={})
+      add Conditions::WildcardCondition.new field, value, opts
+    end
+
+    def with(field, opts={})
+      add Conditions::WildcardCondition.new field, '*', opts
+    end
+
+    def exists(field, opts={})
+      add Conditions::ExistsCondition.new field, opts
+    end
+
+    def missing(field, opts={})
+      add Conditions::MissingCondition.new field, opts
+    end
+
+    def between(field, min_value, max_value, opts={})
+      add Conditions::RangeCondition.new field, { lte: max_value, gte: min_value }, opts
+    end
+
+    def greater_than(field, value, opts={})
+      add Conditions::RangeCondition.new field, { gt: value }, opts
+    end
+    alias_method :gt, :greater_than
+
+    def greater_equal(field, value, opts={})
+      add Conditions::RangeCondition.new field, { gte: value }, opts
+    end
+    alias_method :ge, :greater_equal
+    alias_method :gte, :greater_equal
+
+    def less_than(field, value, opts={})
+      add Conditions::RangeCondition.new field, { lt: value }, opts
+    end
+    alias_method :lt, :less_than
+
+    def less_equal(field, value, opts={})
+      add Conditions::RangeCondition.new field, { lte: value }, opts
+    end
+    alias_method :le, :less_equal
+    alias_method :lte, :less_equal
+
+    def nested(path, opts={}, &block)
+      inner_conditions = self.class.new
+      inner_conditions.evaluate block
+      add Conditions::NestedCondition.new path, inner_conditions, opts
+    end
+
+    def script(script, params={})
+      add Conditions::ScriptCondition.new script, params
+    end
+
+    def boolean(&block)
+      boolean_children = QueryConditions.new
+      boolean_children.evaluate block
+      add boolean_children
+    end
+    alias_method :bool, :boolean
+
+  end
+end

data/lib/elasticated/configurable.rb

@@ -0,0 +1,9 @@
+module Elasticated
+  module Configurable
+
+    def log
+      Configuration.logger ||= DefaultLogger.new
+    end
+
+  end
+end

data/lib/elasticated/configuration.rb

@@ -0,0 +1,9 @@
+module Elasticated
+  class Configuration
+
+    class << self
+      attr_accessor :logger
+    end
+
+  end
+end

data/lib/elasticated/default_logger.rb

@@ -0,0 +1,27 @@
+module Elasticated
+  class DefaultLogger
+
+    # interface
+
+    def trace(message)
+      puts "TRACE #{message}"
+    end
+
+    def debug(message)
+      puts "DEBUG #{message}"
+    end
+
+    def info(message)
+      puts "INFO #{message}"
+    end
+
+    def warn(message)
+      puts "WARN #{message}"
+    end
+
+    def error(message)
+      puts "ERROR #{message}"
+    end
+
+  end
+end

data/lib/elasticated/delimiters/date_field_delimiter.rb

@@ -0,0 +1,33 @@
+module Elasticated
+  module Delimiters
+    class DateFieldDelimiter < TermFieldDelimiter
+
+      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
+      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
+          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
+
+    end
+  end
+end

data/lib/elasticated/delimiters/standard_field_delimiter.rb

@@ -0,0 +1,33 @@
+module Elasticated
+  module Delimiters
+    class StandardFieldDelimiter
+
+      # abstract class
+      # child must implement 'build_strategy_params()'
+
+      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
+      end
+
+    end
+  end
+end

data/lib/elasticated/delimiters/term_field_delimiter.rb

@@ -0,0 +1,24 @@
+module Elasticated
+  module Delimiters
+    class TermFieldDelimiter < StandardFieldDelimiter
+
+      attr_accessor :values
+
+      def initialize(opts={})
+        super
+        self.values = Array.new
+      end
+
+      def add_term(field, value)
+        return unless applies_to? field
+        values << value
+      end
+
+      def build_strategy_params
+        return Hash.new if values.empty?
+        { filter_name => values.uniq }
+      end
+
+    end
+  end
+end