arake 0.0.1 → 0.0.2

data/lib/arake.rb

@@ -8,56 +8,69 @@ require 'watchr'
 
 module ARake
   class Application
-    attr_accessor :accumulated_args
-
     def initialize(top_level_self)
+      @_rake = nil
+      @_watchr = nil
+      @_watchr_script = nil
       @top_level_self = top_level_self
-      @accumulated_args = []
+    end
 
-      hook_task_definition
+    def run
+      original_Rake_application = Rake.application
+      begin
+        Rake.application = rake
+
+        Rake.application.run
+        watchr.run
+      ensure
+        Rake.application = original_Rake_application
+      end
     end
 
-    def hook_task_definition
-      a = self
-      (class << @top_level_self; self; end).class_eval do
-        include Rake::TaskManager
+    # Misc.
 
-        # FIXME: How about other rake tasks?
-        define_method :file do |*args, &block|
-          super *args, &block
-          a.accumulate_args *resolve_args(args), &block
-        end
-      end
+    def rake
+      @_rake ||= CustomRakeAppliation.new
+    end
+
+    def rake_tasks
+      rake.tasks
     end
 
-    def accumulate_args(*args, &block)
-      @accumulated_args.push [*args, block]
+    def watchr
+      @_watchr ||= _create_custom_watchr
     end
 
-    def create_custom_watchr
+    def _create_custom_watchr
+      Watchr::Controller.new(watchr_script, Watchr.handler.new)
+    end
+
+    def watchr_rules
+      watchr_script.rules
+    end
+
+    def watchr_script
+      @_watchr_script ||= _create_custom_watchr_script
+    end
+
+    def _create_custom_watchr_script
       a = self
       s = Watchr::Script.new
       (class << s; self; end).class_eval do
         define_method :parse! do
           @ec.instance_eval do
-            a.accumulated_args.each do |pattern, arg_names, deps, block|
-              deps.each do |d|
-                watch "^#{Regexp.escape d}$", &block
+            a.rake_tasks.each do |t|
+              t.prerequisites.each do |p|
+                watch "^#{Regexp.escape p}$" do
+                  a.rake.reenable_all_tasks
+                  a.rake.invoke_root_tasks_of(t)
+                end
               end
             end
           end
         end
       end
-      Watchr::Controller.new(s, Watchr.handler.new)
-    end
-
-    def load_rakefiles
-      CustomRakeAppliation.new.run
-    end
-
-    def run
-      load_rakefiles
-      create_custom_watchr.run
+      s
     end
   end
 
@@ -70,6 +83,67 @@ module ARake
         # run whenever dependents are updated.
       end
     end
+
+    def reenable_all_tasks
+      tasks.each do |t|
+        t.reenable
+      end
+    end
+
+    def invoke_root_tasks_of(task)
+      root_tasks_of(task).each do |t|
+        t.invoke
+      end
+    end
+
+    def root_tasks_of(task)
+      Misc.root_tasks_of task, tasks
+    end
+  end
+
+  module Misc
+    def self.root_tasks_of(task, tasks)
+      tree_from_task(task, pt_table_from_tasks(tasks)).leaves
+    end
+
+    def self.pt_table_from_tasks(tasks)  # prerequisite-to-target table
+      h = Hash.new {|h, name| h[name] = []}
+      tasks.each do |target_task|
+        target_task.prerequisites.each do |prerequisite|
+          h[prerequisite.to_s].push target_task
+        end
+      end
+      h
+    end
+
+    def self.tree_from_task(task, table = Hash.new {|h, key| h[key] = []})
+      t = Tree.new
+      t.value = task
+      t.subtrees = table[task.to_s].map {|x| tree_from_task x, table}
+      t
+    end
+
+    class Tree
+      attr_accessor :value
+      attr_accessor :subtrees
+
+      def initialize(value = nil, subtrees = [])
+        @value = value
+        @subtrees = subtrees
+      end
+
+      def leaf?
+        subtrees.empty?
+      end
+
+      def leaves
+        if leaf?
+          [value]
+        else
+          subtrees.map{|s| s.leaves}.inject :+
+        end
+      end
+    end
   end
 end
 

