cubicle 0.1.2 → 0.1.3

data/lib/cubicle/data.rb

@@ -1,84 +1,29 @@
-module Cubicle
-  class Data < Array
-
-    attr_reader :dimension_names, :measure_names, :total_count
-
-    def initialize(query,query_results,total_count = nil)
-      @dimension_names = query.dimensions.map{|d|d.name}
-      @measure_names = query.measures.map{|m|m.name}
-      @time_dimension_name = query.time_dimension.name if query.respond_to?(:time_dimension) && query.time_dimension
-      @time_period = query.time_period if query.respond_to?(:time_period)
-      @time_range = query.time_range if query.respond_to?(:time_range)
-      extract_data(query_results)
-      @total_count = total_count if total_count
-    end
-
-    def hierarchize(*args)
-      args = [@time_dimension_name || @dimension_names].flatten if args.blank?
-      extract_dimensions args, self
-    end
-    alias hierarchize_by hierarchize
-    alias by hierarchize
-
-    def records_per_page=(records_per_page)
-      @records_per_page=records_per_page
-    end
-
-    def total_pages
-      if (!defined?(@total_count))
-        raise "Cannot find the total number of pages without setting the total count"
-      end
-
-      if (!defined?(@records_per_page))
-        raise "Cannot find the total number of pages without setting the number of records per page"
-      end
-
-      (@total_count.to_f / @records_per_page.to_f).ceil
-    end
-
-    private
-
-    def extract_dimensions(dimension_names, data)
-      data, dimension_names = data.dup, dimension_names.dup
-
-      return data.map{|measures|Cubicle::DataLevel.new(:measures,measures)} if dimension_names.blank?
-
-      dim_name = dimension_names.shift
-
-      result = Cubicle::DataLevel.new(dim_name)
-      data.each do |tuple|
-        member_name = tuple.delete(dim_name.to_s) || "Unknown"
-        result[member_name] << tuple
-      end
-
-      result.each do |key,value|
-        result[key] = extract_dimensions(dimension_names,value)
-      end
-
-      expand_time_dimension_if_required(result)
-
-      result
-    end
-
-    def extract_data(data)
-      data.each do |result|
-        new = result.dup
-        self << new.delete("_id").merge(new.delete("value"))
-      end
-    end
-
-    def expand_time_dimension_if_required(data_level)
-      return unless data_level.leaf_level? && @time_dimension_name && @time_dimension_name.to_s == data_level.name.to_s &&
-              @time_range && @time_period
-
-      @time_range.by!(@time_period)
-
-      @time_range.each do |date|
-        formatted_date = date.to_cubicle(@time_period)
-        data_level[formatted_date] = [Cubicle::DataLevel.new(:measures,{})] unless data_level.include?(formatted_date)
-      end
-      data_level.keys.sort!
-    end
-  end
-end
-
+module Cubicle
+  module Data
+
+    def self.aggregate(data,measures)
+      aggregated = OrderedHashWithIndifferentAccess.new {|hash,key|hash[key]=[]}
+      #in step one, we will gather our values into columns to give to the measure
+      #definitions to aggregation.
+      data.each do |row|
+        measures.each do |measure|
+          if (row.include?(measure.name))
+            val = row[measure.name]
+            aggregated[measure.name] << val if val.kind_of?(Numeric)
+          end
+        end
+      end
+      #in step two, we will let the measures reduce the columns of values to a single number, preferably using
+      #black magic or human sacrifice
+      measures.each do |measure|
+        aggregated[measure.name] = measure.aggregate(aggregated[measure.name])
+      end
+
+      #give each measure a final shot to operate on the results. This is useful for measures that
+      #act on the results of other aggregations, like Ratio does.
+      measures.each {|measure|measure.finalize_aggregation(aggregated)}
+      aggregated
+    end
+
+  end
+end

data/lib/cubicle/data/hierarchy.rb

