jandot-biorake 1.0

data/README.textile

@@ -0,0 +1,122 @@
+h1. Why?
+
+There is some interest in the bioinformatics community for using rake
+as a workflow tool (see e.g. this "blog post from BioinformaticsZen":http://www.bioinformaticszen.com/2008/05/organised-bioinformatics-exp
+).
+
+Rake could be ideal for this type of work: a typical workflow will
+take data and perform a first set of conversions on it (i.e. a task),
+followed by a second set of conversions (that is dependent on the
+first task), and so on. And obviously, bioinformaticians want to keep their data
+in databases rather than files...
+
+A typical Rakefile could look like this:
+<pre>
+ task :001_load_data do
+   <load data in database>
+ end
+
+ task :002_calculate_averages => [:001_load_data] do
+   <update data in database>
+ end
+
+ task :003_make_histogram_of_averages => [:002_calculate_averages] do
+   <do stuff>
+ end
+</pre>
+
+The trouble is that there is no way yet to check whether a task has to
+be rerun or not, because there are no timestamps. Regular rake will
+rerun all three tasks from the example above, regardless if some of
+them have already been completed.
+
+BioRake adds this task timestamp functionality to rake for working with 
+databases. The functionality needed is very similar to the one available for
+FileTasks.
+
+So if we had reloaded the data (001), the timestamp for that task in a
+metadata would be later than the one for task 002. As a result, task
+002 would automatically have to be rerun if we were to run task 003.
+
+h1. Implementation
+
+I've started to implement an additional type of task, called
+*event*. The above snippet from a Rakefile would actually contain
+
+<pre>
+ event :001_load_data do
+   ...
+ end
+ 
+ event :002_calculated_averages => [:001_load_data] do
+   ...
+ end
+</pre>
+instead of using the *task* tag.
+
+Similar to a FileTask, *timestamps* are used to check if certain tasks
+have to be re-run or not. FileTasks have the advantage that every file
+has a timestamp.  To implement this the metadata of event completion
+times is stored in the .rake directory inside the current directory.
+
+A *event task* automatically:
+
+# checks the metadata to see if the task has already been run
+# if so: are there any prerequisites with timestamps that are newer than the task
+itself?
+# (re)run the task if necessary
+# update the metadata
+
+To re-run all tasks from scratch issue a Rake::EventTask.clean or simply 
+<pre>
+rm -rf .rake
+</pre>
+to reset the metadata to before any events have occured.
+
+h1. Status
+
+Even though the tests seem to run and I've tried some things out, I
+can't guarantee production-level stability (well: call it beta). Use
+at your own risk.
+
+h1. Sample
+
+The sample/ directory contains an example Rakefile. Suppose a
+researcher has intensities for a group of individuals on a number of
+probes.  This information should be loaded into a database with the
+tables _individuals_, _probes_ and _intensities_.
+
+As the _intensities_ table contains foreign keys for individual and
+probe, the _individuals_ and _probes_ tables have to be loaded
+*before* the intensities can be loaded.
+
+In rake-speak, this would look like:
+<pre>
+event :load_probes do
+  _load the actual data_
+end
+
+event :load_individuals do
+  _load the actual data_
+end
+
+event :load_intensities => [:load_probes, :load_individuals] do
+  _load the actual data_
+end
+</pre>
+
+In a later step, the researcher might want to calculate the average
+intensity per probe. This would be a new task that depends on the
+intensities being loaded:
+
+<pre>
+event :calculate_averages => [:load_intensities] do
+  _calculate averages and store in probes table_
+end
+</pre>
+
+Here, we call the database that will contain the data _sample.sqlite3_. The 
+ _metadata_ about completed events is stored in the .rake directory.
+
+Try a _rake -T_...
+

data/Rakefile

@@ -0,0 +1,10 @@
+task :default => :test
+
+desc "Run all the tests"
+task :test do
+  Dir.chdir("test") do
+    ruby "test_event_task.rb"
+    ruby "test_event_task_timestamps.rb"
+    ruby "test_event_task_with_file.rb"
+  end
+end

data/biorake.gemspec

@@ -0,0 +1,42 @@
+Gem::Specification.new do |s|
+  s.name = 'biorake'
+  s.version = "1.0"
+ 
+  s.authors = ["Jan Aerts","Charles Comstock"]
+  s.email = "jan.aerts at gmail.com"
+  s.homepage = "http://github.com/jandot/biorake"
+  s.summary = "Extension to rake to allow for timestamp usage on tasks that don't alter files"
+  s.description = "Extension to rake to allow for timestamp usage on tasks that don't alter files (e.g. loading data in a database)"
+ 
+  s.platform = Gem::Platform::RUBY
+  s.files = [
+      "biorake.gemspec",
+      "lib/biorake.rb",
+      "Rakefile",
+      "README.textile",
+      "sample/individuals.txt",
+      "sample/intensities.txt",
+      "sample/probes.txt",
+      "sample/Rakefile",
+      "test/capture_stdout.rb",
+      "test/event_task_creation.rb",
+      "test/file_creation.rb",
+      "test/test_event_task.rb",
+      "test/test_event_task_timestamps.rb",
+      "test/test_event_task_with_file.rb"
+    ]
+ 
+  s.add_dependency('rake')
+  
+  s.has_rdoc = false
+  
+  s.test_files = [
+      "test/test_event_task.rb",
+      "test/test_event_task_timestamps.rb",
+      "test/test_event_task_with_file.rb"
+    ]
+  
+  s.require_path = 'lib'
+  s.autorequire = 'rake'
+ 
+end

data/lib/biorake.rb

@@ -0,0 +1,77 @@
+require 'rubygems'
+require 'rake'
+
+module Rake
+
+  # #########################################################################
+  # An EventTask is a task that includes time based dependencies with no
+  # associated file. Timestamps are contained in the .rake
+  # directory. If any of a DataTask's prerequisites have a timestamp
+  # that is later than the represented by this task, then the file
+  # must be rebuilt (using the supplied actions).
+  #
+  class EventTask < FileTask
+
+    # Is this data task needed?  Yes if it doesn't exist, or if its time stamp
+    # is out of date.
+    def needed?
+      return true if !File.exist?(taskfn)
+      return true if out_of_date?(timestamp)
+      false
+    end
+
+    # Time stamp for data task.
+    def timestamp      
+      if(File.exist?(taskfn))
+        File.mtime(taskfn)
+      else
+        Rake::EARLY
+      end
+    end
+
+    def execute(args=nil)
+      super(args)
+      # And save the timestamp in storage
+      EventTask.touch(name.to_s)
+    end
+
+    private
+
+    def taskfn
+      ".rake/"+name.to_s
+    end
+
+    # ----------------------------------------------------------------
+    # Task class methods.
+    #
+    class << self
+      # Apply the scope to the task name according to the rules for this kind
+      # of task.  File based tasks ignore the scope when creating the name.
+      def scope_name(scope, task_name)
+        task_name
+      end
+
+      def touch(fn)
+        FileUtils.mkdir_p ".rake"
+        FileUtils.touch ".rake/#{fn}"
+      end
+
+      def clean
+        FileUtils.rm_rf ".rake"
+      end
+    end
+  end # class Rake::EventTask
+end
+
+# Declare an event task.
+#
+# Example:
+#   event :load_probes => [:load_individuals] do
+#     File.open("my_file.txt").each do |line|
+#       probe_name, individual_id = line.chomp.split(/\t/)
+#       Probe.new(:name => probe_name, :individual_id => individual_id).new.save
+#     end
+#   end
+def event(*args, &block)
+  Rake::EventTask.define_task(*args, &block)
+end

data/sample/Rakefile

