cubicle 0.1.0

data/lib/cubicle/aggregation.rb

@@ -0,0 +1,10 @@
+module Cubicle
+  class Aggregation
+    include Cubicle
+    def initialize(source_collection,&block)
+      transient!
+      source_collection_name source_collection
+      instance_eval(&block) if block_given?
+    end
+  end
+end

data/lib/cubicle/calculated_measure.rb

@@ -0,0 +1,18 @@
+module Cubicle
+  class CalculatedMeasure < Measure
+
+    def initialize(*args)
+      opts = args.extract_options!
+      opts[:aggregation_method] = :calculation
+      args << opts
+      super(*args)
+    end
+    #calculated members to not participate in the map/reduce
+    #cycle. They are a finalization-time only
+    #concept.
+    def to_js_keys
+      []
+    end
+
+  end
+end

data/lib/cubicle/data.rb

@@ -0,0 +1,84 @@
+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
+

data/lib/cubicle/data_level.rb

@@ -0,0 +1,60 @@
+module Cubicle
+  class DataLevel < OrderedHash
+
+    def initialize(name = "Unknown Level", initial_data = {})
+      @name = name
+      merge!(initial_data.stringify_keys)
+    end
+
+    attr_reader :name
+    attr_accessor :missing_member_default
+
+    alias member_names keys
+
+    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 flatten(member_name = nil, opts={}, &block)
+
+      default_val = opts[:default] || @missing_member_default || 0
+
+      self.inject([]) do |output, (key, 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::DataLevel)
+    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
+end

data/lib/cubicle/date_time.rb

@@ -0,0 +1,33 @@
+module Cubicle
+  module DateTime
+    def self.db_time_format
+      @time_format ||= :iso8601 #or :native || :time || anything not :iso8601
+    end
+
+    def self.db_time_format=(time_format)
+      raise "db_time_format must be :iso8601 or :native" unless [:iso8601,:native].include?(time_format)
+      @time_format=time_format
+    end
+
+    def self.iso8601?
+      self.db_time_format == :iso8601
+    end
+
+    def iso8601?
+      Cubicle::DateTime.iso8601?
+    end
+
+    def to_cubicle(period = :date)
+      case period
+        when :year, :years then iso8601? ? self.strftime('%Y') : beginning_of_year
+        when :quarter, :quarters then iso8601? ? "#{db_year}-Q#{(month+2) / 3}" : beginning_of_quarter
+        when :month, :months then iso8601? ? self.strftime('%Y-%m') : beginning_of_month
+        else iso8601? ? self.strftime('%Y-%m-%d') : self
+      end
+    end
+
+    def beginning_of(period)
+      self.send "beginning_of_#{period.to_s.singularize}"
+    end
+  end
+end

data/lib/cubicle/dimension.rb

@@ -0,0 +1,4 @@
+module Cubicle
+  class Dimension < Member
+  end
+end

data/lib/cubicle/measure.rb

@@ -0,0 +1,16 @@
+module Cubicle
+  class Measure < Member
+
+    def initialize(*args)
+      super
+      @aggregation_method = self.options.delete(:aggregation_method) || :count
+    end
+
+    attr_accessor :aggregation_method #can be :sum, :average, :count
+
+    def to_js_value
+      return super unless aggregation_method == :count
+      "((#{super}) ? 1 : 0)"
+    end
+  end
+end

data/lib/cubicle/member.rb

@@ -0,0 +1,53 @@
+module Cubicle
+  class Member
+
+    attr_accessor :name,
+                  :expression,
+                  :expression_type, #can be :field_name, :javascript
+                  :options,
+                  :alias_list
+
+    def initialize(*args)
+      opts = args.extract_options!
+      @name = args.shift.to_sym
+
+      self.options = (opts || {}).symbolize_keys
+
+      if (@expression = self.options.delete(:field_name))
+        @expression_type = :field_name
+      elsif (@expression = self.options.delete(:expression))
+        @expression_type = :javascript
+      else
+        @expression = @name
+        @expression_type = :field_name
+      end
+
+      member_alias = self.options[:alias]
+      if (member_alias)
+        member_alias = [member_alias] unless member_alias.is_a?(Array)
+        @alias_list = member_alias.map{|a|a.to_s}
+      end
+
+    end
+
+    def matches(member_name)
+      return name.to_s == member_name.to_s || (@alias_list||=[]).include?(member_name.to_s)
+    end
+
+    def included_in?(list_of_member_names)
+      list_of_member_names.each do |member_name|
+        return true if matches(member_name)
+      end
+      false
+    end
+
+    def to_js_keys
+      ["#{name}:#{to_js_value}"]
+    end
+
+    def to_js_value
+      prefix, suffix = expression_type == :field_name ? ['this.',''] : ['(',')']
+      "#{prefix}#{expression}#{suffix}"
+    end
+  end
+end

data/lib/cubicle/member_list.rb

@@ -0,0 +1,11 @@
+module Cubicle
+  class MemberList < Array
+    def [](member_name)
+      if (member_name.is_a?(Integer))
+        return super(member_name)
+      end
+      self.find{|m|m.matches(member_name)}
+    end
+    #Code here
+  end
+end

data/lib/cubicle/mongo_environment.rb

@@ -0,0 +1,102 @@
+module Cubicle
+  class MongoEnvironment
+
+    # @api public
+    def self.connection
+      @@connection ||= Mongo::Connection.new
+    end
+
+    # @api public
+    def self.connection=(new_connection)
+      @@connection = new_connection
+    end
+
+    # @api public
+    def self.logger
+      connection.logger
+    end
+
+    # @api public
+    def self.database=(name)
+      @@database = nil
+      @@database_name = name
+    end
+
+    # @api public
+    def self.database
+      if @@database_name.blank?
+        raise 'You forgot to set the default database name: MongoMapper.database = "foobar"'
+      end
+
+      @@database ||= connection.db(@@database_name)
+    end
+
+    def self.config=(hash)
+      @@config = hash
+    end
+
+    def self.config
+      raise 'Set config before connecting. Cubicle.mongo.config = {...}' unless defined?(@@config)
+      @@config
+    end
+
+    # @api private
+    def self.config_for_environment(environment)
+      env = config[environment]
+      return env if env['uri'].blank?
+
+      uri = URI.parse(env['uri'])
+      raise InvalidScheme.new('must be mongodb') unless uri.scheme == 'mongodb'
+      {
+              'host' => uri.host,
+              'port' => uri.port,
+              'database' => uri.path.gsub(/^\//, ''),
+              'username' => uri.user,
+              'password' => uri.password,
+              }
+    end
+
+    def self.connect(environment, options={})
+      raise 'Set config before connecting. Cubicle.mongo.config = {...}' if config.blank?
+      env = config_for_environment(environment)
+      self.connection = Mongo::Connection.new(env['host'], env['port'], options)
+      self.database = env['database']
+      self.database.authenticate(env['username'], env['password']) if env['username'] && env['password']
+    end
+
+    def self.setup(config, environment, options={})
+      using_passenger = options.delete(:passenger)
+      handle_passenger_forking if using_passenger
+      self.config = config
+      connect(environment, options)
+    end
+
+    def self.handle_passenger_forking
+      if defined?(PhusionPassenger)
+        PhusionPassenger.on_event(:starting_worker_process) do |forked|
+          connection.connect_to_master if forked
+        end
+      end
+    end
+
+    # @api private
+    def self.use_time_zone?
+      Time.respond_to?(:zone) && Time.zone ? true : false
+    end
+
+    # @api private
+    def self.time_class
+      use_time_zone? ? Time.zone : Time
+    end
+
+    # @api private
+    def self.normalize_object_id(value)
+      value.is_a?(String) ? Mongo::ObjectID.from_string(value) : value
+    end
+  end
+end
+#This class represents MongoDB. It is lifted line for line from MongoMapper
+#http://github.com/jnunemaker/mongomapper/blob/master/lib/mongo_mapper.rb
+#Actually, if the MongoMapper gem is loaded, Cubicle will simply use it for
+#providing the MongoEnvironment. However, if MongoMapper isn't loaded,
+#this stuff is still required, so why reinvent the wheel?

data/lib/cubicle/mongo_mapper/aggregate_plugin.rb

@@ -0,0 +1,17 @@
+module Cubicle
+  module MongoMapper
+    module AggregatePlugin
+      module ClassMethods
+        def aggregate(&block)
+          return Cubicle::Aggregation.new(self.collection_name,&block)
+        end
+      end
+
+      def self.included(model)
+        model.plugin AggregatePlugin
+      end
+    end
+  end
+end
+
+MongoMapper::Document.append_inclusions(Cubicle::MongoMapper::AggregatePlugin)

data/lib/cubicle/query.rb

@@ -0,0 +1,315 @@
+module Cubicle
+  class Query
+
+    attr_reader  :time_period, :transient
+    attr_accessor :source_collection_name
+    def initialize(cubicle)
+      @cubicle = cubicle
+
+      @dimensions = Cubicle::MemberList.new
+      @measures = Cubicle::MemberList.new
+      @source_collection_name = @cubicle.target_collection_name
+      @where, @from_date, @to_date, @date_dimension, @time_period, @limit, @offset = nil
+      @all_dimensions, @all_measures = false, false
+      @transient = false
+      @by=[]
+      @order_by=[]
+      @from_date_filter = "$gte"
+      @to_date_filter = "$lte"
+    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
+      return @dimensions[member_name] ||
+              @measures[member_name]
+    end
+
+    def transient?
+      @transient || @cubicle.transient?
+    end
+
+    def transient!
+      @transient = true
+      @source_collection_name = nil
+    end
+
+    def all_measures?
+      @all_measures
+    end
+
+    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
+      return ((@from_date || Time.now)..(@to_date || Time.now)) unless date_range
+      @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
+
+    def dimension_names
+      return dimensions.map{|dim|dim.name.to_s}
+    end
+
+    def member_names
+      return (dimensions + measures).map{|m|m.name.to_s}
+    end
+
+    def dimensions
+      return @dimensions unless all_dimensions?
+      @cubicle.dimensions.collect{|dim|convert_dimension(dim)}
+    end
+
+    def measures
+      return @measures unless all_measures?
+      @cubicle.measures.collect{|measure|convert_measure(measure)}
+    end
+
+    def execute(options={})
+      @cubicle.execute_query(self,options)
+    end
+
+    private
+    def prepare_filter
+      if @from_date || @to_date
+        unless time_dimension
+          raise "A date range was specified for this query (#{@from_date}->#{@to_date}) however, a time dimension wasn't detected. Please use the time_dimension directive to name a field in your source data that represents the date/time you want to use to filter your query"
+        end
+        @time_period ||= detect_time_period || :date
+
+        if transient? && time_dimension.expression_type != :field_name
+          raise "You are attempting to filter against the derived dimension (#{time_dimension.name}=#{time_dimension.expression}) in a transient query. This is not allowed in transient queries, which only allow filtering fields specified using :field_name"
+        end
+
+        time_filter = {}
+
+        dim_name =  time_dimension.name
+        time_filter[@from_date_filter]=@from_date.utc.to_cubicle(@time_period) if @from_date
+        time_filter[@to_date_filter]=@to_date.utc.to_cubicle(@time_period) if @to_date
+        (@where ||= {})[dim_name] = time_filter
+      end
+      @where
+    end
+
+    def detect_time_period(dimension_name = (time_dimension ? time_dimension.name : nil))
+      return nil unless dimension_name
+      return case dimension_name.to_s.singularize
+        when /.*month$/ then :month
+        when /.*year$/ then :year
+        when /.*quarter$/ then :quarter
+        when /.*day$/ then :date
+        when /.*date$/ then :date
+        else nil
+      end
+    end
+
+    def convert_dimension(dimension)
+      return dimension if transient?
+      Cubicle::Dimension.new(dimension.name, :expression=>"this._id.#{dimension.name}")
+    end
+
+    def convert_measure(measure)
+
+      #If the measure is a ratio, we want to make
+      #sure each of the ratio components will be in the output
+      #Other than that, no change is required to the measure
+      #However, if all measures are included, this won't be necessary
+      #and would cancel out the implicit all_member inclusion. If this
+      #causes a bug down the line, we may need a specific :all_members
+      #flag rather than the implicit "no selections means all members"
+      #shortcut.
+      if (measure.is_a?(Cubicle::Ratio))
+        select measure.numerator, measure.denominator unless all_measures?
+        return measure
+      end
+
+      return measure if transient?
+
+      #when selecting from a cached map_reduce query, we no longer want to count rows, but aggregate
+      #the pre-calculated counts stored in the cached collection. Therefore, any :counts become :sum
+      aggregation = measure.aggregation_method == :count ? :sum : measure.aggregation_method
+      expression = "this.value.#{measure.name}"
+      if (aggregation == :average)
+        count_field = expression + "_count"
+        expression = "#{expression}*#{count_field}"
+      end
+      Cubicle::Measure.new(measure.name, :expression=>expression,:aggregation_method=>aggregation)
+    end
+
+  end
+end