ruby-druid 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: adfe39dfd535cfb911d89bece7d3921b8e63c162
-  data.tar.gz: 74fcfe3637e3131dfb9e057c3ee1c33ff62840bf
+  metadata.gz: d0e676ac15efc4d9777fa182d8c8855bc1ebf386
+  data.tar.gz: e54d2ec80e3bb5efdf02d3b5b127c565c5cfce86
 SHA512:
-  metadata.gz: d06463d4a10c5d142f09b71acb3785bf8906cf5cf1719995b60006499754d609fce7ba1ed9b23ea338dd1587bb6b6bc967509c696ba2c09fc80e1a67367b529f
-  data.tar.gz: a6726f41601627488627aeeedc55163b2e65602d3845dacf0a1bcb66ec412d7dca8333cdeb440a860046ac75a93447132cd0ed5d250d5094532ae50743cda7d9
+  metadata.gz: 884a621b0fb481490d114248bfff0207bc2fd54e889832cf86318c6d26fb53c73c535d97d4d832fc9872a4f6b76b0d426a7050190e41639abfad2d728a36dd7a
+  data.tar.gz: b46976c63af7169c6581d092522f5ac97098320efe903bd6d5a6e58c9c2792aab34d0e17c474de174fc44e74d91a0fc6594a89d39beaf3c8f7fabe3f432af21e

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--require spec_helper

data/.travis.yml

@@ -3,8 +3,7 @@ rvm:
 - jruby
 - 2.0.0
 - 1.9.3
+script:
+- bundle exec rspec --format documentation
 notifications:
   email: false
-  hipchat:
-    rooms:
-      secure: WhPGqnsNAVchiJz/rmmIPIFHXI7NVd+k/zClVhtgyoPEdebFYFgOCEIGbE/53IVymVeXFFBeJUVQg1Um4AVsZzVpS5sC6ABWw7rH5PZQZ7k177ZmuhbIAVYLLXcX0OmolgsATvGejifVj5i/Kld46kRx3JDlWL/mA465Kso7a/k=

data/README.md

@@ -91,12 +91,18 @@ A simple syntax for post aggregations with +,-,/,* can be used like:
 
 ```ruby
 query = Druid::Query.new('service/source').long_sum([:aggregate1, :aggregate2])
-query.postagg{(aggregate2 + aggregate2).as output_field_name}
+query.postagg { (aggregate2 + aggregate2).as output_field_name }
 ```
 
 Required fields for the postaggregation are fetched automatically by the
 library.
 
+Javascript post aggregations are also supported:
+
+```ruby
+query.postagg { js('function(aggregate1, aggregate2) { return aggregate1 + aggregate2; }').as result }
+```
+
 ### Query Interval
 
 The interval for the query takes a string with date and time or objects that

data/lib/druid/having.rb

@@ -7,13 +7,19 @@ module Druid
     end
   end
 
-  class HavingClause
-    (instance_methods + private_instance_methods).each do |method|
-      unless method.to_s =~ /^(__|instance_eval|instance_exec|initialize|object_id|raise|puts|inspect|class)/ || method.to_s =~ /\?/
-        undef_method method
-      end
+  class HavingFilter
+    include Serializable
+
+    def clause?
+      is_a?(HavingClause)
+    end
+
+    def operator?
+      is_a?(HavingOperator)
     end
+  end
 
+  class HavingClause < HavingFilter
     def initialize(metric)
       @metric = metric
     end
@@ -30,24 +36,34 @@ module Druid
       self
     end
 
-    def to_s
-      to_hash.to_s
+    def to_hash
+      {
+        :type => @type,
+        :aggregation => @metric,
+        :value => @value
+      }
+    end
+  end
+
+  class HavingOperator < HavingFilter
+    def initialize(type)
+      @type = type
+      @elements = []
     end
 
-    def as_json(*a)
-      to_hash
+    def and?
+      @type == 'and'
     end
 