@@ -0,0 +1,108 @@
+require '../lib/biorake.rb'
+begin
+  require 'rubygems'
+  require 'dm-core'
+rescue LoadError
+  raise LoadError, "You must have dm-core installed to run the sample (www.datamapper.org)"
+end
+
+DataMapper.setup(:default, 'sqlite3:sample.sqlite3')
+
+class Probe
+  include DataMapper::Resource
+  
+  property :id, Integer, :serial => true
+  property :name, String
+  property :avg, Float
+  
+  has n, :intensities
+  has n, :individuals, :through => :intensities
+end
+
+class Individual
+  include DataMapper::Resource
+  
+  property :id, Integer, :serial => true
+  property :name, String
+  
+  has n, :intensities
+  has n, :probes, :through => :intensities
+end
+
+class Intensity
+  include DataMapper::Resource
+  
+  property :id, Integer, :serial => true
+  property :probe_id, Integer
+  property :individual_id, Integer
+  property :value, Float
+  
+  belongs_to :probe
+  belongs_to :individual
+end
+
+task :default => [:calculate_averages]
+
+desc "Create the database" 
+event :create_database do
+  STDERR.puts "Creating the database..."
+  Probe.auto_migrate! 
+  Individual.auto_migrate! 
+  Intensity.auto_migrate! 
+end
+
+desc 'Rebuild'
+task :rebuild => [:clean, :calculate_averages] do
+  STDERR.puts "Rebuilding the whole dataset..."
+end
+
+desc "start from scratch"
+task :clean do
+  rm_rf "sample.sqlite3"
+  Rake::EventTask.clean
+end
+
+desc 'Load probes from file'
+event :load_probes => ['probes.txt',:create_database] do
+  STDERR.puts "Loading probes..."
+  Probe.all.destroy!
+  File.open('probes.txt').each do |line|
+    probe_name = line.chomp
+    Probe.new(:name => probe_name).save
+  end
+end
+
+desc 'Load individuals from file'
+event :load_individuals => ['individuals.txt',:create_database] do
+  STDERR.puts "Loading individuals..."
+  Individual.all.destroy!
+  File.open('individuals.txt').each do |line|
+    ind_name = line.chomp
+    Individual.new(:name => ind_name).save
+  end
+end
+
+desc 'Load intensities from file'
+event :load_intensities => ['intensities.txt', :load_probes, :load_individuals] do
+  STDERR.puts "Loading intensities..."
+  Intensity.all.destroy!
+  File.open('intensities.txt').each do |line|
+    probe_name, ind_name, value = line.chomp.split(/\t/)
+    probe = Probe.first(:name => probe_name)
+    ind = Individual.first(:name => ind_name)
+    Intensity.new(:probe_id => probe.id, :individual_id => ind.id, :value => value.to_f).save
+  end
+end
+
+desc 'Calculate averages for probes'
+event :calculate_averages => [:load_intensities] do
+  STDERR.puts "Calculating averages..."
+  Probe.all.each do |probe|
+    sum = 0
+    probe.intensities.each do |i|
+      sum += i.value
+    end
+    probe.avg = sum.to_f/probe.intensities.length.to_f
+    probe.save
+  end
+end

data/sample/individuals.txt

@@ -0,0 +1,5 @@
+ind_1
+ind_2
+ind_3
+ind_4
+ind_5

data/sample/intensities.txt

@@ -0,0 +1,25 @@
+probe_1	ind_1	836
+probe_1	ind_2	729
+probe_1	ind_3	872
+probe_1	ind_4	534
+probe_1	ind_5	739
+probe_2	ind_1	152
+probe_2	ind_2	630
+probe_2	ind_3	826
+probe_2	ind_4	917
+probe_2	ind_5	1027
+probe_3	ind_1	710
+probe_3	ind_2	720
+probe_3	ind_3	891
+probe_3	ind_4	710
+probe_3	ind_5	280
+probe_4	ind_1	820
+probe_4	ind_2	720
+probe_4	ind_3	918
+probe_4	ind_4	812
+probe_4	ind_5	710
+probe_5	ind_1	928
+probe_5	ind_2	817
+probe_5	ind_3	918
+probe_5	ind_4	710
+probe_5	ind_5	918	

data/sample/probes.txt

@@ -0,0 +1,5 @@
+probe_1
+probe_2
+probe_3
+probe_4
+probe_5

data/test/capture_stdout.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'stringio'
+
+# Mix-in for capturing standard output.
+module CaptureStdout
+  def capture_stdout
+    s = StringIO.new
+    oldstdout = $stdout
+    $stdout = s
+    yield
+    s.string
+  ensure
+    $stdout = oldstdout
+  end
+
+  def capture_stderr
+    s = StringIO.new
+    oldstderr = $stderr
+    $stderr = s
+    yield
+    s.string
+  ensure
+    $stderr = oldstderr
+  end
+end

data/test/event_task_creation.rb

@@ -0,0 +1,23 @@
+module EventTaskCreation
+
+  def create_timed_event_tasks(old_task, *new_tasks)
+    return if File.exist?(".rake/"+old_task.to_s) && new_tasks.all? { |new_task| File.exist?(new_task) }
+
+    old_time = create_task(old_task)
+    new_tasks.each do |new_task|
+      while create_task(new_task) <= old_time + 0.00001
+        sleep(0.5)
+        delete_task(new_task.to_s)
+      end
+    end
+  end
+
+  def create_task(name)
+    Rake::EventTask.touch(name.to_s)
+    return File.mtime(".rake/"+name.to_s)
+  end
+
+  def delete_task(name)
+    File.delete(".rake/"+name.to_s) rescue nil
+  end
+end

data/test/file_creation.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+module FileCreation
+  OLDFILE = "testdata/old"
+  NEWFILE = "testdata/new"
+
+  def create_timed_files(oldfile, *newfiles)
+    return if File.exist?(oldfile) && newfiles.all? { |newfile| File.exist?(newfile) }
+    old_time = create_file(oldfile)
+    newfiles.each do |newfile|
+      while create_file(newfile) <= old_time
+        sleep(0.1)
+        File.delete(newfile) rescue nil
+      end
+    end
+  end
+
+  def create_dir(dirname)
+    FileUtils.mkdir_p(dirname) unless File.exist?(dirname)
+    File.stat(dirname).mtime
+  end
+
+  def create_file(name)
+    create_dir(File.dirname(name))
+    FileUtils.touch(name) unless File.exist?(name)
+    File.stat(name).mtime
+  end
+
+  def delete_file(name)
+    File.delete(name) rescue nil
+  end
+end

data/test/test_event_task.rb

@@ -0,0 +1,384 @@
+#!/usr/bin/env ruby
+require 'pathname'
+
+require 'test/unit'
+#require 'fileutils'
+require '../lib/biorake'
+require 'file_creation.rb'
+require 'capture_stdout.rb'
+require 'event_task_creation'
+
+
+module Interning
+  private
+
+  def intern(name, *args)
+    Rake.application.define_task(Rake::EventTask, name, *args)
+  end
+end
+
+######################################################################
+class EventTestTask < Test::Unit::TestCase
+  include CaptureStdout
+  include Rake
+  include Interning
+  include EventTaskCreation
+
+  def setup
+    EventTask.clear
+  end
+
+  def test_create
+    arg = nil
+    t = intern(:name).enhance { |task| arg = task; 1234 }
+    assert_equal "name", t.name
+    assert_equal [], t.prerequisites
+    assert t.prerequisites.is_a?(FileList)
+    assert t.needed?
+    t.execute(0)
+    assert_equal t, arg
+    assert_nil t.source
+    assert_equal [], t.sources
+  end
+
+  def test_inspect
+    t = intern(:foo).enhance([:bar, :baz])
+    assert_equal "<Rake::EventTask foo => [bar, baz]>", t.inspect
+  end
+
+  def test_invoke
+    runlist = []
+    t1 = intern(:t1).enhance([:t2, :t3]) { |t| runlist << t.name; 3321 }
+    t2 = intern(:t2).enhance { |t| runlist << t.name }
+    t3 = intern(:t3).enhance { |t| runlist << t.name }
+    assert_equal [:t2, :t3], t1.prerequisites
+    t1.invoke
+    assert_equal ["t2", "t3", "t1"], runlist
+  end
+
+  def test_invoke_with_circular_dependencies
+    runlist = []
+    t1 = intern(:t1).enhance([:t2]) { |t| runlist << t.name; 3321 }
+    t2 = intern(:t2).enhance([:t1]) { |t| runlist << t.name }
+    assert_equal [:t2], t1.prerequisites
+    assert_equal [:t1], t2.prerequisites
+    ex = assert_raise RuntimeError do
+      t1.invoke
+    end
+    assert_match(/circular dependency/i, ex.message)
+    assert_match(/t1 => t2 => t1/, ex.message)
+  end
+
+  def test_dry_run_prevents_actions
+    Rake.application.options.dryrun = true
+    runlist = []
+    t1 = intern(:t1).enhance { |t| runlist << t.name; 3321 }
+    out = capture_stdout { t1.invoke }
+    assert_match(/execute .*t1/i, out)
+    assert_match(/dry run/i, out)
+    assert_no_match(/invoke/i, out)
+    assert_equal [], runlist
+  ensure
+    Rake.application.options.dryrun = false
+  end
+
+  def test_tasks_can_be_traced
+    Rake.application.options.trace = true
+    t1 = intern(:t1) { |t| runlist << t.name; 3321 }
+    out = capture_stdout {
+      t1.invoke
+    }
+    assert_match(/invoke t1/i, out)
+    assert_match(/execute t1/i, out)
+  ensure
+    Rake.application.options.trace = false
+  end
+
+  def test_no_double_invoke
+    runlist = []
+    t1 = intern(:t1).enhance([:t2, :t3]) { |t| runlist << t.name; 3321 }
+    t2 = intern(:t2).enhance([:t3]) { |t| runlist << t.name }
+    t3 = intern(:t3).enhance { |t| runlist << t.name }
+    t1.invoke
+    assert_equal ["t3", "t2", "t1"], runlist
+  end
+
+  def test_find
+    event :tfind
+    assert_equal "tfind", EventTask[:tfind].name
+    ex = assert_raise(RuntimeError) { EventTask[:leaves] }
+    assert_equal "Don't know how to build task 'leaves'", ex.message
+    delete_task(:tfind)
+  end
+
+  def test_defined
+    assert ! EventTask.task_defined?(:a)
+    event :a
+    assert EventTask.task_defined?(:a)
+    delete_task :a
+  end
+
+  def test_multi_invocations
+    runs = []
+    p = proc do |t| runs << t.name end
+    event({:t1=>[:t2,:t3]}, &p)
+    event({:t2=>[:t3]}, &p)
+    event(:t3, &p)
+    EventTask[:t1].invoke
+    assert_equal ["t1", "t2", "t3"], runs.sort
+    delete_task :t1
+    delete_task :t2
+    delete_task :t3
+  end
+
+  def test_task_list
+    task :t2
+    task :t1 => [:t2]
+    assert_equal ["t1", "t2"], Task.tasks.collect {|t| t.name}
+  end
+
+  def test_task_gives_name_on_to_s
+    task :abc
+    assert_equal "abc", Task[:abc].to_s
+  end
+
+  def test_symbols_can_be_prerequisites
+    task :a => :b
+    assert_equal ["b"], Task[:a].prerequisites
+  end
+
+  def test_strings_can_be_prerequisites
+    task :a => "b"
+    assert_equal ["b"], Task[:a].prerequisites
+  end
+
+  def test_arrays_can_be_prerequisites
+    task :a => ["b", "c"]
+    assert_equal ["b", "c"], Task[:a].prerequisites
+  end
+
+  def test_filelists_can_be_prerequisites
+    task :a => FileList.new.include("b", "c")
+    assert_equal ["b", "c"], Task[:a].prerequisites
+  end
+
+  def test_investigation_output
+    t1 = intern(:t1).enhance([:t2, :t3]) { |t| runlist << t.name; 3321 }
+    intern(:t2)
+    intern(:t3)
+    out = t1.investigation
+    assert_match(/class:\s*Rake::EventTask/, out)
+    assert_match(/needed:\s*true/, out)
+    assert_match(/pre-requisites:\s*--t2/, out)
+  end
+
+
+  def test_extended_comments
+    desc %{
+      This is a comment.
+
+      And this is the extended comment.
+      name -- Name of task to execute.
+      rev  -- Software revision to use.
+    }
+    t = intern(:t, :name, :rev)
+    assert_equal "[name,rev]", t.arg_description
+    assert_equal "This is a comment.", t.comment
+    assert_match(/^\s*name -- Name/, t.full_comment)
+    assert_match(/^\s*rev  -- Software/, t.full_comment)
+    assert_match(/\A\s*This is a comment\.$/, t.full_comment)
+  end
+  
+  def test_multiple_comments
+    desc "line one"
+    t = intern(:t)
+    desc "line two"
+    intern(:t)
+    assert_equal "line one / line two", t.comment
+  end
+
+  def test_settable_comments
+    t = intern(:t)
+    t.comment = "HI"
+    assert_equal "HI", t.comment
+  end
+
+  def teardown
+    EventTask.clean
+  end
+
+end
+
+#####################################################################
+class TestTaskWithArguments < Test::Unit::TestCase
+  include CaptureStdout
+  include Rake
+  include Interning
+  include EventTaskCreation
+
+  def setup
+    EventTask.clear
+  end
+
+  def test_no_args_given
+    t = event :t
+    assert_equal [], t.arg_names
+    delete_task :t
+  end
+
+  def test_args_given
+    t = event :t, :a, :b
+    assert_equal [:a, :b], t.arg_names
+    delete_task :t
+  end
+
+  def test_name_and_needs
+    t = event(:t => [:pre])
+    assert_equal "t", t.name
+    assert_equal [], t.arg_names
+    assert_equal ["pre"], t.prerequisites
+    delete_task :t
+    delete_task :pre
+  end
+
+  def test_name_and_explicit_needs
+    t = event(:t, :needs => [:pre])
+    assert_equal "t", t.name
+    assert_equal [], t.arg_names
+    assert_equal ["pre"], t.prerequisites
+    delete_task :t
+  end
+
+  def test_name_args_and_explicit_needs
+    t = event(:t, :x, :y, :needs => [:pre])
+    assert_equal "t", t.name
+    assert_equal [:x, :y], t.arg_names
+    assert_equal ["pre"], t.prerequisites
+    delete_task :t
+    delete_task :pre
+  end
+
+  def test_illegal_keys_in_task_name_hash
+    assert_raise RuntimeError do
+      t = event(:t, :x, :y => 1, :needs => [:pre])
+    end
+    delete_task :pre
+  end
+
+  def test_arg_list_is_empty_if_no_args_given
+    t = intern(:t).enhance do |tt, args|
+      assert_equal({}, args.to_hash)
+    end
+    t.invoke(1, 2, 3)
+  end
+
+  def test_tasks_can_access_arguments_as_hash
+    t = event :t, :a, :b, :c do |tt, args|
+      assert_equal({:a => 1, :b => 2, :c => 3}, args.to_hash)
+      assert_equal 1, args[:a]
+      assert_equal 2, args[:b]
+      assert_equal 3, args[:c]
+      assert_equal 1, args.a
+      assert_equal 2, args.b
+      assert_equal 3, args.c
+    end
+    t.invoke(1, 2, 3)
+    delete_task :t
+  end
+
+  def test_actions_of_various_arity_are_ok_with_args
+    notes = []
+    t = intern(:t, :x).enhance do
+      notes << :a
+    end
+    t.enhance do | |
+      notes << :b
+    end
+    t.enhance do |task|
+      notes << :c
+      assert_kind_of EventTask, task
+    end
+    t.enhance do |t2, args|
+      notes << :d
+      assert_equal t, t2
+      assert_equal({:x => 1}, args.to_hash)
+    end
+    assert_nothing_raised do t.invoke(1) end
+    assert_equal [:a, :b, :c, :d], notes
+  end
+
+  def test_arguments_are_passed_to_block
+    t = intern(:t, :a, :b).enhance { |tt, args|
+      assert_equal( { :a => 1, :b => 2 }, args.to_hash )
+    }
+    t.invoke(1, 2)
+  end
+
+  def test_extra_parameters_are_ignored
+    t = intern(:t, :a).enhance { |tt, args|
+      assert_equal 1, args.a
+      assert_nil args[2]
+    }
+    t.invoke(1, 2)
+  end
+
+  def test_arguments_are_passed_to_all_blocks
+    counter = 0
+    t = event :t, :a
+    event :t do |tt, args|
+      assert_equal 1, args.a
+      counter += 1
+    end
+    event :t do |tt, args|
+      assert_equal 1, args.a
+      counter += 1
+    end
+    t.invoke(1)
+    assert_equal 2, counter
+    delete_task :t
+  end
+
+  def test_block_with_no_parameters_is_ok
+    t = intern(:t).enhance { }
+    t.invoke(1, 2)
+  end
+
+  def test_name_with_args
+    desc "T"
+    t = intern(:tt, :a, :b)
+    assert_equal "tt", t.name
+    assert_equal "T", t.comment
+    assert_equal "[a,b]", t.arg_description
+    assert_equal "tt[a,b]", t.name_with_args
+    assert_equal [:a, :b],t.arg_names
+  end
+
+  def test_named_args_are_passed_to_prereqs
+    value = nil
+    pre = intern(:pre, :rev).enhance { |t, args| value = args.rev }
+    t = intern(:t, :name, :rev).enhance([:pre])
+    t.invoke("bill", "1.2")
+    assert_equal "1.2", value
+  end
+
+  def test_args_not_passed_if_no_prereq_names
+    pre = intern(:pre).enhance { |t, args|
+      assert_equal({}, args.to_hash)
+      assert_equal "bill", args.name
+    }
+    t = intern(:t, :name, :rev).enhance([:pre])
+    t.invoke("bill", "1.2")
+  end
+
+  def test_args_not_passed_if_no_arg_names
+    pre = intern(:pre, :rev).enhance { |t, args|
+      assert_equal({ :rev => nil }, args.to_hash)
+    }
+    t = intern(:t).enhance([:pre])
+    t.invoke("bill", "1.2")
+  end
+  
+  def teardown
+    EventTask.clean
+  end
+end

data/test/test_event_task_timestamps.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require '../lib/biorake'
+require 'event_task_creation'
+require 'yaml'
+
+class TestEventTaskTimeStamp < Test::Unit::TestCase
+  include Rake
+  include EventTaskCreation
+
+  def setup
+    EventTask.clear
+    @runs = Array.new
+  end
+
+  def test_names
+    event :names_1
+    event :names_2 => :names_1
+    event_task_1 = EventTask[:names_1]
+    event_task_2 = EventTask[:names_2]
+    assert_equal 'names_1', event_task_1.name
+    assert_equal 'names_2', event_task_2.name
+  end
+  
+  def test_event_need
+    name_1 = :event_need_1
+    event name_1
+    event_task = EventTask[name_1]
+    assert_equal name_1.to_s, event_task.name
+
+    name_2 = :event_need_2
+    event name_2
+    event_task = EventTask[name_2]
+    assert event_task.needed?, 'task should be needed'
+
+    EventTask.touch(name_2.to_s)
+    assert_equal nil, event_task.prerequisites.collect{|n| EventTask[n].timestamp}.max
+    assert ! event_task.needed?, "task should not be needed"
+  end
+
+  def test_task_times_new_depends_on_old
+    create_timed_event_tasks(:old_task_times_new_depends_on_old, :new_task_times_new_depends_on_old)
+
+    t1 = Rake.application.intern(EventTask, :new_task_times_new_depends_on_old).enhance([:old_task_times_new_depends_on_old])
+    t2 = Rake.application.intern(EventTask, :old_task_times_new_depends_on_old)
+    assert ! t2.needed?, "Should not need to build old task"
+    assert ! t1.needed?, "Should not need to rebuild new task because of old"
+  end
+  
+  def test_task_times_old_depends_on_new
+    create_timed_event_tasks(:old_task_times_old_depends_on_new, :new_task_times_old_depends_on_new)
+    
+    t1 = Rake.application.intern(EventTask, :old_task_times_old_depends_on_new).enhance([:new_task_times_old_depends_on_new])
+    t2 = Rake.application.intern(EventTask, :new_task_times_old_depends_on_new)
+    assert ! t2.needed?, "Should not need to build new task"
+    preq_stamp = t1.prerequisites.collect{|t| EventTask[t].timestamp}.max
+    assert_equal t2.timestamp, preq_stamp
+    assert t1.timestamp < preq_stamp, "T1 should be older"
+    assert t1.needed?, "Should need to rebuild old task because of new"
+  end
+
+  def test_event_depends_on_task_depend_on_data
+    create_timed_event_tasks(:old_event_depends_on_task_depend_on_event, :new_event_depends_on_task_depend_on_event)
+
+    event :new_event_depends_on_task_depend_on_event => [:obj]   do |t| @runs << t.name end
+    task :obj => [:old_event_depends_on_task_depend_on_event] do |t| @runs << t.name end
+    event :old_event_depends_on_task_depend_on_event             do |t| @runs << t.name end
+
+    Task[:obj].invoke
+    EventTask[:new_event_depends_on_task_depend_on_event].invoke
+    assert ! @runs.include?(:new_event_depends_on_task_depend_on_event)
+  end
+
+  def test_existing_event_task_depends_on_non_existing_event_task
+    create_task(:old_existing_event_task_depends_on_non_existing_event_task)
+    delete_task(:new_existing_event_task_depends_on_non_existing_event_task)
+    event :new_existing_event_task_depends_on_non_existing_event_task
+    event :old_existing_event_task_depends_on_non_existing_event_task => :new_existing_event_task_depends_on_non_existing_event_task
+    assert_nothing_raised do EventTask[:old_existing_event_task_depends_on_non_existing_event_task].invoke end
+  end
+  
+  def teardown
+    EventTask.clean
+  end
+end

