cubicle 0.1.2 → 0.1.3

data/lib/cubicle/query/dsl.rb

@@ -0,0 +1,118 @@
+module Cubicle
+  class Query
+    module Dsl
+      include TimeIntelligence
+      def select_all
+        select :all_dimensions, :all_measures
+      end
+
+      def transient!
+        @transient = true
+        @source_collection_name = nil
+      end
+
+      def select(*args)
+        args = unalias(args[0].is_a?(Array) ? args[0] : args)
+        if (args.include?(:all))
+          select_all
+          return
+        end
+
+        if (args.include?(:all_measures))
+          @all_measures = true
+          @measures = Cubicle::MemberList.new
+        end
+        if (args.include?(:all_dimensions))
+          @all_dimensions = true
+          @dimensions = Cubicle::MemberList.new
+        end
+
+        return if args.length == 1 && selected?(args[0])
+
+        found=[:all_measures,:all_dimensions]
+
+        if args.length == 1 && !all_dimensions? && args[0].is_a?(Cubicle::Dimension)
+          @dimensions << convert_dimension(args.pop)
+        elsif args.length == 1 && !all_measures? && args[0].is_a?(Cubicle::Measure)
+          @measures << convert_measure(args.pop)
+        else
+          #remove from the list any dimensions or measures that are already
+          #selected. This allows select to be idempotent,
+          #which is useful for ensuring certain members are selected
+          #even though the user may already have selected them previously
+          args.each do |member_name|               
+            if (member = @aggregation.dimensions[member_name])
+              @dimensions << convert_dimension(member)
+            elsif (member = @aggregation.measures[member_name])
+              @measures << convert_measure(member)
+            end
+            found << member_name if member || selected?(member_name)
+          end
+        end
+        args = args - found
+        raise "You selected one or more members that do not exist in the underlying data source:#{args.inspect}" unless args.blank?
+        self
+      end
+
+      def limit(in_limit = nil)
+        return @limit unless in_limit
+        @limit = in_limit
+        return self
+      end
+
+      def offset(in_offset = nil)
+        return @offset unless in_offset
+        @offset = in_offset
+        return self
+      end
+      alias skip offset
+
+      def by(*args)
+        return @by unless args.length > 0
+        #Resolve any query level aliases
+        args = unalias(args)
+        #We'll need these in the result set
+        select *args
+        #replace any alias names with actual member names
+        @by = args.map{|member_name|@aggregation.find_member(member_name).name}
+        return if @time_dimension #If a time dimension has been explicitly specified, the following isn't helpful.
+
+        #Now let's see if we can find ourselves a time dimension
+        if (@aggregation.time_dimension && time_dimension.included_in?(args))
+          time_dimension(@aggregation.time_dimension)
+        else
+          args.each do |by_member|
+            if (detected = detect_time_period by_member)
+              time_dimension by_member
+              @time_period = detected
+              break
+            end
+          end
+        end
+      end
+
+      def order_by(*args)
+        return @order_by unless args.length > 0
+        args.each do |order|
+          @order_by << (order.is_a?(Array) ? [unalias(order[0]),order[1]] : [unalias(order),:asc])
+        end
+        self
+      end
+
+      def where(filter = nil)
+        return prepare_filter unless filter
+        filter.each do |key,value|
+          (@where ||= {})[unalias(key)] = value
+        end
+        self
+      end
+
+      def alias_member(alias_hash)
+        alias_hash.each {|key,value|@query_aliases[value] = key}
+        self
+      end
+      alias alias_members alias_member
+    end
+  end
+
+end

data/lib/cubicle/query/dsl/time_intelligence.rb

@@ -0,0 +1,89 @@
+module Cubicle
+  class Query
+    module Dsl
+      module TimeIntelligence
+        def time_range(date_range = nil)
+          return nil unless date_range || @from_date || @to_date
+          unless date_range
+            start,stop = @from_date || Time.now, @to_date || Time.now
+            return @to_date_filter=="$lte" ? start..stop : start...stop
+          end
+
+          @to_date_filter = date_range.exclude_end? ? "$lt" : "$lte"
+          @from_date, @to_date = date_range.first, date_range.last if date_range
+        end
+
+        def time_dimension(dimension = nil)
+          return (@time_dimension ||= @aggregation.time_dimension) unless dimension
+          @time_dimension = dimension.is_a?(Cubicle::Dimension) ? dimension : @aggregation.dimensions[unalias(dimension)]
+          raise "No dimension matching the name #{unalias(dimension)} could be found in the underlying data source" unless @time_dimension
+          #select @time_dimension unless selected?(dimension)
+        end
+        alias date_dimension time_dimension
+
+        def last(duration,as_of = Time.now)
+          duration = 1.send(duration) if [:year,:month,:week,:day].include?(duration)
+          period = duration.parts[0][0]
+          @from_date = duration.ago(as_of).advance(period=>1)
+          @to_date = as_of
+        end
+        alias for_the_last last
+
+        def last_complete(duration,as_of = Time.now)
+          duration = 1.send(duration) if [:year,:month,:week,:day].include?(duration)
+          period = duration.parts[0][0]
+          @to_date = as_of.beginning_of(period)
+          @from_date = duration.ago(@to_date)
+          @to_date_filter = "$lt"
+        end
+        alias for_the_last_complete last_complete
+
+        def next(duration,as_of = Time.now)
+          duration = 1.send(duration) if [:year,:month,:week,:day].include?(duration)
+          period = duration.parts[0][0]
+          @to_date = duration.from_now(as_of).advance(period=>-1)
+          @from_date = as_of
+        end
+        alias for_the_next next
+
+        def this(period,as_of = Time.now)
+          @from_date = as_of.beginning_of(period)
+          @to_date = as_of
+          self
+        end
+
+        def from(time = nil)
+          return @from_date unless time
+          @from_date = if time.is_a?(Symbol)
+            Time.send(time) if Time.respond_to?(time)
+            Date.send(time).to_time if Date.respond_to?(time)
+          else
+            time.to_time
+          end
+          self
+        end
+
+        def until(time = nil)
+          return @to_date unless time
+          @to_date = if time.is_a?(Symbol)
+            Time.send(time) if Time.respond_to?(time)
+            Date.send(time).to_time if Date.respond_to?(time)
+          else
+            time.to_time
+          end
+          self
+        end
+
+        def ytd(as_of = Time.now)
+          this :year, as_of
+        end
+        alias year_to_date ytd
+
+        def mtd(as_of = Time.now)
+          this :month, as_of
+        end
+        alias month_to_date mtd
+      end
+    end
+  end
+end

data/lib/cubicle/ratio.rb

@@ -1,12 +1,28 @@
-module Cubicle
-  class Ratio < CalculatedMeasure
-
-    attr_reader :numerator, :denominator
-    def initialize(member_name,numerator,denominator,opts={})
-      @numerator, @denominator = numerator, denominator
-      opts[:expression]="(value.#{denominator} > 0 && value.#{numerator} ? value.#{numerator}/value.#{denominator} : 0)"
-      super(member_name,opts)
-    end
-
-  end
-end
+module Cubicle
+  class Ratio < CalculatedMeasure
+
+    attr_reader :numerator, :denominator
+    def initialize(member_name,numerator,denominator,opts={})
+      @numerator, @denominator = numerator, denominator
+      opts[:expression]="(value.#{denominator} > 0 && value.#{numerator} ? value.#{numerator}/value.#{denominator} : 0)"
+      super(member_name,opts)
+    end
+
+    def aggregate(values)
+      0
+    end
+
+    def finalize_aggregation(aggregation)
+      n = aggregation[numerator].to_f
+      d = aggregation[denominator].to_f
+
+      #If the numerator is greater than zero, when we'll do the division
+      #even if d is zero. This will result in a NaN, which indicates something
+      #wrong with the data, which is fine. However, if the numerator is zero,
+      #then maybe there just isn't any data, in which case NaN is pretty pessimistic -
+      #we'll return 0 instead in this case.
+      aggregation[name] = n > 0 ? n/d : 0
+    end
+
+  end
+end

data/lib/cubicle/version.rb

@@ -1,3 +1,3 @@
-module Cubicle
-  VERSION = '0.1.2'
+module Cubicle
+  VERSION = '0.1.3'
 end

data/test/cubicle/aggregation/ad_hoc_test.rb

@@ -0,0 +1,21 @@
+require "test_helper"
+
+class AdHocTest < ActiveSupport::TestCase
+  context "Executing an ad hoc query via an aggregation" do
+    setup do
+      Defect.create_test_data
+      @results =  Cubicle::Aggregation::AdHoc.new("defects") do
+        dimension :product, :field_name=>"product.name"
+        count :total, :field_name=>"defect_id"
+      end.query
+    end
+    should "return appropriately aggregated data" do
+      assert_equal "Brush Fire Bottle Rockets", @results[0]["product"]
+      assert_equal 1, @results[0]["total"]
+      assert_equal "Evil's Pickling Spice", @results[1]["product"]
+      assert_equal 1, @results[1]["total"]
+      assert_equal "Sad Day Moonshine", @results[2]["product"]
+      assert_equal 3, @results[2]["total"]
+    end
+  end
+end

data/test/cubicle/cubicle_aggregation_test.rb

@@ -1,21 +1,85 @@
-require "test_helper"
-
-class AggregationTest < ActiveSupport::TestCase
-  context "Executing an ad hoc query via an aggregation" do
-    setup do
-      Defect.create_test_data
-      @results =  Cubicle::Aggregation.new("defects") do
-        dimension :product, :field_name=>"product.name"
-        count :total, :field_name=>"defect_id"
-      end.query
-    end
-    should "return appropriately aggregated data" do
-      assert_equal "Brush Fire Bottle Rockets", @results[0]["product"]
-      assert_equal 1, @results[0]["total"]
-      assert_equal "Evil's Pickling Spice", @results[1]["product"]
-      assert_equal 1, @results[1]["total"]
-      assert_equal "Sad Day Moonshine", @results[2]["product"]
-      assert_equal 3, @results[2]["total"]
-    end
-  end
+require "test_helper"
+
+class CubicleAggregationTest < ActiveSupport::TestCase
+
+  context "Given a query with several dimensions and measures" do
+    context "Cubicle#select" do
+      setup do
+        Defect.create_test_data
+      end
+      context "without arguments" do
+        setup do
+          @results = DefectCubicle.query
+        end
+        should "return a collection of appropriate aggregated values based on the cubicle parameters" do
+          assert_equal 4, @results.length
+
+          assert_equal "2009-12-09", @results[0]["manufacture_date"]
+          assert_equal "2009-12", @results[0]["month"]
+          assert_equal "2009", @results[0]["year"]
+          assert_equal "Brush Fire Bottle Rockets", @results[0]["product"]
+          assert_equal "South", @results[0]["region"]
+          assert_equal "Buddy", @results[0]["operator"]
+          assert_equal "Repaired", @results[0]["outcome"]
+          assert_equal 1, @results[0]["total_defects"]
+          assert_equal 0, @results[0]["preventable_defects"]
+          assert_equal 0.43, @results[0]["total_cost"]
+          assert_equal 0.43, @results[0]["avg_cost"]
+          assert_equal 0, @results[0]["preventable_pct"]
+
+          assert_equal "2010-01-01", @results[1]["manufacture_date"]
+          assert_equal "2010-01", @results[1]["month"]
+          assert_equal "2010", @results[1]["year"]
+          assert_equal "Sad Day Moonshine", @results[1]["product"]
+          assert_equal "West", @results[1]["region"]
+          assert_equal "Franny", @results[1]["operator"]
+          assert_equal "Repaired", @results[1]["outcome"]
+          assert_equal 2, @results[1]["total_defects"]
+          assert_equal 1, @results[1]["preventable_defects"]
+          assert_in_delta 12.97, @results[1]["total_cost"], 0.0001
+          assert_in_delta 6.485, @results[1]["avg_cost"],0.0001
+          assert_equal 0.5, @results[1]["preventable_pct"]
+
+          assert_equal "2010-01-05", @results[2]["manufacture_date"]
+          assert_equal "2010-01", @results[2]["month"]
+          assert_equal "2010", @results[2]["year"]
+          assert_equal "Evil's Pickling Spice", @results[2]["product"]
+          assert_equal "Midwest", @results[2]["region"]
+          assert_equal "Seymour", @results[2]["operator"]
+          assert_equal "Discarded", @results[2]["outcome"]
+          assert_equal 1, @results[2]["total_defects"]
+          assert_equal 1, @results[2]["preventable_defects"]
+          assert_equal 0.02, @results[2]["total_cost"]
+          assert_equal 0.02, @results[2]["avg_cost"]
+          assert_equal 1, @results[2]["preventable_pct"]
+
+          assert_equal "2010-02-01", @results[3]["manufacture_date"]
+          assert_equal "2010-02", @results[3]["month"]
+          assert_equal "2010", @results[3]["year"]
+          assert_equal "Sad Day Moonshine", @results[3]["product"]
+          assert_equal "West", @results[3]["region"]
+          assert_equal "Zooey", @results[3]["operator"]
+          assert_equal "Consumed", @results[3]["outcome"]
+          assert_equal 1, @results[3]["total_defects"]
+          assert_equal 1, @results[3]["preventable_defects"]
+          assert_equal 2.94, @results[3]["total_cost"]
+          assert_equal 2.94, @results[3]["avg_cost"]
+          assert_equal 1, @results[3]["preventable_pct"]
+        end
+      end
+      
+      context "Processing a cube" do
+        setup do
+          DefectCubicle.expire!
+          DefectCubicle.process
+        end
+        should "should create the specified aggregations" do
+          assert Cubicle.mongo.database.collection_names.include? "defect_cubicles_cubicle_aggregation_month.product.year"
+          assert Cubicle.mongo.database.collection_names.include? "defect_cubicles_cubicle_aggregation_month.region"
+        end
+
+      end
+    end
+  end
+
 end

data/test/cubicle/cubicle_query_test.rb

@@ -351,5 +351,41 @@ class CubicleQueryTest < ActiveSupport::TestCase
         Cubicle::DateTime.db_time_format = :iso8601
       end
     end
+    context "when a query level alias has been specified" do
+      should "respect the alias in the by clause" do
+        query_results = DefectCubicle.query do
+          alias_member :date=>:my_crazy_date
+          select :all_measures
+          by :my_crazy_date
+        end
+        assert_equal :manufacture_date, query_results.name
+        assert_equal "2009-12-09", query_results.member_names[0]
+      end
+      should "respect the alias in the where clause" do
+        results = DefectCubicle.query do
+          alias_member :product=>:my_crazy_product
+          select :product, :all_measures
+          where  :my_crazy_product=>"Sad Day Moonshine"
+        end
+        assert_equal 1, results.length
+        assert_equal "Sad Day Moonshine", results[0]["product"]
+        assert_equal 3, results[0]["total_defects"]
+        assert_equal 2, results[0]["preventable_defects"]
+        assert_in_delta 15.91, results[0]["total_cost"],0.0001
+        assert_in_delta 15.91/3, results[0]["avg_cost"],0.0001
+        assert_in_delta 2/3.0, results[0]["preventable_pct"],0.0001
+      end
+      should "respect the alias in the order by clause" do
+        results = DefectCubicle.query do
+          alias_member :product=>:my_crazy_product
+          select :product,:all_measures
+          order_by [:my_crazy_product, :desc]
+        end
+        assert_equal 3, results.length
+        assert_equal "Sad Day Moonshine", results[0]["product"]
+        assert_equal "Evil's Pickling Spice", results[1]["product"]
+        assert_equal "Brush Fire Bottle Rockets", results[2]["product"]
+      end
+    end
   end
 end

data/test/cubicle/data/data_test.rb

@@ -0,0 +1,30 @@
+require "test_helper"
+
+class DataTest < ActiveSupport::TestCase
+  context "Data#aggregate" do
+    should "Aggregate a given table of numbers according to the provided measures" do
+      #[{"m1"=>1.0, "m2"=>1.0, "m3"=>1.0}, {"m1"=>2.0, "m2"=>3.0, "m3"=>4.0}, {"m1"=>3.0, "m2"=>5.0, "m3"=>7.0}]
+      data=3.times.inject([]) do |set,index|
+        set << HashWithIndifferentAccess.new({:m1=>1.0 * index+1, :m2=>2.0 * index+1, :m3=>3.0 * index+1})
+      end
+      measures = [Cubicle::Measure.new(:m1, :aggregation_method=>:sum),
+                  Cubicle::Measure.new(:m2, :aggregation_method=>:count),
+                  Cubicle::Measure.new(:m3, :aggregation_method=>:average)]
+      aggregation = Cubicle::Data.aggregate(data,measures)
+      assert_equal 6.0, aggregation[:m1]
+      assert_equal 9.0, aggregation[:m2]
+      assert_equal 4.0, aggregation[:m3]
+    end
+    should "Finalize the aggregation" do
+      #[{"m1"=>1.0, "m2"=>1.0}, {"m1"=>2.0, "m2"=>3.0}, {"m1"=>3.0, "m2"=>5.0}]
+      data=3.times.inject([]) do |set,index|
+        set << HashWithIndifferentAccess.new({:m1=>1.0 * index+1, :m2=>2.0 * index+1})
+      end
+      measures = [Cubicle::Measure.new(:m1, :aggregation_method=>:sum),
+                  Cubicle::Measure.new(:m2, :aggregation_method=>:count),
+                  Cubicle::Ratio.new(:m3, :m1, :m2)]
+      aggregation = Cubicle::Data.aggregate(data,measures)
+      assert_equal 6.0/9.0, aggregation[:m3]
+    end
+  end
+end