active_olap 0.0.2

data/lib/active_olap/dimension.rb

@@ -0,0 +1,230 @@
+module ActiveOLAP
+  
+  class Dimension
+
+    attr_reader :klass
+    attr_reader :categories
+    attr_reader :category_field
+    attr_reader :info
+    
+    attr_reader :joins
+    attr_reader :conditions
+    
+    # creates a new Dimension, given a definition.
+    # The definition can be:
+    # - A name (Symbol) of registered definition
+    # - A name (Symbol) of a field in the corresponding table
+    # - A hash, with at most one of the following keys set
+    #   - :categories -> for custom categories
+    #   - :trend      -> for a trend dimension
+    #   - :field      -> for a table field dimension (similar to passing a Symbol)
+    def self.create(klass, definition = nil)
+      return klass if klass.kind_of? Dimension      
+      
+      case definition
+      when Dimension
+        return definition
+      when Symbol
+        if klass.active_olap_dimensions.has_key?(definition)
+          if klass.active_olap_dimensions[definition].respond_to?(:call)
+            return Dimension.new(klass, klass.active_olap_dimensions[definition].call)
+          else
+            return Dimension.new(klass, klass.active_olap_dimensions[definition])
+          end
+        else
+          return Dimension.new(klass, definition)        
+        end
+      when Array
+        if klass.active_olap_dimensions.has_key?(definition.first)
+          return Dimension.new(klass, klass.active_olap_dimensions[definition.shift].call(*definition))
+        else 
+          return Dimension.new(klass, definition)
+        end
+      else
+        return Dimension.new(klass, definition)
+      end
+    end
+
+    # Builds a SUM expression for this dimension.
+    def to_count_with_overlap_sql
+      
+      count_value = @klass.connection.send(:quote_table_name, @klass.table_name) + '.' + 
+                    @klass.connection.send(:quote_column_name, :id) # TODO: other column than id
+        
+      @categories.map { |category| category.to_count_sql(count_value) }.join(', ')
+    end
+    
+    # Builds a CASE expression for this dimension.
+    def to_case_expression(variable_name)
+      if @category_field
+        "#{@klass.connection.send(:quote_column_name, @category_field)} AS #{@klass.connection.send(:quote_column_name, variable_name)}"
+      else
+        whens = @categories.map { |category| @klass.send(:sanitize_sql, ["WHEN (#{category.to_sanitized_sql}) THEN ?", category.label.to_s]) }
+        "CASE #{whens.join(' ')} ELSE NULL END AS #{@klass.connection.send(:quote_column_name, variable_name)}";
+      end
+    end
+
+    # Registers a category in this dimension.
+    # This function is called when a dimension is created and the categories are known or
+    # while the query result is being populated for dimensions with unknown categories.
+    def register_category(cat_label, definition = nil)
+      unless has_category?(cat_label)
+        definition = {:expression => { @category_field => cat_label }} if definition.nil? && @category_field
+        cat = Category.new(self, cat_label, definition)
+        @categories << cat
+        return (@categories.length - 1)
+      else
+        return category_index(cat_label)
+      end
+    end
+    
+    # Returns a category, given a category label
+    def [](label)
+      category_by_label(label)
+    end
+    
+    # Returns all the category labels
+    def category_labels 
+      @categories.map(&:label)
+    end
+    
+    # Checks whether this dimension has a category with the provided label
+    def has_category?(label)
+      @categories.any? { |cat| cat.label == label }
+    end
+    
+    # Returns the index in this dimension of a category identified by its label 
+    def category_index(label)
+      @categories.each_with_index { |cat, index| return index if cat.label == label }
+      return nil
+    end
+    
+    # Returns a category, given its index
+    def category_by_index(index)
+      @categories[index]
+    end
+    
+    # Returns a category, given a category label
+    def category_by_label(label)
+      @categories.detect { |cat| cat.label == label }
+    end    
+    
+    # checks whether thios is a table field dimension which categories are unknown beforehand
+    def is_field_dimension?
+      !@category_field.nil?
+    end
+    
+    def is_time_dimension?
+      @info.has_key?(:trend) && @info[:trend] == true
+    end
+    
+    def is_custom_dimension?
+      !is_field_dimension? && !is_time_dimension?
+    end
+    
+    def has_overlap?
+      @info.has_key?(:overlap) && @info[:overlap] == true
+    end
+    
+    # Returns a sanitized SQL expression for a given category
+    def sanitized_sql_for(cat)
+      cat_conditions = is_field_dimension? ? @klass.send(:sanitize_sql, { @category_field => cat }) : self[cat].to_sanitized_sql
+      @klass.send(:merge_conditions, cat_conditions, @conditions) 
+    end
+    
+    protected
+    
+    # Generates an SQL expression for the :other-category
+    def generate_other_condition
+      all_categories = @categories.map { |category| "(#{category.to_sanitized_sql})" }.join(' OR ') 
+      "((#{all_categories}) IS NULL OR NOT(#{all_categories}))"
+    end    
+
+    # Initializes a new Dimension object. See Dimension#create
+    def initialize(klass, definition)
+      @klass = klass
+      @categories = []
+
+      @info = {}
+
+      @joins = []
+      @conditions = nil
+      
+      case definition
+      when Hash
+        hash = definition.clone
+        @conditions = hash.delete(:conditions)
+        @joins += hash[:joins].kind_of?(Array) ? hash.delete(:joins) : [hash.delete(:joins)] if hash.has_key?(:joins)
+        
+        if hash.has_key?(:categories)
+          generate_custom_categories(hash.delete(:categories))
+          
+        elsif hash.has_key?(:trend)
+          generate_trend_categories(hash.delete(:trend))
+          
+        elsif hash.has_key?(:field)
+          generate_field_dimension(hash.delete(:field))
+
+        else
+          raise "Invalid category definition! " + definition.inspect          
+        end
+        
+        # make the remaining fields available in the info object
+        @info.merge!(hash)
+        
+      when Symbol
+        generate_field_dimension(definition)
+        
+      else
+        raise "Invalid category definition! " + definition.inspect
+      end      
+    end
+    
+    def generate_field_dimension(field)
+      case field
+      when Hash
+        @category_field = field[:column].to_sym
+      else  
+        @category_field = field.to_sym        
+      end
+      
+      unless @klass.column_names.include?(@category_field.to_s)
+        raise "Could not create dimension for unknown field #{@category_field}" 
+      end
+    end
+    
+    def generate_custom_categories(categories)
+      skip_other = false
+      categories.to_a.each do |category|
+        skip_other = true if category.first == :other
+        register_category(category.first, category.last) if category.last
+      end
+      register_category(:other, :expression => generate_other_condition) unless skip_other
+    end
+    
+    def generate_trend_categories(trend_definition)
+      period_count     = trend_definition.delete(:periods) || trend_definition.delete(:period_count)    || 14      
+      period_length    = trend_definition.delete(:period_length)   || 1.days
+      trend_end        = trend_definition.delete(:end)             || Time.now.utc.midnight + 1.day
+      trend_begin      = trend_definition.delete(:begin)
+      timestamp_field  = trend_definition.delete(:timestamp_field)
+      
+      if !trend_end.nil? && trend_begin.nil?
+        trend_begin = trend_end - (period_count * period_length)
+      end
+      
+      
+      field = @klass.connection.send :quote_column_name, timestamp_field
+      period_begin = trend_begin
+      period_count.times do |i|
+        register_category("period_#{i}".to_sym, {:begin => period_begin, :end => period_begin + period_length,
+                      :expression => ["#{field} >= ? AND #{field} < ?", period_begin, period_begin + period_length] })
+        period_begin  += period_length
+      end
+      
+      # update conditions by only querying records that fall in any periods.
+      @conditions = @klass.send(:merge_conditions, @conditions, ["#{field} >= ? AND #{field} < ?", trend_begin, period_begin])
+      @info[:trend] = true
+    end    
+  end
+end