@@ -0,0 +1,55 @@
+module Cubicle
+  module Data
+    class Hierarchy < Cubicle::Data::Level
+      include Member
+
+      attr_reader :measures
+      def initialize(root_dimension,measures)
+        super(root_dimension)
+        @measures = measures
+        @member_name = name
+      end
+
+      def self.hierarchize_table(table, dimension_names=nil)
+        dimension_names = [table.time_dimension_name || table.dimension_names].flatten if dimension_names.blank?
+        Cubicle::Data::Hierarchy.extract_dimensions(dimension_names,table,table.dup)
+      end
+      private
+
+      def self.extract_dimensions(dimension_names, data, table,parent_level=nil)
+        data, dimension_names = data.dup, dimension_names.dup
+
+        return data if dimension_names.blank?
+
+        dim_name = dimension_names.shift
+        dim = table.dimensions.find{|d|d.name==dim_name}
+        level = parent_level ? Cubicle::Data::Level.new(dim,parent_level) : Cubicle::Data::Hierarchy.new(dim,data.measures)
+        data.each do |tuple|
+          member_name = tuple.delete(dim_name.to_s) || "Unknown"
+          level[member_name] << tuple
+        end
+
+        level.each do |key,value|
+          level[key] = Cubicle::Data::Hierarchy.extract_dimensions(dimension_names,value,table,level)
+        end
+
+        Cubicle::Data::Hierarchy.expand_time_dimension_if_required(level,table)
+
+        level
+      end
+
+      def self.expand_time_dimension_if_required(data_level,table)
+        return unless data_level.leaf_level? && table.time_dimension_name && table.time_dimension_name.to_s == data_level.name.to_s &&
+                table.time_range && table.time_period
+
+        table.time_range.by!(table.time_period)
+
+        table.time_range.each do |date|
+          formatted_date = date.to_cubicle(table.time_period)
+          data_level[formatted_date] = [OrderedHashWithIndifferentAccess.new] unless data_level.include?(formatted_date)
+        end
+        data_level.keys.sort!
+      end
+    end
+  end
+end

data/lib/cubicle/data/level.rb

@@ -0,0 +1,62 @@
+module Cubicle
+  module Data
+    class Level < OrderedHashWithIndifferentAccess
+
+      def initialize(dimension,parent_level=nil)
+        @dimension = dimension
+        @parent_level = parent_level
+        super() {|hash,key|hash[key]=[]}#Always have an array freshly baked when strangers call
+      end
+
+      attr_reader   :dimension, :parent_level
+      attr_accessor :missing_member_default
+
+      alias member_names keys
+      alias members values
+
+      def name
+        @dimension.name
+      end
+
+      def flatten(member_name = nil, opts={}, &block)
+
+        default_val = opts[:default] || @missing_member_default || 0
+
+        self.values.inject([]) do |output, data|
+          data.inject(output) do |flattened, value|
+            value.missing_member_default = default_val if value.respond_to?(:missing_member_default)
+
+            if block_given?
+              flat_val = block.arity == 1 ? (yield value) : (value.instance_eval(&block))
+            end
+            flat_val ||= value[member_name] if member_name && value.include?(member_name)
+            flat_val ||= default_val
+            flattened << flat_val
+          end
+        end
+      end
+
+      def leaf_level?
+        return self.length < 1 ||
+                !self[self.keys[0]].is_a?(Cubicle::Data::Level)
+      end
+
+      def []=(key,val)
+        prepare_level_member(val,key,self)
+        super(key.to_s,val)
+      end
+
+      def hierarchy
+        parent_level || self
+      end
+            
+      private
+      def prepare_level_member(member,member_name,parent_level)
+        member.class_eval("include Cubicle::Data::Member")
+        member.member_name = member_name
+        member.parent_level = parent_level
+      end
+
+    end
+  end
+end

data/lib/cubicle/data/member.rb

@@ -0,0 +1,28 @@
+module Cubicle
+  module Data
+    module Member
+      attr_accessor :member_name, :parent_level
+
+      def measure_values
+        @measure_values ||= aggregate_children()
+      end
+
+      def leaf_member?
+        !self.kind_of?(Cubicle::Data::Level)
+      end
+
+      def measures
+        parent_level.hierarchy.measures
+      end
+
+      def measure_data
+        leaf_member? ? self : members.map{|member|member.aggregate_children}
+      end
+
+      def aggregate_children()
+        Cubicle::Data.aggregate(measure_data,measures)
+      end
+
+    end
+  end
+end

data/lib/cubicle/data/table.rb

