jzimmek-reportme 0.2.2 → 0.4.0

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.4.0

data/lib/reportme.rb

@@ -2,5 +2,31 @@ require 'rubygems'
 require 'activerecord'
 require "actionmailer"
 
-require 'reportme/report'
-require 'reportme/report_factory'
+class Object
+  
+  def self.dsl_attr(name, opts={})
+
+    self.class.send(:define_method, name) do |value|
+      key = "@@#{name}".to_sym
+      class_variable_set(key, value)
+    end
+    
+    
+    self.class.send(:define_method, "#{name}_value".to_sym) do
+      class_variable_get("@@#{name}".to_sym)
+    end
+
+    self.class.send(:define_method, "#{name}_reset".to_sym) do
+      default = opts[:default].try(:call)
+      class_variable_set("@@#{name}".to_sym, default)
+    end
+
+    default = opts[:default].try(:call)
+    send(name, default)
+
+  end
+  
+end
+
+require 'reportme/report_factory'
+

data/lib/reportme/report.rb

@@ -2,17 +2,31 @@ module Reportme
   class Report
   
     attr_reader :name
-  
-    def initialize(report_factory, name)
+    
+    def initialize(report_factory, name, temporary=false)
       @report_factory = report_factory
       @name = name
       @periods = [:today, :day, :week, :calendar_week, :month, :calendar_month]
+      @depends_on = []
+      @temporary = temporary
     end
   
+    def temporary?
+      @temporary
+    end
+    
     def source(&block)
       @source = block
     end
     
+    def depends_on(dependencies=[])
+      @depends_on += dependencies
+    end
+    
+    def dependencies
+      @depends_on
+    end
+    
     def periods(wanted_periods=[])
       unless wanted_periods.blank?
         @periods.clear
@@ -31,7 +45,8 @@ module Reportme
     end
   
     def table_name(period)
-      "#{name}_#{period}"
+      prefix = temporary? ? "tmp_" : ""
+      "#{prefix}#{name}_#{period}"
     end
   
     def table_exist?(period)

data/lib/reportme/report_factory.rb

@@ -3,51 +3,42 @@ require 'reportme/mailer'
 
 module Reportme
   class ReportFactory
-  
-    def self.create(&block)
-      rme = ReportFactory.new
-      rme.instance_eval(&block)
-      rme
-    end
+
+    dsl_attr :reports,        :default => lambda{ [] }
+    dsl_attr :subscribtions,  :default => lambda{ {} }
+    dsl_attr :properties,     :default => lambda{ {} }
+    dsl_attr :init
   
     def initialize
-      @reports = []
-      @subscribtions = {}
       @report_exists_cache = []
     end
     
-    def connection(properties)
-      @properties = properties
-      ActiveRecord::Base.establish_connection(@properties)
+    def self.connection(properties)
+      ActiveRecord::Base.establish_connection(@@properties = properties)
     end
     
-    def smtp(settings)
+    def self.smtp(settings)
       ActionMailer::Base.smtp_settings = settings
     end
     
-    def mail(from, recipients, subject, body, attachments=[])
+    def self.mail(from, recipients, subject, body, attachments=[])
       Mailer.deliver_message(from, recipients, subject, body, attachments)
     end
   
-    def since(since)
-      raise "since has already been set to '#{@since}' and cannot be changed to: '#{since}'"  if @since
-      raise "since cannot be in the future"                                                   if since.future?
-      
-      @since = since.to_date
-    end
-  
-    def init(&block)
-      raise "only one init block allowed" if @init
-      @init = block;
+    def self.init(&block)
+      raise "only one init block allowed" if @@init
+      @@init = block;
     end
   
     def self.periods(today)
 
+      today = today.to_date
+      
       r = []
       p = []
 
       # period "today" will never be generated for previous days
-      p << :today if today.to_date == Date.today
+      p << :today if today == Date.today
       p += [:day, :week, :calendar_week, :month, :calendar_month]
 
       p.each do |period|