data/lib/active_olap/helpers/chart_helper.rb

@@ -0,0 +1,99 @@
+module ActiveOLAP::Helpers
+  module ChartHelper
+  
+    def included(base)
+      require 'gchartrb'
+      base.send :include, ActiveOLAP::Helpers::DisplayHelper
+    end
+  
+    def active_olap_pie_chart(cube, options = {}, html_options = {})
+      raise "Pie charts are only suitable charts for 1-dimensional cubes" if cube.depth > 1
+      raise "Pie charts are only supported with a single aggregate"       if cube.aggregates.length > 1
+    
+      active_olap_1d_pie_chart(cube, options, html_options)
+    end
+
+    def active_olap_line_chart(cube, options = {}, html_options = {}) 
+      raise "Line charts are only supported with a single aggregate" if cube.aggregates.length > 1
+    
+      case cube.depth
+      when 1; active_olap_1d_line_chart(cube, options, html_options)
+      when 2; active_olap_2d_line_chart(cube, options, html_options)
+      else;   raise "Multidimensional line charts are not yet supported"
+      end
+    end
+
+    def active_olap_1d_pie_chart(cube, options = {}, html_options = {})
+    
+      # set some default options
+      options[:size]      ||= '550x300'
+      options[:legend]      = true unless options.has_key?(:legend)
+      html_options[:alt]  ||= show_active_olap_cube(cube, :for => :pie_chart)
+      html_options[:size] ||= options[:size]
+    
+      chart = GoogleChart::PieChart.new(options[:size])
+      chart.show_legend = options[:legend]
+      cube.each do |category, value| 
+        if category.info[:color]
+          color = category.info[:color]
+          color = $1 if color =~ /^\#([A-f0-9]{6})$/        
+          chart.data show_active_olap_category(category, :for => :pie_chart), value, color
+        else
+          chart.data show_active_olap_category(category, :for => :pie_chart), value
+        end
+      end
+      image_tag(chart.to_url, html_options)
+    end
+
+    def active_olap_1d_line_chart(cube, options = {}, html_options = {})
+    
+      # set some default options
+      options[:size]      ||= '550x300'
+      options[:legend]      = false unless options.has_key?(:legend)
+      html_options[:alt]  ||= show_active_olap_cube(cube, :for => :line_chart)
+      html_options[:size] ||= options[:size]
+    
+      chart = GoogleChart::LineChart.new(options[:size])
+      labels = cube.categories.map { |cat| show_active_olap_period(cat, :for => :line_chart) }
+    
+      color = options[:color] || '000000'
+      color = $1 if color =~ /^\#([A-f0-9]{6})$/
+      chart.data(show_active_olap_dimension(cube.dimension, :for => :line_chart), cube.to_a, color)
+      chart.show_legend = options[:legend]
+      chart.axis :x, :labels => labels    
+      chart.axis :y, :range  => [0, cube.raw_results.max]
+      image_tag(chart.to_url, html_options)
+    end
+
+    def active_olap_2d_line_chart(cube, options = {}, html_options = {})
+    
+      # set some default options
+      options[:size]      ||= '550x300'
+      options[:legend]      = true unless options.has_key?(:legend) && options[:legend] == false
+      colors = options.has_key?(:colors) ? options[:colors].clone : ['aaaaaa', 'aa0000', '00aa00', '0000aa', '222222']
+      html_options[:alt]  ||= show_active_olap_cube(cube, :for => :line_chart)
+      html_options[:size] ||= options[:size]
+    
+      chart = GoogleChart::LineChart.new(options[:size])
+    
+      cube.transpose.each do |cat, sub_cube| 
+        color = cat.info[:color] || colors.shift || '666666'
+        color = $1 if color =~ /^\#([A-f0-9]{6})$/
+        chart.data show_active_olap_category(cat, :for => :line_chart), sub_cube.raw_results, color
+      end
+    
+      if options[:totals]
+        totals_label = options[:totals_label] || "Total"
+        totals_color = options[:totals_color] || "000000"
+        totals_color = $1 if totals_color =~ /^\#([A-f0-9]{6})$/
+        chart.data totals_label, cube.map { |cat, result| result.raw_results.sum }, totals_color
+      end
+    
+      chart.show_legend = options[:legend]
+      labels = cube.categories.map { |cat| show_active_olap_period(cat, :for => :line_chart) }    
+      chart.axis :x, :labels => labels        
+      chart.axis :y, :range  => [0, cube.raw_results.flatten.max]
+      image_tag(chart.to_url, html_options)
+    end  
+  end
+end