@@ -0,0 +1,56 @@
+module Cubicle
+  module Data
+    class Table < Array
+      attr_reader :total_count, :dimensions, :measures, :time_dimension_name, :time_range, :time_period
+
+      def initialize(query,query_results,total_count = nil)
+        @dimensions = Marshal.load(Marshal.dump(query.dimensions))
+        @measures   = Marshal.load(Marshal.dump(query.measures))
+        @time_dimension_name = query.time_dimension.name if query.respond_to?(:time_dimension) && query.time_dimension
+        @time_period = query.time_period if query.respond_to?(:time_period)
+        @time_range = query.time_range if query.respond_to?(:time_range)
+        extract_data(query_results)
+        @total_count = total_count if total_count
+      end
+
+      def dimension_names
+        @dimensions.map{|d|d.name}
+      end
+
+      def measure_names
+        @measures.map{|m|m.name}
+      end
+
+      def hierarchize(*args)
+        Cubicle::Data::Hierarchy.hierarchize_table(self,args)
+      end
+      alias hierarchize_by hierarchize
+      alias by hierarchize
+
+      def records_per_page=(records_per_page)
+        @records_per_page=records_per_page
+      end
+
+      def total_pages
+        if (!defined?(@total_count))
+          raise "Cannot find the total number of pages without setting the total count"
+        end
+
+        if (!defined?(@records_per_page))
+          raise "Cannot find the total number of pages without setting the number of records per page"
+        end
+
+        (@total_count.to_f / @records_per_page.to_f).ceil
+      end
+
+      private
+
+      def extract_data(data)
+        data.each do |result|
+          new = result.dup
+          self << OrderedHashWithIndifferentAccess.new(new.delete("_id").merge(new.delete("value")))
+        end
+      end
+    end
+  end
+end

data/lib/cubicle/measure.rb

@@ -1,20 +1,30 @@
-module Cubicle
-  class Measure < Member
-
-    def initialize(*args)
-      super
-      @aggregation_method = self.options.delete(:aggregation_method) || default_aggregation_method
-    end
-
-    attr_accessor :aggregation_method #can be :sum, :average, :count
-
-    def to_js_value
-      return super unless aggregation_method == :count
-      "((#{super}) ? 1 : 0)"
-    end
-
-    def default_aggregation_method
-      :count
-    end
-  end
-end
+module Cubicle
+  class Measure < Member
+
+    def initialize(*args)
+      super
+      @aggregation_method = self.options.delete(:aggregation_method) || default_aggregation_method
+    end
+
+    attr_accessor :aggregation_method #can be :sum, :average, :count
+
+    def to_js_value
+      return super unless aggregation_method == :count
+      "((#{super}) ? 1 : 0)"
+    end
+
+    def default_aggregation_method
+      :count
+    end
+
+    def aggregate(values)
+      return nil if values.blank?
+      sum = values.inject(0){|total,val|total+val}
+      aggregation_method == :average ? sum/values.length : sum
+    end
+
+    def finalize_aggregation(aggregation)
+      aggregation
+    end
+  end
+end

data/lib/cubicle/mongo_mapper/aggregate_plugin.rb

@@ -3,7 +3,7 @@ module Cubicle
     module AggregatePlugin
       module ClassMethods
         def aggregate(&block)
-          return Cubicle::Aggregation.new(self.collection_name,&block)
+          return Cubicle::Aggregation::AdHoc.new(self.collection_name,&block)
         end
       end
 

data/lib/cubicle/ordered_hash_with_indifferent_access.rb

@@ -0,0 +1,27 @@
+class OrderedHashWithIndifferentAccess < OrderedHash
+  def initialize(initial_data={},&block)
+    merge!(initial_data.stringify_keys)
+    super(&block) if block
+  end
+
+
+  def [](key)
+      key = key.to_s
+      #self[key] = [] unless self.keys.include?(key)
+      super(key)
+    end
+
+    def []=(key,val)
+      super(key.to_s,val)
+    end
+
+    def include?(key)
+      super(key.to_s)
+    end
+
+   def method_missing(sym,*args,&block)
+      return self[sym.to_s[0..-2]] = args[0] if sym.to_s =~ /.*=$/
+      return self[sym] if self.keys.include?(sym.to_s)
+      missing_member_default
+    end
+end

data/lib/cubicle/query.rb

@@ -1,14 +1,16 @@
 module Cubicle
   class Query
+    include Dsl
 
-    attr_reader  :time_period, :transient
+    attr_reader  :time_period, :transient, :aggregation
     attr_accessor :source_collection_name
-    def initialize(cubicle)
-      @cubicle = cubicle
+    
+    def initialize(aggregation)
+      @aggregation = aggregation
 
       @dimensions = Cubicle::MemberList.new
       @measures = Cubicle::MemberList.new
-      @source_collection_name = @cubicle.target_collection_name
+      @source_collection_name = @aggregation.target_collection_name
       @where, @from_date, @to_date, @date_dimension, @time_period, @limit, @offset = nil
       @all_dimensions, @all_measures = false, false
       @transient = false
@@ -16,31 +18,24 @@ module Cubicle
       @order_by=[]
       @from_date_filter = "$gte"
       @to_date_filter = "$lte"
+      @query_aliases=HashWithIndifferentAccess.new
     end
 
     def clone
       Marshal.load(Marshal.dump(self))
     end
 
-    def select_all
-      select :all_dimensions, :all_measures
-    end
-
     def selected?(member = nil)
       return (@dimensions.length > 0 || @measures.length > 0) unless member
-      member_name = member.kind_of?(Cubicle::Member) ? member.name : member.to_s
+      member_name = member.kind_of?(Cubicle::Member) ? member.name : unalias(member.to_s)
       return @dimensions[member_name] ||
               @measures[member_name]
     end
 
     def transient?
-      @transient || @cubicle.transient?
+      @transient || @aggregation.transient?
     end
 
-    def transient!
-      @transient = true
-      @source_collection_name = nil
-    end
 
     def all_measures?
       @all_measures
@@ -48,183 +43,7 @@ module Cubicle
 
     def all_dimensions?
       @all_dimensions
-    end
-
-    def select(*args)
-      args = args[0] if args[0].is_a?(Array)
-
-      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 = @cubicle.dimensions[member_name])
-            @dimensions << convert_dimension(member)
-          elsif (member = @cubicle.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
-
-      #We'll need these in the result set
-      select *args
-
-      #replace any alias names with actual member names
-      @by = args.map{|member_name|@cubicle.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 (@cubicle.time_dimension && time_dimension.included_in?(args))
-        time_dimension(@cubicle.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) ? order : [order,:asc])
-      end
-    end
-
-    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 ||= @cubicle.time_dimension) unless dimension
-      @time_dimension = dimension.is_a?(Cubicle::Dimension) ? dimension : @cubicle.dimensions[dimension]
-      raise "No dimension matching the name #{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
-
-    def where(filter = nil)
-      return prepare_filter unless filter
-      (@where ||= {}).merge!(filter)
-      self
-    end
+    end  
 
     def dimension_names
       return dimensions.map{|dim|dim.name.to_s}
@@ -236,16 +55,16 @@ module Cubicle
 
     def dimensions
       return @dimensions unless all_dimensions?
-      @cubicle.dimensions.collect{|dim|convert_dimension(dim)}
+      @aggregation.dimensions.collect{|dim|convert_dimension(dim)}
     end
 
     def measures
       return @measures unless all_measures?
-      @cubicle.measures.collect{|measure|convert_measure(measure)}
+      @aggregation.measures.collect{|measure|convert_measure(measure)}
     end
 
     def execute(options={})
-      @cubicle.execute_query(self,options)
+      @aggregation.execute_query(self,options)
     end
 
     private
@@ -315,5 +134,13 @@ module Cubicle
       Cubicle::Measure.new(measure.name, :expression=>expression,:aggregation_method=>aggregation)
     end
 
+    def unalias(*name_or_names)
+      return (@query_aliases[name_or_names[0]] || name_or_names[0]) unless
+               name_or_names.length > 1 || name_or_names[0].is_a?(Array)
+
+      name_or_names = name_or_names[0] if name_or_names[0].is_a?(Array)
+      name_or_names.map {|name|@query_aliases[name] || name}
+    end
+
   end
 end