@@ -100,13 +91,17 @@ module Reportme
       exists
     end
     
-    def schema_name
-      schema = @properties[:database]
+    def self.schema_name
+      schema = @@properties[:database]
       raise "missing :database in connection properties" unless schema
       schema
     end
-    
+
     def columns(table_name)
+      self.class.columns(table_name)
+    end
+    
+    def self.columns(table_name)
       sql = <<-SQL
       select
         column_name
@@ -120,23 +115,17 @@ module Reportme
       select_values(sql)
     end
     
-    def reset
-      @report_exists_cache.clear
-      exec("drop table if exists #{report_information_table_name};")
+    def ensure_report_tables_exist(report)
       
-      ReportFactory.periods(@since).each do |period|
-        @reports.each do |r|
-          exec("drop table if exists #{r.table_name(period[:name])};")
-        end
-      end
-    end
-
-    def ensure_report_table_exist(report, period)
-      unless report.table_exist?(period)
-        table_name  = report.table_name(period)
-        sql         = report.sql('0000-00-00 00:00:00', '0000-00-00 00:00:00', period)
+      [:today, :day, :week, :calendar_week, :month, :calendar_month].each do |period|
+        next unless report.wants_period?(period)
+      
+        unless report.table_exist?(period)
+          table_name  = report.table_name(period)
+          sql         = report.sql('0000-00-00 00:00:00', '0000-00-00 00:00:00', period)
 
-        exec("create table #{table_name} ENGINE=InnoDB default CHARSET=utf8 as #{sql} limit 0;")
+          exec("create table #{table_name} ENGINE=InnoDB default CHARSET=utf8 as #{sql} limit 0;")
+        end
       end
     end
     
@@ -186,46 +175,152 @@ module Reportme
           exec("insert into #{report_information_table_name} values ('#{table_name}', '#{von}', '#{bis}', now());")
           exec("insert into #{table_name} select #{column_names.join(',')} from #{report.table_name(:day)} as d where d.von between '#{von}' and '#{(_von + num_days.days).strftime("%Y-%m-%d 00:00:00")}';")
 
-          notify_subscriber(report.name, period_name, _von)
+          self.class.notify_subscriber(report.name, period_name, _von)
         end
       end
     end
     
-    def run
-    
-      @init.call              if @init
-      @since = Date.today     unless @since
+    def validate_dependencies
+      @@reports.each do |r|
+        r.dependencies.each do |d|
+          raise "report #{r.name} depends on non existing report #{d}" unless self.class.has_report?(d)
+        end
+      end
+    end
     
-      ensure_report_informations_table_exist
-      
+    def __fill_periods_queue(since)
       periods_queue = []
       
-      while !@since.future?
-        ReportFactory.periods(@since).each do |period|
+      loop do
+        ReportFactory.periods(since).each do |period|
           periods_queue << period
         end
-        @since += 1.day
+        since += 1.day
+        break if since.future?
+      end 
+      
+      periods_queue
+    end
+    
+    def run(since=Date.today)
+    
+      raise "since cannot be in the future" if since.future?
+
+      begin
+        @@init.call              if @@init
+    
+        ensure_report_informations_table_exist
+      
+        validate_dependencies
+
+        run_dependency_aware(@@reports) do |report|
+          ensure_report_tables_exist(report)
+        end
+      
+        periods_queue = __fill_periods_queue(since)
+      
+        # we will generate all daily reports first.
+        # this will speed up generation of weekly and monthly reports.
+      
+        self.class.__sort_periods(periods_queue).each do |period|
+        
+          run_dependency_aware(@@reports) do |report|
+            __report_period(report, period)
+          end
+        
+        end
+      ensure
+        @@reports.each do |report|
+          
+          if report.temporary?
+            [:today, :day, :week, :calendar_week, :month, :calendar_month].each do |period|
+              
+              table_name = report.table_name(period)
+              
+              exec("delete from #{report_information_table_name} where report = '#{table_name}';")
+              exec("drop table if exists #{table_name};")
+              
+            end
+          end
+          
+        end
       end
       
-      # we will generate all daily reports first.
-      # this will speed up generation of weekly and monthly reports.
+    end
+    
+    def run_dependency_aware(reports, &block)
+
+      dependencies = __dependency_hash
+      reports = reports.dup
       
-      periods_queue.reject{|p| p[:name] != :day}.each do |period|
-        report_period(period)
+      while true
+
+        break if reports.blank?
+
+        num_run = 0
+
+        reports.each do |r|
+
+          unless dependencies[r.name].blank?
+            puts "report ['#{r.name}'] waits on dependencies: #{dependencies[r.name].collect{|d|d.name}.join(',')}"
+            next
+          end
+
+          block.call(r)
+
+          dependencies.each_pair do |key, values|
+
+            if values.include?(r)
+              # puts "remove '#{r[:name]}' from '#{key}' list of dependencies"
+              values.delete(r)
+            end
+          end
+
+          num_run += 1
+          reports.delete(r)
+
+        end
+
+        raise "deadlock" if num_run == 0
+
       end
+      
+    end
+
+    def self.__sort_periods(periods)
+      
+      sorting = {
+        :today          => 99,
+        :day            => 1,
+        :week           => 2,
+        :calendar_week  => 3,
+        :month          => 4,
+        :calendar_month => 5
+      }
+      
+      periods.sort{|a, b| sorting[a[:name]] <=> sorting[b[:name]]}
+      
+    end
 
-      periods_queue.reject{|p| p[:name] == :day}.each do |period|
-        report_period(period)
+    def __dependency_hash
+      dependencies = {}
+      @@reports.each do |r|
+        
+        dependencies[r.name] = []
+        
+        r.dependencies.each do |d|
+          dependencies[r.name] << self.class.report_by_name(d)
+        end
       end
       
+      dependencies
     end
   
-    def report_period(period)
-      @reports.each do |r|
+    def __report_period(r, period)
       
-        period_name = period[:name]
+      period_name = period[:name]
       
-        next unless r.wants_period?(period_name)
+      if r.wants_period?(period_name)
 
         _von = period[:von]
         _bis = period[:bis]
@@ -239,8 +334,6 @@ module Reportme
         sql           = r.sql(von, bis, period_name)
     
         puts "report: #{r.table_name(period_name)} von: #{von}, bis: #{bis}"
-
-        ensure_report_table_exist(r, period_name)
         
         report_exists = report_exists?(table_name, von, bis)
         
@@ -257,30 +350,35 @@ module Reportme
         if !report_exists || period_name == :today
           ActiveRecord::Base.transaction do
             exec("insert into #{report_information_table_name} values ('#{table_name}', '#{von}', '#{bis}', now());") unless report_exists
-        
-            if period_name == :today
-              exec("truncate #{table_name};")
-            end
+
+            exec("truncate #{table_name};") if period_name == :today
           
             exec("insert into #{table_name} #{sql};")
             
-            notify_subscriber(r.name, period_name, _von)
+            self.class.notify_subscriber(r.name, period_name, _von)
           end
         end
 
-    
       end
       
     end
-  
+
     def exec(sql)
+      self.class.exec(sql)
+    end
+  
+    def self.exec(sql)
       puts "// ------------------------"
       puts "exec: #{sql}"
       puts "------------------------ //"
       ActiveRecord::Base.connection.execute(sql)
     end
-    
+
     def select_value(sql)
+      self.class.select_value(sql)
+    end
+    
+    def self.select_value(sql)
       puts "// ------------------------"
       puts "select_value: #{sql}"
       puts "------------------------ //"
@@ -288,6 +386,10 @@ module Reportme
     end
 
     def select_one(sql)
+      self.class.select_one(sql)
+    end
+    
+    def self.select_one(sql)
       puts "// ------------------------"
       puts "select_one: #{sql}"
       puts "------------------------ //"
@@ -295,6 +397,10 @@ module Reportme
     end
 
     def select_all(sql)
+      self.class.select_all(sql)
+    end
+
+    def self.select_all(sql)
       puts "// ------------------------"
       puts "select_all: #{sql}"
       puts "------------------------ //"
@@ -302,6 +408,10 @@ module Reportme
     end
 
     def select_rows(sql)
+      self.class.select_rows(sql)
+    end
+    
+    def self.select_rows(sql)
       puts "// ------------------------"
       puts "select_rows: #{sql}"
       puts "------------------------ //"
@@ -309,32 +419,40 @@ module Reportme
     end
 
     def select_values(sql)
+      self.class.select_values(sql)
+    end
+    
+    def self.select_values(sql)
       puts "// ------------------------"
       puts "select_values: #{sql}"
       puts "------------------------ //"
       ActiveRecord::Base.connection.select_values(sql)
     end
 
-    def has_subscribtion?(report_name)
-      !@subscribtions[report_name].blank?
+    def self.has_subscribtion?(report_name)
+      !@@subscribtions[report_name].blank?
+    end
+    
+    def self.report_by_name(report_name)
+      @@reports.find{|r|r.name == report_name}
     end
   
-    def has_report?(report_name)
-      !@reports.find{|r|r.name == report_name}.blank?
+    def self.has_report?(report_name)
+      !@@reports.find{|r|r.name == report_name}.blank?
     end
   
-    def subscribe(report_name, &block)
+    def self.subscribe(report_name, &block)
       report_name = report_name.to_sym
       
       raise "report: #{report_name} does not exist" unless has_report?(report_name)
       
-      existing = @subscribtions[report_name] || (@subscribtions[report_name] = [])
+      existing = @@subscribtions[report_name] || (@@subscribtions[report_name] = [])
       existing << block
     end
     
-    def notify_subscriber(report_name, period, von)
+    def self.notify_subscriber(report_name, period, von)
       
-      (@subscribtions[report_name] || []).each do |subscription|
+      (@@subscribtions[report_name] || []).each do |subscription|
         begin
           subscription.call(period, von)
         rescue Exception => e
@@ -344,14 +462,14 @@ module Reportme
       
     end
   
-    def report(name, &block)
+    def self.report(name, temporary=false, &block)
       
       name = name.to_sym
       
-      r = Report.new(self, name)
+      r = Report.new(self, name, temporary)
       r.instance_eval(&block)
     
-      @reports << r
+      @@reports << r
     end
   
   end

data/test/reportme_test.rb

@@ -16,55 +16,73 @@ class ReportmeTest < Test::Unit::TestCase
         )
     SQL
   end
+
+  class TestReport < Reportme::ReportFactory
+  end
   
   def create_visit_report_factory(opts={})
     
     defaults = {
       :periods => [],
-      :since => DateTime.now
+      :init => lambda {}
     }
     
     opts = defaults.merge(opts)
     
-    @rme = Reportme::ReportFactory.create do
-      
-      since  opts[:since]
-      connection :adapter => "mysql", :database => "report_me_test", :username => "root", :password => "root", :host => "localhost", :port => 3306
-      
-      report :visits do
-        periods opts[:periods]
-        source do |von, bis|
-          <<-SQL
-          select
-            '#{von}' as von,
-            date(created_at) as datum,
-            channel,
-            count(1) as cnt
-          from
-            visits
-          where
-            created_at between '#{von}' and '#{bis}'
-          group by
-            date(created_at),
-            channel
-          SQL
-        end
+    TestReport.connection :adapter => "mysql", :database => "report_me_test", :username => "root", :password => "root", :host => "localhost", :port => 3306
+    TestReport.init do
+      opts[:init].call
+    end
+    TestReport.report :visits do
+      periods opts[:periods]
+      source do |von, bis|
+        <<-SQL
+        select
+          '#{von}' as von,
+          date(created_at) as datum,
+          channel,
+          count(1) as cnt
+        from
+          visits
+        where
+          created_at between '#{von}' and '#{bis}'
+        group by
+          date(created_at),
+          channel
+        SQL
       end
     end
-    @rme
+    
+    @rme = TestReport.new
+    
   end
   
   def exec(sql)
+    puts "exec: #{sql}"
     ActiveRecord::Base.connection.execute(sql)
   end
 
   def one(sql)
+    puts "one: #{sql}"
     ActiveRecord::Base.connection.select_one(sql)
   end
 
   def teardown
     unless @debug
-      @rme.reset if @rme
+      exec("drop table if exists report_informations;")
+    
+      [:today, :day, :week, :calendar_week, :month, :calendar_month].each do |period|
+      
+        TestReport.reports_value.each do |report|
+          exec("drop table if exists #{report.table_name(period)};")
+        end
+      end
+    
+      TestReport.reports_reset
+      TestReport.init_reset
+      TestReport.subscribtions_reset
+      TestReport.properties_reset
+
       exec("truncate visits;");
     end
   end
@@ -82,6 +100,7 @@ class ReportmeTest < Test::Unit::TestCase
     assert_equal 2, one("select cnt from visits_today where channel = 'sem' and datum = curdate()")["cnt"].to_i
   end
   
+  
   should "create visitors in the today report for channel sem and seo" do
     exec("insert into visits values (null, 'sem', now())");
     exec("insert into visits values (null, 'sem', now())");
@@ -126,6 +145,7 @@ class ReportmeTest < Test::Unit::TestCase
   
   should "create a daily report for the previous 3 days" do
   
+  
     #should be ignored
     exec("insert into visits values (null, 'sem', curdate());");
   
@@ -137,7 +157,7 @@ class ReportmeTest < Test::Unit::TestCase
     # should be ignored
     exec("insert into visits values (null, 'sem', date_sub(curdate(), interval 5 day));");
   
-    create_visit_report_factory(:since => 3.days.ago,:periods => [:day]).run
+    create_visit_report_factory(:periods => [:day]).run(3.days.ago)
     assert_equal 4, one("select count(1) as cnt from visits_day where von between date_sub(curdate(), interval 4 day) and date_sub(curdate(), interval 1 day)")["cnt"].to_i
   end
   
@@ -159,10 +179,12 @@ class ReportmeTest < Test::Unit::TestCase
     # should be ignored in weekly
     exec("insert into visits values (null, 'sem', date_sub(curdate(), interval 9 day));");
   
-    create_visit_report_factory(:since => 10.days.ago, :periods => [:day]).run
+    create_visit_report_factory(:periods => [:day]).run(10.days.ago)
     
     exec("truncate visits;")
   
+    Reportme::ReportFactory.init_reset
+  
     create_visit_report_factory(:periods => [:week]).run
   
     assert_equal 7, one("select count(1) as cnt from visits_week where date(von) between date_sub(curdate(), interval 7 day) and date_sub(curdate(), interval 1 day)")["cnt"].to_i
@@ -320,7 +342,7 @@ class ReportmeTest < Test::Unit::TestCase
   
     assert_equal '2009-04-01 00:00:00'.to_datetime, periods[:calendar_month][:von]
     assert_equal '2009-04-30 23:59:59'.to_datetime, periods[:calendar_month][:bis]
-
+  
     ##
     # today
     ##
@@ -333,7 +355,7 @@ class ReportmeTest < Test::Unit::TestCase
     assert_equal "#{today.strftime('%Y-%m-%d')} 23:59:59".to_datetime, periods[:today][:bis]
     
   end
-
+  
   should "create the calendar_weekly report by using 7 daily reports" do
     
     today = '2009-06-24'
@@ -353,58 +375,84 @@ class ReportmeTest < Test::Unit::TestCase
     exec("insert into visits values (null, 'sem', date_sub('#{today}', interval 9 day));");
     # should be ignored in weekly
     exec("insert into visits values (null, 'sem', date_sub('#{today}', interval 10 day));");
+  
+    create_visit_report_factory(:periods => [:day]).run(15.days.ago)
+  
+    exec("truncate visits;")
+  
+    Reportme::ReportFactory.init_reset
 
-    create_visit_report_factory(:since => 15.days.ago, :periods => [:day]).run
+    d1 = Date.today
+    d2 = today.to_date
+  
+    num_days = 0
 
-    exec("truncate visits;")
+    while d2.past?
+      d2 += 1.day
+      num_days += 1
+    end
+  
+    create_visit_report_factory(:periods => [:calendar_week]).run(num_days.days.ago)
   
-    create_visit_report_factory(:periods => [:calendar_week]).run
+    day_lastweek = today.to_date - 7.days
+    
+    monday = day_lastweek - (day_lastweek.cwday - 1).days
+  
+    von, bis = [monday, monday + 6.days]
+  
+    von = von.to_datetime
+    bis = bis.to_datetime + 23.hours + 59.minutes + 59.seconds
   
-    assert_equal 7, one("select count(1) as cnt from visits_calendar_week where von between '2009-06-15 00:00:00' and '2009-06-21 00:00:00'")["cnt"].to_i
+    sql = "select count(1) as cnt from visits_calendar_week where von between '#{von.strftime('%Y-%m-%d 00:00:00')}' and '#{bis.strftime('%Y-%m-%d 23:59:59')}'"
+    
+#    assert_equal 7, one("select count(1) as cnt from visits_calendar_week where von between '2009-06-15 00:00:00' and '2009-06-21 00:00:00'")["cnt"].to_i
+    assert_equal 7, one(sql)["cnt"].to_i
     
   end
-
+  
   should "probe existing reports" do
     rme = create_visit_report_factory
-    assert rme.has_report?(:visits)
-    assert !rme.has_report?(:some_not_existing_report)
+    assert rme.class.has_report?(:visits)
+    assert !rme.class.has_report?(:some_not_existing_report)
   end
-
+  
   should "subscribe to visits report" do
     rme = create_visit_report_factory
-    rme.subscribe :visits do
+    rme.class.subscribe :visits do
     end
-    assert rme.has_subscribtion?(:visits)
+    assert rme.class.has_subscribtion?(:visits)
   end
   
   should "fail on subscribtion to not existing report" do
     rme = create_visit_report_factory
     assert_raise RuntimeError do 
-      rme.subscribe :some_not_existing_report do
+      rme.class.subscribe :some_not_existing_report do
       end
     end
   end
   
   should "notify subscriptions" do
     notifed = false
-
+  
     rme = create_visit_report_factory
-    rme.subscribe :visits do
+    rme.class.subscribe :visits do
       notifed = true
     end
     
-    rme.notify_subscriber(:visits, :day, '2009-01-01'.to_datetime)
+    rme.class.notify_subscriber(:visits, :day, '2009-01-01'.to_datetime)
     
     assert notifed
   end
   
   should "call initializer before running reports" do
     initialized = false
-
-    rme = create_visit_report_factory
-    rme.init do
-      initialized = true
-    end
+  
+    rme = create_visit_report_factory({
+      :init => lambda {
+        initialized = true
+      }
+    })
+  
     rme.run
     
     assert initialized
@@ -412,26 +460,115 @@ class ReportmeTest < Test::Unit::TestCase
   end
   
   should "fail when multiple init blocks are defined" do
-
+  
     rme = create_visit_report_factory
-    rme.init do
-    end
     
     assert_raise RuntimeError do
-      rme.init do
+      rme.class.init do
       end
     end
   end
   
-  should "fail on multiple since calls" do
+  should "fail on non existing report dependencies" do
+  
+    class ReportDependencyTestReport < Reportme::ReportFactory
+      connection :adapter => "mysql", :database => "report_me_test", :username => "root", :password => "root", :host => "localhost", :port => 3306
+      report :report1 do
+        depends_on [:report2]
+      end
+    end
     
-    rme = create_visit_report_factory
-    # 'since' will be implicitly called by ower testing factory method above
-    # any further call should fails
-
     assert_raise RuntimeError do
-      rme.since 20.days.ago
+      ReportDependencyTestReport.new.validate_dependencies
+    end
+  end
+  
+  should "return a report by name" do
+    class ReportByNameTestReport < Reportme::ReportFactory
+      connection :adapter => "mysql", :database => "report_me_test", :username => "root", :password => "root", :host => "localhost", :port => 3306
+      report :report1 do
+      end
+      report :report2 do
+      end
     end
+  
+    assert :report1, ReportByNameTestReport.report_by_name(:report1).name
+    assert :report2, ReportByNameTestReport.report_by_name(:report2).name
+    
+  end
+  
+  should "compute a dependency hash" do
+    class ReportDependencyHashTestReport < Reportme::ReportFactory
+      connection :adapter => "mysql", :database => "report_me_test", :username => "root", :password => "root", :host => "localhost", :port => 3306
+      report :report1 do
+        depends_on [:report2, :report3]
+      end
+      report :report2 do
+        depends_on [:report3]
+      end
+      report :report3 do
+      end
+    end
+    
+    hash = ReportDependencyHashTestReport.new.__dependency_hash
+    
+    assert [
+      ReportDependencyHashTestReport.report_by_name(:report2),
+      ReportDependencyHashTestReport.report_by_name(:report3)
+      ], hash[:report1]
+  
+    assert [
+      ReportDependencyHashTestReport.report_by_name(:report3)
+      ], hash[:report2]
+  
+    assert [], hash[:report3]
+  end
+  
+  should "sort some periods" do
+    assert [:day, :today], Reportme::ReportFactory.__sort_periods([{:name => :today}, {:name => :day}])
+    assert [:day, :week, :today], Reportme::ReportFactory.__sort_periods([{:name => :today}, {:name => :day}, {:name => :week}])
+    assert [:day, :week], Reportme::ReportFactory.__sort_periods([{:name => :week}, {:name => :day}])
+    assert [:day, :week, :month, :calendar_month, :today], Reportme::ReportFactory.__sort_periods([{:name => :week}, {:name => :day}, {:name => :today}, {:name => :calendar_month}, {:name => :month}])
+    
+    assert [:day, :week, :week, :today, :today], Reportme::ReportFactory.__sort_periods([{:name => :week}, {:name => :today}, {:name => :today}, {:name => :week}, {:name => :day}])
+  end
+  
+  should "run reports in a dependency aware manner" do
+    class ReportDependencyAwareTestReport < Reportme::ReportFactory
+      connection :adapter => "mysql", :database => "report_me_test", :username => "root", :password => "root", :host => "localhost", :port => 3306
+      report :report1 do
+        depends_on [:report2, :report3]
+      end
+      report :report2 do
+        depends_on [:report3]
+      end
+      report :report3 do
+      end
+    end
+    
+    runned = []
+    
+    reports = []
+    reports << ReportDependencyAwareTestReport.report_by_name(:report1)
+    reports << ReportDependencyAwareTestReport.report_by_name(:report2)
+    reports << ReportDependencyAwareTestReport.report_by_name(:report3)
+    
+    ReportDependencyAwareTestReport.new.run_dependency_aware(reports) do |report|
+      runned << report.name
+    end
+    
+    assert [:report3, :report2, :report1], runned
+    
+  end
+  
+  should "prefix tablename with tmp_ for temporary reports" do
+    class ReportTemporaryTestReport < Reportme::ReportFactory
+      connection :adapter => "mysql", :database => "report_me_test", :username => "root", :password => "root", :host => "localhost", :port => 3306
+      report :report1, :temporary => true do
+      end
+    end
+    
+    assert "tmp_report1_day", ReportTemporaryTestReport.report_by_name(:report1).table_name(:day)
   end
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jzimmek-reportme
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 0.4.0
 platform: ruby
 authors: 
 - Jan Zimmek
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-27 00:00:00 -07:00
+date: 2009-06-29 00:00:00 -07:00
 default_executable: 
 dependencies: []