data/lib/active_olap/helpers/display_helper.rb

@@ -0,0 +1,54 @@
+module ActiveOLAP::Helpers
+  module DisplayHelper
+  
+
+    def show_active_olap_category(category, options = {})
+      return category.info[:name] unless category.info[:name].blank?
+      return show_active_olap_period(category, options) if category.dimension.is_time_dimension?
+      return category.to_s.humanize if category.label.kind_of?(Symbol)
+      return category.to_s 
+    end
+  
+    def show_active_olap_period(category, options = {})
+    
+      duration = category.info[:end] - category.info[:begin]
+      if duration < 1.hour
+        begin_time = category.info[:begin].strftime('%H:%M')
+        end_time   = category.info[:end].strftime('%H:%M')    
+      elsif duration < 1.day
+        begin_time = category.info[:begin].strftime('%H')
+        end_time   = category.info[:end].strftime('%H')
+      elsif duration < 1.month
+        begin_time = category.info[:begin].strftime('%m/%d')
+        end_time   = category.info[:end].strftime('%m/%d')      
+      else
+        begin_time = category.info[:begin].strftime('\'%y/%m/%d')
+        end_time   = category.info[:end].strftime('\'%y/%m/%d')
+      end
+    
+      case options[:for]
+      when :line_chart; begin_time 
+      else; "#{begin_time} - #{end_time}"
+      end
+    end
+
+
+    def show_active_olap_aggregate(aggregate, options = {})
+      aggregate.info[:name].blank? ? aggregate.label.to_s : aggregate.info[:name]
+    end
+  
+    def show_active_olap_value(category, aggregate, value, options = {})
+      value.nil? ? '-' : value.to_s
+    end
+
+    def show_active_olap_dimension(dimension, options = {})
+      return dimension.info[:name] unless dimension.info[:name].blank?    
+      "dimension"
+    end
+  
+    def show_active_olap_cube(cube, options = {})
+      return cube.info[:name] unless cube.info[:name].blank?
+      "OLAP cube"
+    end
+  end
+end

data/lib/active_olap/helpers/form_helper.rb

@@ -0,0 +1,16 @@
+module ActiveOLAP::Helpers
+  module FormHelper
+  
+    def select_olap_dimension_tag(klass, dim_index = 1, options = {}, html_options = {})    
+      dimensions = klass.active_olap_dimensions.map { |l, dim| [l, ActiveOLAP::Dimension.create(klass, l)] }
+      dimensions.delete_if { |(l, dim)| dim.is_time_dimension? }.map { |(l, dim)| [l, show_active_olap_dimension(dim)] }
+      select_tag "dimension[#{dim_index}][name]", options_for_select(dimensions, nil), html_options
+    end
+  
+    def select_olap_time_dimension_tag(klass, dim_index = 1, options = {}, html_options = {})
+      dimensions = klass.active_olap_dimensions.map { |l, dim| [l, ActiveOLAP::Dimension.create(klass, l)] }
+      dimensions.delete_if { |(l, dim)| !dim.is_time_dimension? }.map { |(l, dim)| [l, show_active_olap_dimension(dim)] }
+      select_tag "dimension[#{dim_index}][name]", options_for_select(dimensions, nil), html_options
+    end
+  end
+end

data/lib/active_olap/helpers/table_helper.rb

@@ -0,0 +1,92 @@
+module ActiveOLAP::Helpers
+  module TableHelper
+  
+  
+    def self.included(base)
+      base.send :include, ActiveOLAP::Helpers::DisplayHelper
+    end
+  
+    def active_olap_matrix(cube, options = {}, html_options = {})
+    
+      raise "Only suitable for 2D cubes" unless cube.depth == 2
+      raise "Only 1 aggregate supported" if cube.aggregates.length > 1
+      options[:strings] ||= {}
+    
+      content_tag(:table, html_options.merge(:class => "active-olap table 2d")) do    
+        content_tag(:thead) do
+          content_tag(:tr, :class => 'category') do
+            header_html = content_tag(:th, ' ') + "\n\t" +
+            cube.dimensions[1].categories.map do |category|
+              content_tag(:th, show_active_olap_category(category, :for => :matrix), :class => 'column', :id => "category-#{category.label}")
+            end.join
+            
+            if options[:totals]
+              header_html << content_tag(:th, '&nbsp;', :class => 'column total', :id => "category-total")
+            end
+            header_html
+          end
+        end << "\n" <<
+        content_tag(:tbody) do
+          body_html = cube.map do |category, sub_cube|
+            content_tag(:tr, :class => 'row') do
+              row_html = "\t\n" + content_tag(:th, show_active_olap_category(category, :class => 'category row', :id => "category-#{category.label}", :for => :matrix)) + 
+              sub_cube.map do |category, value|
+                content_tag(:td, show_active_olap_value(category, cube.aggregates.first, value, :for => :matrix), :class => 'value')
+              end.join
+              if options[:totals]
+                row_html << content_tag(:td, show_active_olap_value(category, sub_cube.aggregates.first, sub_cube.sum, :for => :matrix), :class => 'value')
+              end
+              row_html
+            end
+          end
+          
+          if options[:totals]
+            body_html << content_tag(:tr, :class => 'totals') do
+              "\t\n" + content_tag(:th, '&nbsp;', :class => 'row total') + 
+              cube.transpose.map do |category, sub_cube|
+                content_tag(:td, show_active_olap_value(category, sub_cube.aggregates.first, sub_cube.sum, :for => :matrix), :class => 'value')
+              end.join + 
+              content_tag(:td, cube.sum, :class => 'value')
+            end
+          end
+          body_html
+        end
+      end
+    end
+
+    def active_olap_table(cube, options = {}, html_options = {})
+      content_tag(:table, :class => "active-olap table #{cube.depth}d" ) do
+        content_tag(:thead) do
+          content_tag(:tr) do
+            content_tag(:th, '&nbsp;', :class => 'categories', :colspan => cube.depth) <<
+            cube.aggregates.map { |agg| content_tag(:th, show_active_olap_aggregate(agg, :for => :table), :class => "aggregate #{agg.label}") }.join
+          end
+        end << "\n" <<
+        content_tag(:tbody) { active_olap_table_bodypart(cube, options) }
+      end
+    end
+  
+    def active_olap_table_bodypart(cube, options = {}, intermediate = [], counts = [])
+      cube.map do |category, result|
+        if result.kind_of?(ActiveOLAP::Cube)
+          active_olap_table_bodypart(result, options, intermediate.push(category), counts.push(result.categories.length))
+        else
+          content_tag(:tr) do
+            cells = intermediate.map do |c| 
+              cat_count = counts.shift
+              content_tag(:th, c.label.to_s, { :class => 'category', :rowspan => cat_count * counts.inject(1) { |i, count| i * count } } ) 
+            end.join
+            intermediate.clear
+          
+            cells << content_tag(:th, show_active_olap_category(category, :for => :table), :class => "category") # TODO values
+            cells << if result.kind_of?(Hash)
+                cube.aggregates.map { |agg| content_tag(:td, show_active_olap_value(category, agg, result[agg.label], :for => :table), :class => "value #{agg.label}") }.join
+              else
+                content_tag(:td, show_active_olap_value(category, cube.aggregates[0], result, :for => :table), :class => 'value')
+              end
+          end
+        end
+      end.join
+    end
+  end
+end

data/lib/active_olap/test/assertions.rb

@@ -0,0 +1,39 @@
+module ActiveOLAP::Test
+  module  Assertions
+  
+    # tests whether Active OLAP is enabled for a given class, by checking
+    # whether the class responds to certain methods like olap_query
+    def assert_active_olap_enabled(klass, message = "Active OLAP is not enabled for this class!")
+      assert klass.respond_to?(:active_olap_dimensions), message
+      assert klass.respond_to?(:active_olap_aggregates), message
+      assert klass.respond_to?(:olap_query), message
+      assert klass.respond_to?(:olap_drilldown), message    
+    end
+  
+    # tests whether a given cube is a valid Active OLAP cube and has the expected dimensions
+    # you can specify the number of dimenions as an integer (say n), or as an array of n integers,
+    # in which each element is the number of categories that should be in that dimension. You can 
+    # use :unknown if this is not known beforehand
+    #
+    # examples:
+    #
+    # assert_active_olap_cube cube, 2 
+    # => checks for the existence of two dimensions
+    #
+    # assert_active_olap_cube cube, [3, :unknown] 
+    # => Checks for the existence of two dimensions. 
+    #    - The first dimension should have 3 catgeories
+    #    - The number of categories in the second dimension is unknown
+    def assert_active_olap_cube(cube, dimensions = nil)
+      assert_kind_of ActiveOLAP::Cube, cube
+      if dimensions.kind_of?(Array)
+        assert_equal dimensions.length, cube.depth
+        dimensions.each_with_index do |category_count, index|
+          assert_equal category_count, cube.dimensions[index].categories.length unless category_count == :unknown
+        end
+      elsif dimensions.kind_of?(Numeric)
+        assert_equal dimensions, cube.depth   
+      end
+    end
+  end
+end

data/lib/active_olap.rb

@@ -0,0 +1,116 @@
+module ActiveOLAP
+  
+  def enable_active_olap(config = nil, &block)
+
+    self.send(:extend, ClassMethods)
+    self.named_scope :olap_drilldown, lambda { |hash| self.olap_drilldown_finder_options(hash) }    
+    
+    self.cattr_accessor :active_olap_dimensions, :active_olap_aggregates
+    self.active_olap_dimensions = {}
+    self.active_olap_aggregates = {}    
+    
+    if config.nil? && block_given?
+      conf = Configurator.new(self)
+      yield(conf) 
+    end
+    
+  end
+  
+  
+  module ClassMethods
+    
+    # Performs an OLAP query that counts how many records do occur in given categories.
+    # It can be used for multiple dimensions 
+    # It expects a list of category definitions
+    def olap_query(*args)
+
+      # set aggregates apart if they are given
+      aggregates_given = (args.last.kind_of?(Hash) && args.last.has_key?(:aggregate)) ? args.pop[:aggregate] : nil
+      
+      # parse the dimensions
+      raise "You have to provide at least one dimension for an OLAP query" if args.length == 0    
+      dimensions = args.collect { |d| Dimension.create(self, d) }
+      
+      raise "Overlapping categories only supported in the last dimension" if dimensions[0..-2].any? { |d| d.has_overlap? }
+      raise "Only counting is supported with overlapping categories" if dimensions.last.has_overlap? && aggregates_given
+
+      if !aggregates_given
+        if dimensions.last.has_overlap?
+          aggregates = []
+        else
+          aggregates = [Aggregate.create(self, :the_olap_count_field, :count_distinct)]
+        end
+      else 
+        aggregates = Aggregate.all_from_olap_query_call(self, aggregates_given)        
+      end
+
+      conditions = self.send(:merge_conditions, *dimensions.map(&:conditions))
+      joins = (dimensions.map(&:joins) + aggregates.map(&:joins)).flatten.uniq
+      joins_clause = joins.empty? ? nil : self.send(:merge_joins, *joins)
+
+      selects = aggregates.map { |agg| agg.to_sanitized_sql }
+      groups  = []
+
+      if aggregates.length > 0
+        dimensions_to_group = dimensions.clone
+      else 
+        selects << dimensions.last.to_count_with_overlap_sql
+        dimensions_to_group = dimensions[0, dimensions.length - 1]
+      end
+      
+      dimensions_to_group.each_with_index do |d, index|
+        var_name = "dimension_#{index}"
+        groups  << self.connection.quote_column_name(var_name)
+        selects << d.to_case_expression(var_name)
+      end
+    
+      group_clause = groups.length > 0 ? groups.join(', ') : nil
+      # TODO: having
+      
+      olap_temporarily_set_join_type if joins_clause
+      
+      query_result = self.scoped(:conditions => conditions).find(:all, :select => selects.join(', '), 
+          :joins => joins_clause, :group => group_clause, :order => group_clause)  
+      
+      olap_temporarily_reset_join_type if joins_clause
+      
+      return Cube.new(self, dimensions, aggregates, query_result)
+    end   
+  end
+  
+  protected
+  
+  def olap_drilldown_finder_options(options)
+    raise "You have to provide at least one dimension for an OLAP query" if options.length == 0    
+
+    # returns an options hash to create a scope (the named_scope :olap_drilldown)
+    conditions = options.map { |dim, cat| Dimension.create(self, dim).sanitized_sql_for(cat) }
+    { :select => connection.quote_table_name(table_name) + '.*', :conditions => self.send(:merge_conditions, *conditions) }
+  end
+  
+  # temporarily use LEFT JOINs for specified :joins
+  def olap_temporarily_set_join_type
+    ActiveRecord::Associations::ClassMethods::InnerJoinDependency::InnerJoinAssociation.send(:define_method, :join_type) { "LEFT OUTER JOIN" }
+  end
+
+  # reset to INNER JOINs after query has finished
+  def olap_temporarily_reset_join_type
+    ActiveRecord::Associations::ClassMethods::InnerJoinDependency::InnerJoinAssociation.send(:define_method, :join_type) { "INNER JOIN" }
+  end
+  
+end
+
+
+require 'active_olap/dimension'
+require 'active_olap/category'
+require 'active_olap/aggregate'
+require 'active_olap/cube'
+require 'active_olap/configurator'
+
+require 'active_olap/helpers/display_helper'
+require 'active_olap/helpers/table_helper'
+require 'active_olap/helpers/chart_helper'
+require 'active_olap/helpers/form_helper'
+
+# inlcude the AcvtiveOLAP module in ActiveRecord::Base
+ActiveRecord::Base.send(:extend, ActiveOLAP)

data/spec/integration/active_olap_spec.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$:.reject! { |e| e.include? 'TextMate' }
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+# load RSpec libraries
+require 'rubygems'
+gem 'rspec', '>=1.1.11'
+require 'test/unit'
+require 'spec'
+
+
+# Load Active OLAP files
+require 'active_record'
+require File.dirname(__FILE__) + '/../lib/active_record/olap'
+require File.dirname(__FILE__) + '/../lib/active_record/olap/cube'

data/spec/unit/cube_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe ActiveOLAP::Cube do
+  
+  before(:each) do
+
+  end
+  
+  it "should blah"
+  
+end