-    def to_json(*a)
-      to_hash.to_json(*a)
+    def add(element)
+      @elements << element
     end
 
     def to_hash
       {
         :type => @type,
-        :aggregation => @metric,
-        :value => @value
+        :havingSpecs => @elements
       }
     end
   end
-end
+end

data/lib/druid/post_aggregation.rb

@@ -5,6 +5,14 @@ module Druid
         PostAggregationField.new(name)
       end
     end
+
+    def js(*args)
+      if args.empty?
+        PostAggregationField.new(:js)
+      else
+        PostAggregationJavascript.new(args.first)
+      end
+    end
   end
 
   module PostAggregationOperators
@@ -90,6 +98,8 @@ module Druid
   end
 
   class PostAggregationConstant
+    include PostAggregationOperators
+
     attr_reader :value
 
     def initialize(value)
@@ -108,4 +118,40 @@ module Druid
       to_hash
     end
   end
+
+  class PostAggregationJavascript
+    include PostAggregationOperators
+    include Serializable
+
+    def initialize(function)
+      @field_names = extract_fields(function)
+      @function = function
+    end
+
+    def get_field_names
+      @field_names
+    end
+
+    def as(field)
+      @name = field.name.to_s
+      self
+    end
+
+    def to_hash
+      {
+        "type" => "javascript",
+        "name" => @name,
+        "fieldNames" => @field_names,
+        "function" => @function
+      }
+    end
+
+    private
+
+    def extract_fields(function)
+      match = function.match(/function\((.+)\)/)
+      raise 'Invalid Javascript function' unless match && match.captures
+      match.captures.first.split(',').map {|field| field.strip }
+    end
+  end
 end

data/lib/druid/query.rb

@@ -1,6 +1,8 @@
+require 'druid/serializable'
 require 'druid/filter'
 require 'druid/having'
 require 'druid/post_aggregation'
+
 require 'time'
 require 'json'
 
@@ -137,7 +139,20 @@ module Druid
 
     def having(&block)
       having = Having.new.instance_exec(&block)
-      @properties[:having] = having
+
+      if old_having = @properties[:having]
+        if old_having.operator? && old_having.and?
+          new_having = old_having
+        else
+          new_having = HavingOperator.new('and')
+          new_having.add(old_having)
+        end
+        new_having.add(having)
+      else
+        new_having = having
+      end
+
+      @properties[:having] = new_having
       self
     end
 

data/lib/druid/serializable.rb

@@ -0,0 +1,19 @@
+module Druid
+  module Serializable
+    def to_hash
+      {}
+    end
+
+    def to_s
+      to_hash.to_s
+    end
+
+    def as_json(*a)
+      to_hash
+    end
+
+    def to_json(*a)
+      to_hash.to_json(*a)
+    end
+  end
+end

data/ruby-druid.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "ruby-druid"
-  spec.version       = "0.1.8"
+  spec.version       = "0.1.9"
   spec.authors       = ["LiquidM, Inc."]
   spec.email         = ["opensource@liquidm.com"]
   spec.summary       = %q{Ruby client for metamx druid}

data/spec/lib/client_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe Druid::Client do
 
   it 'calls zookeeper on intialize' do

data/spec/lib/query_spec.rb

@@ -1,5 +1,3 @@
-require "spec_helper"
-
 describe Druid::Query do
 
   before :each do
@@ -20,7 +18,7 @@ describe Druid::Query do
     @query.group_by()
     JSON.parse(@query.to_json)['queryType'].should == 'groupBy'
   end
-  
+
   it 'sets query type to timeseries' do
     @query.time_series()
     JSON.parse(@query.to_json)['queryType'].should == 'timeseries'
@@ -39,91 +37,113 @@ describe Druid::Query do
     result['threshold'].should == 25
   end
 
-  it 'build a post aggregation with a constant right' do
-    @query.postagg{(a + 1).as ctr }
+  describe '#postagg' do
+    it 'build a post aggregation with a constant right' do
+      @query.postagg{(a + 1).as ctr }
 
-    JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
-      "fn"=>"+",
-      "fields"=>
-      [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
-       {"type"=>"constant", "value"=>1}],
-      "name"=>"ctr"}]
-  end
+      JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
+        "fn"=>"+",
+        "fields"=>
+        [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
+         {"type"=>"constant", "value"=>1}],
+        "name"=>"ctr"}]
+    end
 
-  it 'build a + post aggregation' do
-    @query.postagg{(a + b).as ctr }
-    JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
-      "fn"=>"+",
-      "fields"=>
-      [{"type"=>"fieldAccess","name"=>"a", "fieldName"=>"a"},
-      {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
-      "name"=>"ctr"}]
-  end
+    it 'build a + post aggregation' do
+      @query.postagg{(a + b).as ctr }
+      JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
+        "fn"=>"+",
+        "fields"=>
+        [{"type"=>"fieldAccess","name"=>"a", "fieldName"=>"a"},
+        {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
+        "name"=>"ctr"}]
+    end
+
+    it 'build a - post aggregation' do
+      @query.postagg{(a - b).as ctr }
+      JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
+        "fn"=>"-",
+        "fields"=>
+        [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
+        {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
+        "name"=>"ctr"}]
+    end
+
+    it 'build a * post aggregation' do
+      @query.postagg{(a * b).as ctr }
+      JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
+        "fn"=>"*",
+        "fields"=>
+        [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
+        {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
+        "name"=>"ctr"}]
+    end
 
-  it 'build a - post aggregation' do
-    @query.postagg{(a - b).as ctr }
-    JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
-      "fn"=>"-",
-      "fields"=>
-      [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
-      {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
+    it 'build a / post aggregation' do
+      @query.postagg{(a / b).as ctr }
+      JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
+        "fn"=>"/",
+        "fields"=>
+        [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
+        {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
       "name"=>"ctr"}]
-  end
+    end
 
-  it 'build a * post aggregation' do
-    @query.postagg{(a * b).as ctr }
-    JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
-      "fn"=>"*",
-      "fields"=>
-      [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
-      {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
+    it 'build a complex post aggregation' do
+      @query.postagg{((a / b) * 1000).as ctr }
+      JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
+        "fn"=>"*",
+        "fields"=>
+        [{"type"=>"arithmetic", "fn"=>"/", "fields"=>
+          [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
+           {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}]},
+        {"type"=>"constant", "value"=>1000}],
       "name"=>"ctr"}]
-  end
+    end
 
-  it 'build a / post aggregation' do
-    @query.postagg{(a / b).as ctr }
-    JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
-      "fn"=>"/",
-      "fields"=>
-      [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
-      {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
-    "name"=>"ctr"}]
-  end
+    it 'adds fields required by the postagg operation to longsum' do
+      @query.postagg{ (a/b).as c }
+      JSON.parse(@query.to_json)['aggregations'].should == [
+        {"type"=>"longSum", "name"=>"a", "fieldName"=>"a"},
+        {"type"=>"longSum", "name"=>"b", "fieldName"=>"b"}
+      ]
+    end
 
-  it 'build a complex post aggregation' do
-    @query.postagg{((a / b) * 1000).as ctr }
-    JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
-      "fn"=>"*",
-      "fields"=>
-      [{"type"=>"arithmetic", "fn"=>"/", "fields"=>
+    it 'chains aggregations' do
+      @query.postagg{(a / b).as ctr }.postagg{(b / a).as rtc }
+
+      JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
+        "fn"=>"/",
+        "fields"=>
         [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
-         {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}]},
-      {"type"=>"constant", "value"=>1000}],
-    "name"=>"ctr"}]
-  end
-
-  it 'adds fields required by the postagg operation to longsum' do
-    @query.postagg{ (a/b).as c }
-    JSON.parse(@query.to_json)['aggregations'].should == [{"type"=>"longSum", "name"=>"a", "fieldName"=>"a"},
-                                                          {"type"=>"longSum", "name"=>"b", "fieldName"=>"b"}]
-  end
-
-  it 'chains aggregations' do
-    @query.postagg{(a / b).as ctr }.postagg{(b / a).as rtc }
-
-    JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
-      "fn"=>"/",
-      "fields"=>
-      [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
-      {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
-    "name"=>"ctr"},
-    {"type"=>"arithmetic",
-      "fn"=>"/",
-      "fields"=>
-      [{"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"},
-      {"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"}],
-    "name"=>"rtc"}
-    ]
+        {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
+      "name"=>"ctr"},
+      {"type"=>"arithmetic",
+        "fn"=>"/",
+        "fields"=>
+        [{"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"},
+        {"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"}],
+      "name"=>"rtc"}
+      ]
+    end
+
+    it 'builds a javascript post aggregation' do
+      @query.postagg { js('function(agg1, agg2) { return agg1 + agg2; }').as result }
+      JSON.parse(@query.to_json)['postAggregations'].should == [
+        {
+          'type' => 'javascript',
+          'name' => 'result',
+          'fieldNames' => ['agg1', 'agg2'],
+          'function' => 'function(agg1, agg2) { return agg1 + agg2; }'
+        }
+      ]
+    end
+
+    it 'raises an error when an invalid javascript function is used' do
+      expect {
+        @query.postagg { js('{ return a_with_b - a; }').as b }
+      }.to raise_error
+    end
   end
 
   it 'builds aggregations on long_sum' do
@@ -135,7 +155,6 @@ describe Druid::Query do
     ]
   end
 
-
   it 'appends long_sum properties from aggregations on calling long_sum again' do
     @query.long_sum(:a, :b, :c)
     @query.double_sum(:x,:y)
@@ -368,11 +387,25 @@ end
     ]}
   end
 
-  it 'creates a greater than having clause' do
-    @query.having{a > 100}
-    JSON.parse(@query.to_json)['having'].should == {
-      "type"=>"greaterThan", "aggregation"=>"a", "value"=>100
-    }
+  describe '#having' do
+    it 'creates a greater than having clause' do
+      @query.having{a > 100}
+      JSON.parse(@query.to_json)['having'].should == {
+        "type"=>"greaterThan", "aggregation"=>"a", "value"=>100
+      }
+    end
+
+    it 'chains having clauses with and' do
+      @query.having{a > 100}.having{b > 200}.having{c > 300}
+      JSON.parse(@query.to_json)['having'].should == {
+        "type" => "and",
+        "havingSpecs" => [
+          { "type" => "greaterThan", "aggregation" => "a", "value" => 100 },
+          { "type" => "greaterThan", "aggregation" => "b", "value" => 200 },
+          { "type" => "greaterThan", "aggregation" => "c", "value" => 300 }
+        ]
+      }
+    end
   end
 
   it 'does not accept in with empty array' do

data/spec/lib/zoo_handler_spec.rb

@@ -1,5 +1,3 @@
-require "spec_helper"
-
 module ZK
   def self.new(uri, opts = {})
     Mock.new uri, opts

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: ruby-druid
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - LiquidM, Inc.
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-09 00:00:00.000000000 Z
+date: 2014-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zk
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  prerelease: false
   type: :runtime
-- !ruby/object:Gem::Dependency
-  name: rest-client
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  prerelease: false
   type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Ruby client for metamx druid
 email:
 - opensource@liquidm.com
@@ -46,8 +46,9 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
@@ -62,6 +63,7 @@ files:
 - lib/druid/post_aggregation.rb
 - lib/druid/query.rb
 - lib/druid/response_row.rb
+- lib/druid/serializable.rb
 - lib/druid/zoo_handler.rb
 - ruby-druid.gemspec
 - spec/lib/client_spec.rb
@@ -72,24 +74,24 @@ homepage: https://github.com/liquidm/ruby-druid
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.2.2
-signing_key:
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
 specification_version: 4
 summary: Ruby client for metamx druid
 test_files:
@@ -97,4 +99,4 @@ test_files:
 - spec/lib/query_spec.rb
 - spec/lib/zoo_handler_spec.rb
 - spec/spec_helper.rb
-has_rdoc:
+has_rdoc: