ruby-druid 0.1.9 → 0.9.0

data/lib/druid/granularity.rb

@@ -0,0 +1,39 @@
+module Druid
+  class Granularity
+    include ActiveModel::Model
+
+    attr_accessor :type
+    validates :type, inclusion: { in: %w(period) }
+
+    class PeriodValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        valid = ISO8601::Duration.new(value) rescue nil
+        record.errors.add(attribute, 'must be a valid ISO 8601 period') unless valid
+      end
+    end
+
+    attr_accessor :period
+    validates :period, period: true
+
+    attr_accessor :timeZone
+    validates :timeZone, allow_nil: true, inclusion: {
+      in: ActiveSupport::TimeZone.all.map { |tz| tz.tzinfo.name }
+    }
+
+    class OriginValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        return unless value
+        valid = ISO8601::DateTime.new(value) rescue nil
+        record.errors.add(attribute, 'must be a valid ISO 8601 time') unless valid
+      end
+    end
+
+    attr_accessor :origin
+    validates :origin, origin: true
+
+    def as_json(options = {})
+      super(options.merge(except: %w(errors validation_context)))
+    end
+
+  end
+end

data/lib/druid/having.rb

@@ -1,14 +1,68 @@
 module Druid
   class Having
+    include ActiveModel::Model
+
+    attr_accessor :type
+    validates :type, inclusion: { in: %w(and or not greaterThan lessThan equalTo) }
+
+    class HavingsValidator < ActiveModel::EachValidator
+      TYPES = %w(and or)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.queryType)
+          value.each(&:valid?) # trigger validation
+          value.each do |avalue|
+            avalue.errors.messages.each do |k, v|
+              record.errors.add(attribute, { k => v })
+            end
+          end
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.queryType}") if value
+        end
+      end
+    end
+
+    attr_accessor :havingSpecs
+    validates :havingSpecs, havings: true
+
+    def havingSpecs
+      @havingSpecs ||= []
+    end
+
+    class HavingValidator < ActiveModel::EachValidator
+      TYPES = %w(not)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.type)
+          record.errors.add(attribute, 'may not be blank') if value.blank?
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.type}") if value
+        end
+      end
+    end
+
+    attr_accessor :havingSpec
+    validates :havingSpec, having: true
+
+    class AggregationValidator < ActiveModel::EachValidator
+      TYPES = %w(greaterThan lessThan equalTo)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.type)
+          record.errors.add(attribute, 'may not be blank') if value.blank?
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.type}") if value
+        end
+      end
+    end
+
+    attr_accessor :aggregation
+    validates :aggregation, aggregation: true
+
+    attr_accessor :value
+
     def method_missing(name, *args)
       if args.empty?
-        HavingClause.new(name)
+        HavingClause.new(aggregation: name)
       end
     end
-  end
-
-  class HavingFilter
-    include Serializable
 
     def clause?
       is_a?(HavingClause)
@@ -17,38 +71,80 @@ module Druid
     def operator?
       is_a?(HavingOperator)
     end
+
+    def chain(other)
+      return unless other
+      if self.operator? && self.and?
+        having = self
+      else
+        having = HavingOperator.new(type: 'and')
+        having.havingSpecs << self
+      end
+      having.havingSpecs << other
+      having
+    end
+
+    def as_json(options = {})
+      super(options.merge(except: %w(errors validation_context)))
+    end
   end
 
-  class HavingClause < HavingFilter
-    def initialize(metric)
-      @metric = metric
+  class HavingClause < Having
+    def &(other)
+      create_operator('and', other)
+    end
+
+    def |(other)
+      create_operator('or', other)
     end
 
+    def !
+      create_operator('not')
+    end
+
+    def eq(value)
+      set_clause('equalTo', value)
+    end
+
+    alias :'==' :eq
+
+    def neq(value)
+      !eq(value)
+    end
+
+    alias :'!=' :neq
+
     def <(value)
-      @type = "lessThan"
-      @value = value
-      self
+      set_clause('lessThan', value)
     end
 
     def >(value)
-      @type = "greaterThan"
-      @value = value
-      self
+      set_clause('greaterThan', value)
     end
 
-    def to_hash
-      {
-        :type => @type,
-        :aggregation => @metric,
-        :value => @value
-      }
+    private
+
+    def create_operator(type, other = nil)
+      operator = HavingOperator.new(type: type)
+      if type.to_s == 'not'
+        operator.havingSpec = self
+      else
+        operator.havingSpecs << self
+        operator.havingSpecs << other if other
+      end
+      operator
     end
-  end
 
-  class HavingOperator < HavingFilter
-    def initialize(type)
+    def set_clause(type, value)
       @type = type
-      @elements = []
+      @value = value
+      self
+    end
+  end
+
+  class HavingOperator < Having
+    def and?
+      @type == 'and'
     end
 
     def and?
@@ -59,11 +155,35 @@ module Druid
       @elements << element
     end
 
-    def to_hash
-      {
-        :type => @type,
-        :havingSpecs => @elements
-      }
+    def &(other)
+      apply_operator('and', other)
+    end
+
+    def |(other)
+      apply_operator('or', other)
+    end
+
+    def !
+      if @type == 'not'
+        @elements.first
+      else
+        operator = HavingOperator.new(type: 'not')
+        operator.havingSpec = self
+        operator
+      end
+    end
+
+    private
+
+    def apply_operator(type, other)
+      if @type == type
+        operator = self
+      else
+        operator = HavingOperator.new(type: type)
+        operator.havingSpecs << self
+      end
+      operator.havingSpecs << other
+      operator
     end
   end
 end

data/lib/druid/post_aggregation.rb

@@ -1,14 +1,116 @@
 module Druid
   class PostAggregation
+    include ActiveModel::Model
+
+    attr_accessor :numBuckets
+
+    attr_accessor :type
+    validates :type, inclusion: { in: %w(arithmetic fieldAccess constant javascript hyperUniqueCardinality) }
+
+    class NameValidator < ActiveModel::EachValidator
+      TYPES = %w(arithmetic constant javascript)
+      def validate_each(record, attribute, value)
+        if !TYPES.include?(record.type)
+          record.errors.add(attribute, "is not supported by type=#{record.type}") if value
+        end
+      end
+    end
+
+    attr_accessor :name
+    validates :name, name: true
+
+    class FnValidator < ActiveModel::EachValidator
+      TYPES = %w(arithmetic)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.type)
+          record.errors.add(attribute, 'must be a valid arithmetic operation') unless %w(+ - * /).include?(value)
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.type}") if value
+        end
+      end
+    end
+
+    attr_accessor :fn
+    validates :fn, fn: true
+
+    class FieldsValidator < ActiveModel::EachValidator
+      TYPES = %w(arithmetic)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.type)
+          value.each(&:valid?) # trigger validation
+          value.each do |fvalue|
+            fvalue.errors.messages.each do |k, v|
+              record.errors.add(attribute, { k => v })
+            end
+          end
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.type}") if value
+        end
+      end
+    end
+
+    attr_accessor :fields
+    validates :fields, fields: true
+
+    def fields=(value)
+      @fields = [value].flatten.compact.map do |aggregation|
+        PostAggregation.new(aggregation)
+      end
+    end
+
+    class FieldnameValidator < ActiveModel::EachValidator
+      TYPES = %w(fieldAccess hyperUniqueCardinality)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.type)
+          record.errors.add(attribute, 'may not be blank') if value.blank?
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.type}") if value
+        end
+      end
+    end
+
+    attr_accessor :fieldName
+    validates :fieldName, fieldname: true
+
+    class ValueValidator < ActiveModel::EachValidator
+      TYPES = %w(constant)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.type)
+          record.errors.add(attribute, 'must be numeric') if !value.is_a?(Numeric)
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.type}") if value
+        end
+      end
+    end
+
+    attr_accessor :value
+    validates :value, value: true
+
+    class FunctionValidator < ActiveModel::EachValidator
+      TYPES = %w(javascript)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.type)
+          record.errors.add(attribute, 'may not be blank') if value.blank?
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.type}") if value
+        end
+      end
+    end
+
+    attr_accessor :function
+    validates :function, function: true
+
+    attr_reader :fieldNames
+
     def method_missing(name, *args)
       if args.empty?
-        PostAggregationField.new(name)
+        PostAggregationField.new(fieldName: name)
       end
     end
 
     def js(*args)
       if args.empty?
-        PostAggregationField.new(:js)
+        PostAggregationField.new(fieldName: :js)
       else
         PostAggregationJavascript.new(args.first)
       end
@@ -33,125 +135,137 @@ module Druid
     end
   end
 
-  class PostAggregationOperation
+  class PostAggregationOperation < PostAggregation
     include PostAggregationOperators
 
-    attr_reader :left, :operator, :right, :name
-
     def initialize(left, operator, right)
-      @left = left.is_a?(Numeric) ? PostAggregationConstant.new(left) : left
-      @operator = operator
-      @right = right.is_a?(Numeric) ? PostAggregationConstant.new(right) : right
+      super()
+      @type = 'arithmetic'
+      @fn = operator
+      @fields = [
+        left.is_a?(Numeric) ? PostAggregationConstant.new(value: left) : left,
+        right.is_a?(Numeric) ? PostAggregationConstant.new(value: right) : right,
+      ]
     end
 
     def as(field)