data/spec/arake_spec.rb

@@ -0,0 +1,397 @@
+#!/usr/bin/env rspec
+
+require 'arake'
+require 'stringio'
+require 'tmpdir'
+
+# $ mount
+# /dev/disk0s2 on / (hfs, local, journaled)
+# devfs on /dev (devfs, local)
+# fdesc on /dev (fdesc, union)
+# map -hosts on /net (autofs, automounted)
+# map auto_home on /home (autofs, automounted)
+# 
+# $ ruby -e 'p (Dir.glob "/a", File::FNM_CASEFOLD)'
+# -e:1:in `glob': invalid byte sequence in US-ASCII (ArgumentError)
+#         from -e:1:in `<main>'
+# 
+# $ ruby --version
+# ruby 1.9.2p180 (2011-02-18 revision 30909) [i386-darwin9.8.0]
+File::FNM_CASEFOLD = 0
+
+def with_argv(*args, &block)
+  original_ARGV = ARGV.dup
+
+  ARGV.clear
+  ARGV.push *args
+
+  block.call
+
+  ARGV.clear
+  ARGV.push *original_ARGV
+end
+
+def with_rakefile(rakefile_content, &block)
+  Dir.mktmpdir do |d|
+    rakefile = "#{d}/Rakefile"
+    File.open rakefile, 'w' do |io|
+      io.write rakefile_content
+    end
+    with_argv *['-f', rakefile] do
+      block.call
+    end
+  end
+end
+
+def with_rake_application(rake_application, &block)
+  original_Rake_application = Rake.application
+  begin
+    Rake.application = rake_application
+    block.call
+  ensure
+    Rake.application = original_Rake_application
+  end
+end
+
+def with_rake(rake_application, rakefile_content, &block)
+  with_rakefile rakefile_content do
+    with_rake_application rake_application do
+      block.call
+    end
+  end
+end
+
+def redirect(stdout = $stdout, &block)
+  _stdout = $stdout
+  begin
+    $stdout = stdout
+    block.call
+  ensure
+    $stdout = _stdout
+  end
+end
+
+top_level_self = self
+
+
+
+
+describe ARake::CustomRakeAppliation do
+  it 'should read rakefiles but should not run any specified targets' do
+    rakefile_content = <<-"END"
+      p 'outer#{self.object_id}'
+      task :default do
+        p 'inner#{self.object_id}'
+      end
+    END
+    with_rake ARake::CustomRakeAppliation.new, rakefile_content do
+      s = String.new
+      redirect (StringIO.new s) do
+        Rake.application.run
+      end
+
+      (s.index "outer#{self.object_id}").should_not be_nil
+      (s.index "inner#{self.object_id}").should be_nil
+    end
+  end
+end
+
+
+
+
+describe ARake::Application do
+  def re(s)
+    "^#{Regexp.escape s}$"
+  end
+
+  it 'should not affect the default Rake.application' do
+    oa = Rake.application
+    a = ARake::Application.new top_level_self
+    with_rake_application a.rake do
+      oa.tasks.should be_empty
+      a.rake_tasks.should be_empty
+
+      block = Proc.new {}
+      top_level_self.instance_eval do
+        task 'bar1'
+        task 'bar2'
+        task 'baz1'
+        task 'baz2'
+        task 'foo1' => ['bar1', 'baz1'], &block
+        task 'foo2' => ['bar2', 'baz2'], &block
+      end
+
+      oa.tasks.should be_empty
+      a.rake_tasks.should_not be_empty
+    end
+  end
+
+  it 'should be able to refer tasks' do
+    a = ARake::Application.new top_level_self
+    with_rake_application a.rake do
+      a.rake_tasks.should be_empty
+
+      block = Proc.new {}
+      top_level_self.instance_eval do
+        task 'bar1'
+        task 'bar2'
+        task 'baz1'
+        task 'baz2'
+        task 'foo1' => ['bar1', 'baz1'], &block
+        task 'foo2' => ['bar2', 'baz2'], &block
+      end
+
+      a.rake_tasks.should_not be_empty
+      a.rake_tasks[-2].to_s.should eql 'foo1'
+      a.rake_tasks[-2].prerequisites.should eql ['bar1', 'baz1']
+      a.rake_tasks[-2].actions.should eql [block]
+      a.rake_tasks[-1].to_s.should eql 'foo2'
+      a.rake_tasks[-1].prerequisites.should eql ['bar2', 'baz2']
+      a.rake_tasks[-1].actions.should eql [block]
+    end
+  end
+
+  it 'should define a watch rule for each dependent' do
+    a = ARake::Application.new top_level_self
+    with_rake_application a.rake do
+      a.rake_tasks.should be_empty
+      a.watchr_rules.should be_empty
+
+      block = Proc.new {}
+      top_level_self.instance_eval do
+        task 'bar1'
+        task 'bar2'
+        task 'baz1'
+        task 'baz2'
+        task 'foo1' => ['bar1', 'baz1'], &block
+        task 'foo2' => ['bar2', 'baz2'], &block
+      end
+      a.watchr_script.parse!
+
+      a.rake_tasks.should_not be_empty
+      a.watchr_rules.should_not be_empty
+      a.watchr_rules[0].pattern.should eql re('bar1')
+      a.watchr_rules[1].pattern.should eql re('baz1')
+      a.watchr_rules[2].pattern.should eql re('bar2')
+      a.watchr_rules[3].pattern.should eql re('baz2')
+    end
+  end
+
+  it 'should invoke a rake task with proper parameters' do
+    a = ARake::Application.new top_level_self
+    with_rake_application a.rake do
+      passed_task = nil
+      block = Proc.new {|task| passed_task = task}
+      top_level_self.instance_eval do
+        task 'bar'
+        task 'foo' => 'bar', &block
+      end
+      a.watchr_script.parse!
+      r = a.watchr_rules[0]
+
+      r.pattern.should eql re('bar')
+      passed_task.should be_nil
+
+      r.action.call
+      t = a.rake_tasks[1]
+
+      t.to_s.should eql 'foo'
+      passed_task.should equal t
+    end
+  end
+
+  it 'should execute rake tasks even if they are already executed before' do
+    a = ARake::Application.new top_level_self
+    with_rake_application a.rake do
+      call_count = 0
+      block = Proc.new {call_count += 1}
+      top_level_self.instance_eval do
+        task :dependent
+        task :target => :dependent, &block
+      end
+      a.watchr_script.parse!
+      r = a.watchr_rules[0]
+
+      r.pattern.should eql re(:dependent)
+      call_count.should eql 0
+
+      r.action.call
+
+      call_count.should eql 1
+
+      r.action.call
+
+      call_count.should eql 2
+    end
+  end
+
+  it 'should execute chained tasks properly' do
+    a = ARake::Application.new top_level_self
+    with_rake_application a.rake do
+      calling_history = []
+      block = Proc.new {|t| calling_history.push t.to_s}
+      top_level_self.instance_eval do
+        # t1a t1b t1c
+        #  |\  |   |
+        #  | \ |   |
+        #  |  \|   |
+        # t2a t2b t2c
+        #  |   |  /|
+        #  |   | / |
+        #  |   |/  |
+        # t3a t3b t3c
+        task :t1a => [:t2a, :t2b], &block
+        task :t1b => [:t2b], &block
+        task :t1c => [:t2c], &block
+        task :t2a => [:t3a], &block
+        task :t2b => [:t3b], &block
+        task :t2c => [:t3b, :t3c], &block
+        task :t3a => [], &block
+        task :t3b => [], &block
+        task :t3c => [], &block
+      end
+      a.watchr_script.parse!
+      rules_table = Hash.new {|h, key| h[key] = []}
+      a.watchr_rules.each do |r|
+        rules_table[r.pattern].push r
+      end
+      def rules_table.trigger(task_name)
+        self[task_name].each do |r|
+          r.action.call
+        end
+      end
+
+      rules_table.keys.sort.should eql [
+        re(:t2a),
+        re(:t2b),
+        re(:t2c),
+        re(:t3a),
+        re(:t3b),
+        re(:t3c),
+      ]
+      calling_history.should be_empty
+
+      calling_history.clear
+      rules_table.trigger re(:t3c)
+
+      calling_history.sort.should eql %w[t1c t2c t3b t3c]
+
+      calling_history.clear
+      rules_table.trigger re(:t2c)
+
+      calling_history.sort.should eql %w[t1c t2c t3b t3c]
+
+      calling_history.clear
+      rules_table.trigger re(:t3b)
+
+      calling_history.sort.should eql %w[
+        t1a t1b t1c t2a t2b t2c t3a t3b t3b t3c
+      ]
+
+      calling_history.clear
+      rules_table.trigger re(:t2b)
+
+      calling_history.sort.should eql %w[t1a t1b t2a t2b t2b t3a t3b t3b]
+
+      calling_history.clear
+      rules_table.trigger re(:t3a)
+
+      calling_history.sort.should eql %w[t1a t2a t2b t3a t3b]
+
+      calling_history.clear
+      rules_table.trigger re(:t2a)
+
+      calling_history.sort.should eql %w[t1a t2a t2b t3a t3b]
+    end
+  end
+end
+
+
+
+
+describe ARake::Misc do
+  Tree = ARake::Misc::Tree
+
+  it 'should create an empty instance' do
+    t = Tree.new
+    t.value.should be_nil
+    t.subtrees.should be_empty
+
+    t.leaf?.should be_true
+    t.leaves.should eql [nil]
+  end
+
+  it 'should return values of leaves' do
+    t = Tree.new(
+      1,
+      [
+        Tree.new(2),
+        Tree.new(
+          3,
+          [Tree.new(4)]
+        ),
+        Tree.new(5),
+      ]
+    )
+
+    t.leaves.should eql [2, 4, 5]
+  end
+
+  it 'should return a tree of tasks based on their dependencies' do
+    def task(name, *prerequisites)
+      t = Rake::Task.new name, Rake::Application.new
+      t.enhance prerequisites
+      t
+    end
+
+    # t1a t1b t1c
+    #   \ /|   |
+    #    X |   |
+    #   / \|   |
+    # t2a t2b t2c
+    #  |   |  /|
+    #  |   | / |
+    #  |   |/  |
+    # t3a t3b t3c
+    #      |
+    #      |
+    #      |
+    #     t4b
+    t4b = task 't4b'
+    t3c = task 't3c'
+    t3b = task 't3b', t4b
+    t3a = task 't3a'
+    t2c = task 't2c', t3b, t3c
+    t2b = task 't2b', t3b
+    t2a = task 't2a', t3a
+    t1c = task 't1c', t2c
+    t1b = task 't1b', t2a, t2b
+    t1a = task 't1a', t2b
+
+    tasks = [
+      t1a,
+      t1b,
+      t1c,
+      t2a,
+      t2b,
+      t2c,
+      t3a,
+      t3b,
+      t3c,
+      t4b,
+    ]
+
+    ARake::Misc.root_tasks_of(t1a, tasks).should eql [t1a]
+    ARake::Misc.root_tasks_of(t1b, tasks).should eql [t1b]
+    ARake::Misc.root_tasks_of(t1c, tasks).should eql [t1c]
+    ARake::Misc.root_tasks_of(t2a, tasks).should eql [t1b]
+    ARake::Misc.root_tasks_of(t2b, tasks).should eql [t1a, t1b]
+    ARake::Misc.root_tasks_of(t2c, tasks).should eql [t1c]
+    ARake::Misc.root_tasks_of(t3a, tasks).should eql [t1b]
+    ARake::Misc.root_tasks_of(t3b, tasks).should eql [t1a, t1b, t1c]
+    ARake::Misc.root_tasks_of(t3c, tasks).should eql [t1c]
+    ARake::Misc.root_tasks_of(t4b, tasks).should eql [t1a, t1b, t1c]
+  end
+end
+
+__END__

metadata

@@ -2,7 +2,7 @@
 name: arake
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Kana Natsuno
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-04 00:00:00 +09:00
+date: 2011-05-06 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -59,6 +59,7 @@ files:
 - arake.gemspec
 - bin/arake
 - lib/arake.rb
+- spec/arake_spec.rb
 has_rdoc: true
 homepage: http://github.com/kana/ruby-arake
 licenses: []