activewarehouse 0.1.0

data/lib/active_warehouse/model/report/chart_report.rb

@@ -0,0 +1,9 @@
+module ActiveWarehouse
+  module Report
+    class ChartReport < ActiveRecord::Base
+      include AbstractReport
+      before_save :to_storage
+      after_save :from_storage
+    end
+  end
+end

data/lib/active_warehouse/model/report/table_report.rb

@@ -0,0 +1,23 @@
+module ActiveWarehouse
+  module Report
+    # A report which is used to represent a tabular report.
+    class TableReport < ActiveRecord::Base
+      include AbstractReport
+      before_save :to_storage
+      after_save :from_storage
+      attr_accessor :format, :link_cell, :html_params
+      
+      def format
+        @format ||= {}
+      end
+      
+      def link_cell
+        @link_cell ||= false
+      end
+      
+      def html_params
+        @html_params ||= {}
+      end
+    end
+  end
+end

data/lib/active_warehouse/version.rb

@@ -0,0 +1,9 @@
+module ActiveWarehouse
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/active_warehouse/view.rb

@@ -0,0 +1,2 @@
+require 'active_warehouse/view/report_helper'
+ActionView::Base.send :include, ReportHelper

data/lib/active_warehouse/view/report_helper.rb

@@ -0,0 +1,213 @@
+module ReportHelper
+  
+  # Render the report.
+  # * <tt>report</tt>: The report instance
+  # * <tt>html_options</tt>: HTML options
+  def render_report(report, html_options={})
+    case report
+    when ActiveWarehouse::Report::TableReport
+      render_table_report(report, html_options)
+    when ActiveWarehouse::Report::ChartReport
+      render_chart_report(report, html_options)
+    else
+      raise "Unsupported report type: #{report.class}"
+    end
+  end
+  
+  private
+  def render_table_report(report, html_options)
+    cube = report.cube
+    fact_class = report.fact_class
+    column_dimension_class = report.column_dimension_class
+    row_dimension_class = report.row_dimension_class
+    
+    column_dimension = report.column_dimension_name
+    row_dimension = report.row_dimension_name
+    
+    column_hierarchy = report.column_hierarchy
+    column_hierarchy_constraints = report.column_constraints
+    
+    row_hierarchy = report.row_hierarchy
+    row_hierarchy_constraints = report.row_constraints
+    
+    fact_attributes = report.fact_attributes
+    
+    html_params = report.html_params
+    
+    cstage = (params[:cstage] || report.column_stage).to_i
+    rstage = (params[:rstage] || report.row_stage).to_i
+    
+    col_param_prefix = report.column_param_prefix
+    row_param_prefix = report.row_param_prefix
+    
+    link_cell = report.link_cell
+    format = report.format
+    
+    # Get the dimension instances
+    col_dims = find_column_dimensions(column_dimension_class, column_hierarchy, cstage, col_param_prefix)
+    row_dims = find_row_dimensions(row_dimension_class, row_hierarchy, rstage, row_param_prefix)
+    
+    # Get the aggregate map
+    agg_map = cube.aggregate_map(column_dimension, column_hierarchy, row_dimension, row_hierarchy, cstage, rstage)
+    
+    table_attributes = {}
+    table_attributes[:class] = html_options[:report_class] ||= 'report'
+    
+    col_hierarchy_length = column_dimension_class.hierarchy(column_hierarchy).length
+    row_hierarchy_length = row_dimension_class.hierarchy(row_hierarchy).length
+    col_group = column_dimension_class.hierarchy(column_hierarchy)[cstage]
+    row_group = row_dimension_class.hierarchy(row_hierarchy)[rstage]
+    
+    # build the paths back to the top of the two dimension hierarchies
+    col_path = []
+    row_path = []
+    0.upto(cstage) do |s| 
+      p = params["#{col_param_prefix}_#{column_dimension_class.hierarchy(column_hierarchy)[s]}"]
+      col_path << p unless p.nil?
+    end
+    0.upto(rstage) do |s| 
+      p = params["#{row_param_prefix}_#{row_dimension_class.hierarchy(row_hierarchy)[s]}"]
+      row_path << p unless p.nil?
+    end
+    #col_path << col_group.to_s
+    #row_path << row_group.to_s
+    
+    # build the XHTML
+    x = Builder::XmlMarkup.new(:indent => 2)
+    x.table(table_attributes) do |x|
+      x.tr do |x| # column dimension
+        x.th
+        col_dims.each do |col_dim|
+          col_dim_value = col_dim.send(col_group)
+          x.th({:colspan => fact_attributes.length}) do |x|
+            x << link_to_if((cstage < col_hierarchy_length - 1), col_dim_value, {
+              :cstage => cstage + 1, 
+              :rstage => rstage, 
+              "#{col_param_prefix}_#{col_group}" => col_dim_value}.merge(cube_params).merge(html_params))
+          end
+        end
+      end
+      
+      x.tr do |x| # aggregated fact headers
+        x.th
+        col_dims.each do |col_dim|
+          #fact_class.aggregate_fields.each do |field_name, options|
+          #  x.th(options[:label].to_s || field_name.to_s.humanize)
+          fact_attributes.each do |fact_attribute|
+            x.th(fact_attribute.to_s.humanize.titleize) # TODO replace with sortable column header
+          end
+        end
+      end
+      
+      row_dims.each do |row_dim| # rows
+        row_dim_value = row_dim.send(row_group)
+        cell_row_path = row_path + [row_dim_value]
+        x.tr do |x|
+          x.td do |x| # row dimension label
+            x << link_to_if((rstage < row_hierarchy_length - 1), row_dim_value, {
+              :cstage => cstage, 
+              :rstage => rstage + 1, 
+              "#{row_param_prefix}_#{row_group}" => row_dim_value}.merge(cube_params).merge(html_params))
+          end
+          
+          col_dims.each do |col_dim| # aggregated facts
+            col_dim_value = col_dim.send(col_group)
+            cell_col_path = col_path + [col_dim_value]
+            fact_attributes.each_with_index do |fact_attribute, index|
+              x.td do |x|
+                #puts "Row path (length=#{cell_row_path.length}): #{cell_row_path.join(':')}"
+                #puts "Col path (length=#{cell_col_path.length}): #{cell_col_path.join(':')}"
+                
+                block = format[fact_attribute.to_sym]
+                value = agg_map.value(cell_row_path.join(':'), cell_col_path.join(':'), index).to_s
+                value = block.call(value) if block
+                
+                x << link_to_if((cstage < col_hierarchy_length - 1 and rstage < row_hierarchy_length - 1 and link_cell),
+                  #agg_map[row_path.join(':')][col_path.join(':')][index].to_s, {
+                  value, {
+                  :cstage => cstage + 1, 
+                  :rstage => rstage + 1, 
+                  "#{col_param_prefix}_#{col_group}" => col_dim_value, 
+                  "#{row_param_prefix}_#{row_group}" => row_dim_value}.merge(cube_params).merge(html_params))
+              end
+            end
+          end
+        end
+      end
+      
+    end
+  end
+  
+  def render_chart_report(report, html_options)
+    "Not Yet Implemented"
+  end
+  
+  protected
+  def cube_params
+    p = {}
+    params.each { |key, value| p[key] = value if key =~ /^r_/ or key =~ /^c_/ }
+    p
+  end
+  def find_column_dimensions(dimension_class, hierarchy, current_stage, param_prefix='c')
+    find_dimensions(dimension_class, hierarchy, current_stage, param_prefix)
+  end
+  
+  def find_row_dimensions(dimension_class, hierarchy, current_stage, param_prefix='r')
+    find_dimensions(dimension_class, hierarchy, current_stage, param_prefix)
+  end
+  
+  def find_dimensions(dimension_class, hierarchy, current_stage, param_prefix)
+    # Construct the column find options
+    find_options = {}
+    group_by = []
+    conditions_sql = []
+    conditions_args = []
+    current_stage.to_i.downto(0) do |stage|
+      level = dimension_class.hierarchy(hierarchy)[stage]
+      group_by << level
+      unless stage == current_stage
+        conditions_sql << "#{level} = ?"
+        conditions_args << params["#{param_prefix}_#{level}"]
+      end
+    end
+    find_options[:conditions] = nil
+    if conditions_args.length > 0
+      find_options[:conditions] = [conditions_sql.join(" and ")] + conditions_args
+    end
+    find_options[:group] = find_options[:order] = group_by.join(',')
+    dimension_class.find(:all, find_options)
+  end
+  
+  public
+  # Create a sortable column header.
+  #
+  # Parameters are
+  #   column_name: The column display name
+  #   order_by: The column name from the table used for sorting
+  #   link_parameters: Parameters passed to the hypertext link
+  #   attributes: Parameters passed to the <th> element
+  #
+  # Example:
+  #   sortable_column_header('SSN','ssn')
+  #   sortable_column_header('Name','name',{:onclick => 'doSomething();'}, {:title => 'Some Title'})
+  def sortable_column_header(column_name, order_by, link_parameters={}, attributes={})
+    order = 'desc'
+    if params[:order_by].to_s == order_by.to_s
+  	  sorted = 'sorted'
+	  	if params[:order] == 'desc' || params[:order].nil?
+	  	  order_css_class = 'order_down'
+	  	  order = 'asc'
+	  	elsif params[:order] == 'asc'
+	  	  order_css_class = 'order_up'
+	  	  order = 'desc'
+	  	end
+  	else
+  	  sorted = ''
+  	end
+    
+    attributes.merge!({:class => "sortable #{sorted} #{order_css_class}"})
+    x.th(attributes) do |th|
+      th << link_to(column_name, params.merge({:order_by => order_by, :order => order}), link_parameters)
+    end
+  end
+end