data/test/test_event_task_with_file.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+require 'pathname'
+
+require 'test/unit'
+#require 'fileutils'
+require '../lib/biorake'
+require 'file_creation.rb'
+require 'capture_stdout.rb'
+require 'event_task_creation'
+
+
+module Interning
+  private
+
+  def event_intern(name, *args)
+    Rake.application.define_task(Rake::EventTask, name, *args)
+  end
+  
+  def file_intern(name, *args)
+    Rake.application.define_task(Rake::FileTask, name, *args)
+  end
+
+end
+
+######################################################################
+class EventTestTask < Test::Unit::TestCase
+  include CaptureStdout
+  include Rake
+  include Interning
+  include EventTaskCreation
+
+  def setup
+    EventTask.clear
+    FileTask.clear
+  end
+
+  def test_invoke
+    runlist = []
+    t1 = event_intern(:t1).enhance([:t2, :t3]) { |t| runlist << t.name; 3321 }
+    t2 = file_intern(:t2).enhance { |t| runlist << t.name }
+    t3 = event_intern(:t3).enhance { |t| runlist << t.name }
+    assert_equal [:t2, :t3], t1.prerequisites
+    t1.invoke
+    assert_equal ["t2", "t3", "t1"], runlist
+  end
+
+  def test_invoke_with_circular_dependencies
+    runlist = []
+    t1 = event_intern(:t1).enhance([:t2]) { |t| runlist << t.name; 3321 }
+    t2 = file_intern(:t2).enhance([:t1]) { |t| runlist << t.name }
+    assert_equal [:t2], t1.prerequisites
+    assert_equal [:t1], t2.prerequisites
+    ex = assert_raise RuntimeError do
+      t1.invoke
+    end
+    assert_match(/circular dependency/i, ex.message)
+    assert_match(/t1 => t2 => t1/, ex.message)
+  end
+
+  def test_no_double_invoke
+    runlist = []
+    t1 = event_intern(:t1).enhance([:t2, :t3]) { |t| runlist << t.name; 3321 }
+    t2 = event_intern(:t2).enhance([:t3]) { |t| runlist << t.name }
+    t3 = event_intern(:t3).enhance { |t| runlist << t.name }
+    t1.invoke
+    assert_equal ["t3", "t2", "t1"], runlist
+  end
+  
+  def teardown
+    Rake::EventTask.clean
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: jandot-biorake
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- Jan Aerts
+- Charles Comstock
+autorequire: rake
+bindir: bin
+cert_chain: []
+
+date: 2008-08-13 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Extension to rake to allow for timestamp usage on tasks that don't alter files (e.g. loading data in a database)
+email: jan.aerts at gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- biorake.gemspec
+- lib/biorake.rb
+- Rakefile
+- README.textile
+- sample/individuals.txt
+- sample/intensities.txt
+- sample/probes.txt
+- sample/Rakefile
+- test/capture_stdout.rb
+- test/event_task_creation.rb
+- test/file_creation.rb
+- test/test_event_task.rb
+- test/test_event_task_timestamps.rb
+- test/test_event_task_with_file.rb
+has_rdoc: false
+homepage: http://github.com/jandot/biorake
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Extension to rake to allow for timestamp usage on tasks that don't alter files
+test_files: 
+- test/test_event_task.rb
+- test/test_event_task_timestamps.rb
+- test/test_event_task_with_file.rb