-      @name = field.name.to_s
+      @name = field.fieldName.to_s
       self
     end
 
-    def get_field_names
-      field_names = []
-      field_names << left.get_field_names if left.respond_to?(:get_field_names)
-      field_names << right.get_field_names if right.respond_to?(:get_field_names)
-      field_names
-    end
-
-    def to_hash
-      hash = { "type" => "arithmetic", "fn" => @operator, "fields" => [@left.to_hash, @right.to_hash] }
-      hash["name"] = @name if @name
-      hash
-    end
-
-    def to_json(*a)
-      to_hash.to_json(*a)
-    end
-
-    def as_json(*a)
-      to_hash
+    def field_names
+      fields.map(&:field_names).flatten.compact.uniq
     end
   end
 
-  class PostAggregationField
+  class PostAggregationField < PostAggregation
     include PostAggregationOperators
 
-    attr_reader :name
-
-    def initialize(name)
-      @name = name
+    def initialize(attributes = {})
+      super
+      @type = 'fieldAccess'
     end
 
-    def get_field_names
-      @name
+    def field_names
+      [@fieldName]
     end
+  end
 
-    def to_hash
-      { "type" => "fieldAccess", "name" => @name, "fieldName" => @name }
-    end
+  class PostAggregationConstant < PostAggregation
+    include PostAggregationOperators
 
-    def to_json(*a)
-      to_hash.to_json(*a)
+    def initialize(attributes = {})
+      super
+      @type = 'constant'
     end
 
-    def as_json(*a)
-      to_hash
+    def field_names
+      []
     end
   end
 
-  class PostAggregationConstant
+  class PostAggregationJavascript < PostAggregation
     include PostAggregationOperators
 
-    attr_reader :value
-
-    def initialize(value)
-      @value = value
+    def initialize(function)
+      super()
+      @type = 'javascript'
+      @fieldNames = extract_fields(function)
+      @function = function
     end
 
-    def to_hash
-      { "type" => "constant", "value" => @value }
+    def field_names
+      @fieldNames
     end
 
-    def to_json(*a)
-      to_hash.to_json(*a)
+    def as(field)
+      @name = field.fieldName.to_s
+      self
     end
 
-    def as_json(*a)
-      to_hash
+    private
+
+    def extract_fields(function)
+      match = function.match(/function\((.+)\)/)
+      raise 'Invalid Javascript function' unless match && match.captures
+      match.captures.first.split(',').map(&:strip)
     end
   end
 
-  class PostAggregationJavascript
-    include PostAggregationOperators
-    include Serializable
+  class PostAggregationHistogramEqualBuckets < PostAggregation
+    attr_accessor :numBuckets
+    def initialize(attributes = {})
+      super(attributes)
+      @type = "equalBuckets"
+      @numBuckets ||= 10
+    end
+  end
 
-    def initialize(function)
-      @field_names = extract_fields(function)
-      @function = function
+  class PostAggregationHistogramBuckets < PostAggregation
+    attr_accessor :bucketSize
+    attr_accessor :offset
+    def initialize(attributes = {})
+      super
+      @type = "buckets"
     end
+  end
 
-    def get_field_names
-      @field_names
+  class PostAggregationHistogramCustomBuckets < PostAggregation
+    attr_accessor :breaks
+    def initialize(attributes = {})
+      super
+      @type = "customBuckets"
     end
+  end
 
-    def as(field)
-      @name = field.name.to_s
-      self
+  class PostAggregationHistogramMin < PostAggregation
+    def initialize(attributes = {})
+      super
+      @type = "min"
     end
+  end
 
-    def to_hash
-      {
-        "type" => "javascript",
-        "name" => @name,
-        "fieldNames" => @field_names,
-        "function" => @function
-      }
+  class PostAggregationHistogramMax < PostAggregation
+    def initialize(attributes = {})
+      super
+      @type = "max"
     end
+  end
 
-    private
+  class PostAggregationHistogramQuantile < PostAggregation
+    attr_accessor :propability
+    def initialize(attributes = {})
+      super
+      @type = "quantile"
+    end
+  end
 
-    def extract_fields(function)
-      match = function.match(/function\((.+)\)/)
-      raise 'Invalid Javascript function' unless match && match.captures
-      match.captures.first.split(',').map {|field| field.strip }
+  class PostAggregationHistogramQuantiles < PostAggregation
+    attr_accessor :probabilities
+    def initialize(attributes = {})
+      super
+      @type = "quantiles"
     end
   end
-end
+
+end