facets 1.8.49 → 1.8.51

data/work/yore/taskable.rb

@@ -1,482 +0,0 @@
-# = taskable.rb
-#
-# == Copyright (c) 2006 Thomas Sawyer
-#
-#   Ruby License
-#
-#   This module is free software. You may use, modify, and/or redistribute this
-#   software under the same terms as Ruby.
-#
-#   This program is distributed in the hope that it will be useful, but WITHOUT
-#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-#   FOR A PARTICULAR PURPOSE.
-#
-# == Author(s)
-#
-# * Thomas Sawyer
-#
-# == Developers Notes
-#
-# TODO The included call back does a comparison to Object.
-# This is a bit of a hack b/c there is actually no way to
-# check if it is the toplevel --a flaw w/ Ruby's toplevel proxy.
-
-# Author::    Thomas Sawyer
-# Copyright:: Copyright (c) 2006 Thomas Sawyer
-# License::   Ruby License
-
-$toplevel = self
-
-# = Taskable
-#
-# The Taskable module provides a generic task system
-# patterned after Rake, but useable in any
-# code context --not just with the Rake tool. In other
-# words one can create methods with dependencies.
-#
-# NOTE Unlike methods, tasks can't take independent parameters
-# if they are to be used as prerequisites. The arguments passed
-# to a task call will also be passed to it's prequisites.
-#
-# To use Taskable at the toplevel use:
-#
-#   include Taskable
-#
-# Or if you want all modules to be "taskable":
-#
-#   class Module
-#     include Taskable
-#   end
-
-module Taskable
-
-  #
-
-  def self.included( base )
-    if base == Object #$toplevel
-      require 'facets/more/main_as_module.rb'
-    end
-  end
-
-  #
-
-  def descriptions
-    @descriptions ||= {}
-  end
-
-  #
-
-  def task( name_preqs, &action )
-
-    if Hash === name_preqs
-      name = name_preqs.keys[0]
-      preqs = name_preqs.values[0]
-    else
-      name = name_preqs
-      preqs = []
-    end
-
-    descriptions[name.to_sym] = desc!
-
-    if action
-      define_method( name , &action )
-    else
-      define_method( name ) {}
-    end
-    alias_method "#{name}:task", name
-
-    preqs = preqs.collect { |q| q.to_sym }.uniq
-
-    define_method( "#{name}:preq" ) do |build|
-      return build if preqs.empty?
-      bld = [*build]
-      (preqs - build).each { |n|
-        bld.concat( send("#{n}:preq", bld) )
-        bld << n
-      }
-      bld.uniq
-    end
-
-    define_method( name ) do |*args|
-      preq = send("#{name}:preq",[])
-      raise "recursive task prerequisites" if preq.include?(name.to_sym)
-      preq.each{|n| send("#{n}:task",*args)}
-      send("#{name}:task",*args)
-    end
-
-  end
-
-  # Define description for subsequent task.
-
-  def desc(line=nil)
-    return @last_description unless line
-    @last_description = line.gsub("\n",'')
-  end
-
-  # Use up the description for subsequent task.
-
-  def desc!
-    l, @last_description = @last_description, nil
-    l
-  end
-
-  #
-
-  def instance_tasks
-    i = []
-    instance_methods.each do |name|
-      if name =~ /^(.*):task$/
-        i << $1
-      end
-    end
-    i
-  end
-
-  # List of task names with descriptions.
-
-  def described_tasks
-    instance_tasks.select { |name| descriptions[name.to_sym] }
-  end
-
-  # List of task names without descriptions.
-
-  def undescribed_tasks
-    instance_tasks.select { |name| ! descriptions[name.to_sym] }
-  end
-
-end
-
-
-module Rakeable
-
-  include Taskable
-
-  #
-  def self.included( base )
-    if base == Object #$toplevel
-      require 'facets/more/main_as_module.rb'
-    end
-  end
-
-  # <b>Build a file</b>
-  #
-  # Task must be provide instructions
-  # for building the file.
-
-  def file( file_to_source, &build )
-    if Hash === file_to_source.last
-      source = file_to_source.values.flatten
-      file   = file_to_source.keys[0]
-    end
-
-    task(file => source) do
-      needed = false
-      if File.exist?(file)
-        #source.each { |s| send(s) if respond_to?(s) }
-        timestamp = File.mtime(file)
-        needed = source.any? { |f| File.mtime(f.to_s) > timestamp }
-      else
-        timestamp = Time.now - 1
-        needed = true
-      end
-      if needed
-        build.call() #(source)
-        unless File.exist?(file) and File.mtime(file) > timestamp
-          raise "failed to build -- #{file}"
-        end
-      end
-    end
-  end
-
-  def rule(pattern_to_source, &build)
-    if Hash === file_to_source.last
-      source = file_to_source.values.flatten
-      target = file_to_source.keys[0]
-    end
-
-    @task[target] = RuleTask.new(target, source, build)
-  end
-
-  #
-
-  def task
-    super.merge(@task)
-  end
-
-  #
-
-  def tasks
-    super.merge(@task).keys
-  end
-
-  #def namespace
-  #end
-
-  def method_missing(sym)
-    target = sym.to_s
-    task = task()
-    hit = task.keys.find { |match|
-      case match
-      when Regexp
-        match =~ target
-      elsif target.index('*')
-        File.fnmatch(target, match)
-      else
-        match == target
-      end
-    }
-    if hit
-      task[hit].run(self)
-    end
-  end
-
-end
-
-#
-
-class Task
-
-  def initialize( target, source, &build )
-    @target = target
-    @source = source
-    @build  = build
-  end
-
-  def run( context )
-    task   = self
-    source = @source
-    build  = @build
-
-    context.instance_eval {
-      build.call(self)
-    end
-  end
-
-end
-
-#
-
-class FileTask < Task
-
-  def run( context )
-    task   = self
-    source = @source
-    build  = @build
-
-    context.instance_eval {
-      needed = false
-      if File.exist?(file)
-        #source.each { |s| send(s) if respond_to?(s) }
-        timestamp = File.mtime(file)
-        needed = source.any? { |f| File.mtime(f.to_s) > timestamp }
-      else
-        timestamp = Time.now - 1
-        needed = true
-      end
-      if needed
-        build.call(task)
-        unless File.exist?(file) and File.mtime(file) > timestamp
-          raise "failed to build -- #{file}"
-        end
-      end
-    end
-  end
-
-end
-
-#
-
-class RuleTask < FileTask
-
-  def run( context, target )
-    @target = name
-    super( context )
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TestTaskable1 < Test::Unit::TestCase
-
-    module M
-      task :m1 => [ :c1 ] do @x << "m1" end
-      task :m2 => [ :c2 ] do @x << "m2" end
-      task :m3 => [ :c3 ] do @x << "m3" end
-      task :m4 => [ :c1, :c2, :c3 ] do @x << "m4" end
-      task :m5 do @x << 'm5' end
-    end
-
-    class B
-      attr :x
-      def initialize ; @x = [] ; end
-
-      task :b1 do @x << "b1" end
-      task :b2 => [ :b1 ]
-    end
-
-    class C
-      include M
-      attr :x
-      def initialize ; @x = [] ; end
-
-      task :c1 do @x << "c1" end
-      task :c2 => [ :c1, :c1 ] do @x << "c2" end
-      task :c3 => [ :c1, :c2 ] do @x << "c3" end
-      task :c4 => [ :m1 ] do @x << "c4" end
-      task :c5 => [ :c5 ] do @x << "c5" end
-      task :c6 => [ :c7 ] do @x << "c6" end
-      task :c7 => [ :c6 ] do @x << "c7" end
-    end
-
-    class D < C
-      task :d1 => [ :c1 ] do @x << "d1" ; end
-      task :d2 => [ :m1 ] do @x << "d2" ; end
-    end
-
-    module N
-      include M
-    end
-
-    class E
-      include N
-      attr :x
-      def initialize ; @x = [] ; end
-
-      task :e1 => [ :c1 ] do @x << "e1" ; end
-      task :e2 => [ :m1 ] do @x << "e2" ; end
-      task :e3 => [ :m5 ] do @x << "e3" ; end
-    end
-
-    module O
-      attr :x
-      task :o1 do (@x||=[]) << "o1" end
-      task :o2 => [ :o1 ] do (@x||=[]) << "o2" end
-    end
-
-    # tests
-
-    def test_B1
-      b = B.new ; b.b1
-      assert_equal( [ 'b1' ], b.x )
-    end
-
-    def test_B2
-      b = B.new ; b.b2
-      assert_equal( [ 'b1' ], b.x )
-    end
-
-    def test_C1
-      c = C.new ; c.c1
-      assert_equal( [ 'c1' ], c.x )
-    end
-
-    def test_C2
-      c = C.new ; c.c2
-      assert_equal( [ 'c1', 'c2' ], c.x )
-    end
-
-    def test_C3
-      c = C.new ; c.c3
-      assert_equal( [ 'c1', 'c2', 'c3' ], c.x )
-    end
-
-    def test_C4
-      c = C.new ; c.c4
-      assert_equal( [ 'c1', 'm1', 'c4' ], c.x )
-    end
-
-    def test_M1
-      c = C.new ; c.m1
-      assert_equal( [ 'c1', 'm1' ], c.x )
-    end
-
-    def test_M2
-      c = C.new ; c.m2
-      assert_equal( [ 'c1', 'c2', 'm2' ], c.x )
-    end
-
-    def test_M3
-      c = C.new ; c.m3
-      assert_equal( [ 'c1', 'c2', 'c3', 'm3' ], c.x )
-    end
-
-    def test_M4
-      c = C.new ; c.m4
-      assert_equal( [ 'c1', 'c2', 'c3', 'm4' ], c.x )
-    end
-
-    def test_D1
-      d = D.new ; d.d1
-      assert_equal( [ 'c1', 'd1' ], d.x )
-    end
-
-    def test_D2
-      d = D.new ; d.d2
-      assert_equal( [ 'c1', 'm1', 'd2' ], d.x )
-    end
-
-    def test_E1
-      e = E.new
-      assert_raises( NoMethodError ) { e.e1 }
-      #assert_equal( [ 'c1', 'e1' ], e.x )
-    end
-
-    def test_E2
-      e = E.new
-      assert_raises( NoMethodError ) { e.e2 }
-      #assert_equal( [ 'c1', 'm1', 'e2' ], e.x )
-    end
-
-    def test_E3
-      e = E.new ; e.e3
-      assert_equal( [ 'm5', 'e3' ], e.x )
-    end
-
-    # def test_F1
-    #   F.o1
-    #   assert_equal( [ 'o1' ], F.x )
-    # end
-    #
-    # def test_F2
-    #   F.o2
-    #   assert_equal( [ 'o1', 'o1', 'o2' ], F.x )
-    # end
-
-  end
-
-#   ##
-#   # Test toplevel usage.
-#   #
-# 
-#   include Taskable
-# 
-#   task :foo do
-#     "foo"
-#   end
-# 
-#   task :bar => [ :foo ] do
-#     "bar"
-#   end
-# 
-#   class TestTaskable2 < Test::Unit::TestCase
-#     def test_01
-#       assert_equal( "foo", foo )
-#     end
-#     def test_01
-#       assert_equal( "bar", bar )
-#     end
-# 
-#   end
-
-=end