data/tasks/active_warehouse_tasks.rake

@@ -0,0 +1,50 @@
+namespace :warehouse do 
+  desc "Build a 'standard' date dimension"
+  task :build_date_dimension => :environment do
+    abcs = ActiveRecord::Base.configurations
+    ActiveRecord::Base.establish_connection(abcs[RAILS_ENV])
+
+    start_date = (ENV['START_DATE'] ? Time.parse(ENV['START_DATE']) : Time.now.years_ago(5))
+    end_date = (ENV['END_DATE'] ? Time.parse(ENV['END_DATE']) : Time.now )
+
+    ddb = ActiveWarehouse::Builder::DateDimensionBuilder.new(start_date, end_date)
+    ddb.build.each do |record|
+      dd = DateDimension.new
+      record.each do |key,value|
+        dd.send("#{key}=".to_sym, value) if dd.respond_to?(key)
+      end
+      dd.save!
+    end
+  end
+  
+  desc "Rebuild the warehouse" # TODO: consider moving this logic somewhere into a class and calling it from here
+  task :rebuild => :environment do
+    puts "Rebuilding data warehouse"
+    # Discover and require all cube models
+    # TODO: do some more research on the potential problems with this
+    models_dir = File.join(File.dirname(__FILE__), '../../../../app/models')
+    Dir.glob(File.join(models_dir, "**", "*.rb")).each do |f|
+      if f =~ /_cube\.rb/
+        require f
+      end
+    end
+    
+    t = Benchmark.realtime do 
+      ActiveWarehouse::Cube.subclasses.each do |subclass|
+        puts "Rebuilding #{subclass}"
+        tc = Benchmark.realtime do
+          subclass.populate(:force => true)
+        end
+        puts "Rebuilt #{subclass} in #{tc}s"
+      end
+    end
+    puts "Data warehouse rebuilt in #{t}s"
+  end
+  
+  desc "Migrate ActiveWarehouse"
+  task :migrate => :environment do
+    puts "Migrating ActiveWarehouse"
+    migration_directory = File.join(File.dirname(__FILE__), '../db/migrations')
+    ActiveWarehouse::Migrator.migrate(migration_directory, ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+  end
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: activewarehouse
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-12-19 00:00:00 -05:00
+summary: Build data warehouses with Rails.
+require_paths: 
+- lib
+email: anthonyeden@gmail.com
+homepage: http://activewarehouse.rubyforge.org
+rubyforge_project: activewarehouse
+description: ActiveWarehouse extends Rails to provide functionality specific for building data warehouses.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Anthony Eden
+files: 
+- install.rb
+- README
+- TODO
+- Rakefile
+- db/migrations
+- db/migrations/001_create_table_reports.rb
+- doc/agg_queries.txt
+- doc/agg_queries_results.txt
+- doc/queries.txt
+- generators/cube
+- generators/dimension
+- generators/fact
+- generators/cube/cube_generator.rb
+- generators/cube/templates
+- generators/cube/USAGE
+- generators/cube/templates/model.rb
+- generators/cube/templates/unit_test.rb
+- generators/dimension/dimension_generator.rb
+- generators/dimension/templates
+- generators/dimension/USAGE
+- generators/dimension/templates/fixture.yml
+- generators/dimension/templates/migration.rb
+- generators/dimension/templates/model.rb
+- generators/dimension/templates/unit_test.rb
+- generators/fact/fact_generator.rb
+- generators/fact/templates
+- generators/fact/USAGE
+- generators/fact/templates/fixture.yml
+- generators/fact/templates/migration.rb
+- generators/fact/templates/model.rb
+- generators/fact/templates/unit_test.rb
+- lib/active_warehouse
+- lib/active_warehouse.rb
+- lib/active_warehouse/builder
+- lib/active_warehouse/builder.rb
+- lib/active_warehouse/core_ext
+- lib/active_warehouse/core_ext.rb
+- lib/active_warehouse/migrations.rb
+- lib/active_warehouse/model
+- lib/active_warehouse/model.rb
+- lib/active_warehouse/version.rb
+- lib/active_warehouse/view
+- lib/active_warehouse/view.rb
+- lib/active_warehouse/builder/date_dimension_builder.rb
+- lib/active_warehouse/builder/random_data_builder.rb
+- lib/active_warehouse/core_ext/time
+- lib/active_warehouse/core_ext/time.rb
+- lib/active_warehouse/core_ext/time/calculations.rb
+- lib/active_warehouse/model/aggregate.rb
+- lib/active_warehouse/model/cube.rb
+- lib/active_warehouse/model/dimension
+- lib/active_warehouse/model/dimension.rb
+- lib/active_warehouse/model/fact.rb
+- lib/active_warehouse/model/report
+- lib/active_warehouse/model/report.rb
+- lib/active_warehouse/model/dimension/bridge.rb
+- lib/active_warehouse/model/dimension/dimension.rb
+- lib/active_warehouse/model/dimension/hierarchical_dimension.rb
+- lib/active_warehouse/model/report/abstract_report.rb
+- lib/active_warehouse/model/report/chart_report.rb
+- lib/active_warehouse/model/report/table_report.rb
+- lib/active_warehouse/view/report_helper.rb
+- tasks/active_warehouse_tasks.rake
+test_files: []
+
+rdoc_options: 
+- --exclude
+- .
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.7.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.1.5618
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.14.4.5618
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.12.5.5618
+    version: