facets 1.7.46 → 1.8.0

data/work/yore/reap.yml

@@ -0,0 +1,47 @@
+
+prepare: !!custom
+  desc: Redirect, extact tests and test
+  deps: [ 'redirect', 'extest', 'test' ]
+
+package: !!package
+  dir: 'srv/package'
+  distribute: [ tar.gz, zip ] # gem
+
+release: !!release
+  dir        : 'srv/package'
+  host       : rubyforge.org
+  username   : transami
+  project    : facets
+  groupid    : 804
+  package    : Facets
+
+announce: !!announce
+  to      : transfire@gmail.com #ruby-talk@ruby-lang.org
+  from    : transfire@gmail.com
+  domain  : jupiterzeus.net
+  server  : smtp.gmail.com
+  port    : 25 #587
+  account : transfire@gmail.com
+  auth    : login  #cram_md5 #plain
+  secure  : tls # ~, tls, ssl
+  file    : doc/LATEST
+  slogan  : ALL YOUR BASE ARE BELONG TO RUBY!
+  links:
+    - http://facets.rubyforge.org
+
+count: !!count
+  include: 'lib/**/*'
+
+setup: !!setup
+
+changelog: !!changelog
+  file: doc/CHANGELOG
+
+version: !!version
+  file: meta/version
+
+test: !!test
+
+extest: !!extest
+  files: 'lib/facets/**/*.rb'
+

data/work/yore/taskable-old.rb

@@ -0,0 +1,519 @@
+# = 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.
+#
+# == Auhtor(s)
+#
+# * Thomas Sawyer
+
+# Author::    Thomas Sawyer
+# Copyright:: Copyright (c) 2006 Thomas Sawyer
+# License::   Ruby License
+
+require 'tsort'
+
+$main = self
+
+# = TSort
+#
+# TSort is used to determine which prerequisites to run
+# for a task.
+#
+# Here we add a convenience method --if such a long method
+# name can be said to be convenient ;) Although we ended
+# not using it after all --it still may proved useful and
+# may eventually be added to Facets or submitted as a patch.
+
+module TSort
+  def strongly_connected_components_from(node)
+    result = []
+    each_strongly_connected_component_from(node) do |component|
+      result << component
+    end
+    result
+  end
+end
+
+# = Task
+#
+# A Task is a Method with prerequisite dependencies.
+#
+# NOTE Can't subclass Method b/c Method has no initiator.
+# Not sure that would be a good idea anyway.
+
+class Task
+  attr_accessor :description
+
+  def self.instance( method )
+p method
+    initialize( )
+  end
+
+  def initialize( name, container, preq, desc=nil, &action )
+    @name = name
+    @container = container
+    @prerequisite = preq || []
+    @description = desc
+    @action = action
+  end
+
+  def prerequisite
+    @prerequisite ||= []
+  end
+
+#   #--
+#   # TODO Problem is 'a' can't take any parameters,
+#   #      and there's no way to sort the tasks
+#   #      from here. FIX if possible.
+#   #++
+#   def to_proc
+#     r = @prerequisite
+#     n = @name
+#     a = @action
+#     lambda {
+#       r.each{ |d| send(d) unless n == d }
+#       instance_eval &a if a
+#     }
+#   end
+
+  def complete
+    # ensure no cycles in the graph and extract call graph
+    # TODO what about singletons?
+    t = Graph.new( container, name )
+    t.each_strongly_connected_component_from( name ) do |c|
+      #@container.instance_task(c).call
+      @container.send("->#{d}")
+    end
+  end
+
+  def call
+    @action.call
+  end
+
+  def each(&blk)
+    @prerequisite.each(&blk)
+  end
+
+  # Task::Graph is a Tarjan-sorted hash.
+  # It is used to generate the proper dependency chains.
+  # TODO Make Multiton off of base.
+
+  class Graph < Hash
+    include TSort
+
+    def initialize( base, name )
+      #if base == $main
+      #  @base = Object #(class << base; self; end)
+      #else
+        @base = base #.class
+      #end
+      @name = name
+      #instance_map( name )
+    end
+
+    def instance_map( name=nil )
+      name = name || @name
+      task = nil
+      unless @base.ancestors.find { |anc| task = anc.instance_task(name) }
+        raise "task does not exist -- #{name} in #{@base}"
+      end
+      self[name] = task.prerequisite || []
+      self[name].each { |r| instance_map( r ) }
+    end
+
+    def list
+      instance_map
+      self
+    end
+
+    alias :tsort_each_node :each_key
+
+    def tsort_each_child(node, &block)
+      fetch(node).each(&block)
+    end
+  end
+
+end
+
+# = 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 parameters
+# if they are to be used as prerequisites.
+# This capability might be added in the future, but
+# presently syntax limitations make it awkward.
+#
+# To use Taskable at the top level do:
+#
+#   include Taskable
+#
+
+module Taskable
+
+  def self.included( base )
+    if base == Object
+      $main.instance_eval {
+
+        def define_method( meth, &block )
+          Object.class_eval do
+            define_method( meth, &block )
+            private meth
+          end
+        end
+
+        def ancestors(*args)
+          Object.ancestors(*args)
+        end
+
+        def instance_method(*args)
+          Object.instance_method(*args)
+        end
+      }
+    end
+  end
+
+  # Provide a mapping of tasks, including task from ancestors.
+  # TODO Not sure this is properly reading from ancestors.
+
+  # 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
+
+  # Define a task.
+
+  def task(args, &action)
+    if Hash === args
+      raise ArgumentError, "#{args.size} for 1" if args.size != 1
+      name, *deps = *(args.to_a.flatten)
+      name = name.to_sym
+      deps = deps.compact.collect{ |e| e.to_sym }
+    else
+      name, deps = args.to_sym, []
+    end
+    # create task by creating core and callable methods.
+    # We do it this way b/c otherwise we'd have to use
+    # instance_eval and then can't pass paramaters (TODO fix w/Ruby 1.9).
+    if action
+      define_method( "->#{name}", &action ) # core of the task
+      define_method( name ) do |*args|
+        r = nil
+        # ensure no cycles in the graph and extract call graph
+        # TODO what about singleton tasks?
+        todo = Task::Graph.new( self.class, name )
+        todo.list.each_strongly_connected_component_from( name ) do |c|
+          r = send("->#{c}", *args)
+        end
+        r
+      end
+      #cont = (self == $main ? Object : self )
+      #cont = self
+      instance_task_table[name] = Task.new( name, self, deps, desc!, &action )
+    elsif name and deps
+      if m = instance_task(name)
+        #m.description = desc!  # TODO should this apply only if there is an action?
+        m.prerequisite.concat deps unless deps.empty?
+        m
+      else
+        #define_method( "->#{name}", lambda{} )  # empty action
+        define_method( name ) do |*args|
+          r = nil
+          # ensure no cycles in the graph and extract call graph
+          # TODO what about singleton tasks?
+          todo = Task::Graph.new( self.class, name )
+          todo.list.each_strongly_connected_component_from( name ) do |c|
+            r = send("->#{c}", *args) unless "#{c}" == "#{name}"
+          end
+          r
+        end
+        #cont = (self == $main ? Object : self )
+        #cont = self
+        instance_task_table[name] = Task.new( name, self, deps, desc!, &action )
+      end
+    #else
+    #  Task.instance( method(m) )
+    end
+  end
+
+  # Access a task.
+
+  def instance_task( name )
+    name = name.to_sym
+    if instance_task_table and r = instance_task_table[name]
+      return r
+    end
+    ancestors.each do |anc|
+      itt = anc.instance_task_table #instance_variable_get("@instance_task_table")
+      if itt and r = itt[name]
+        return r
+      end
+    end
+    nil
+  end
+
+  # List of task names.
+
+  def instance_tasks( include_ancestors=true )
+    if include_ancestors and ancestors #and ancestors[1]
+      a = []
+      ancestors.each do |anc|
+        a |= anc.instance_task_table.keys 
+      end
+      return a
+    else
+      instance_task_table.keys
+    end
+  end
+
+ protected
+
+  def instance_task_table
+    if self == $main
+      Object.instance_task_table
+    else
+      @instance_task_table ||= {}
+    end
+  end
+
+  # TODO deprecate these two methods?
+
+ public
+
+  # List of task names with descriptions.
+
+  def described_tasks
+    instance_tasks.select { |name| instance_task(name).description }
+  end
+
+  # List of task names without descriptions.
+
+  def undescribed_tasks
+    instance_tasks.select { |name| ! instance_task(name).description }
+  end
+
+end
+
+# Include the Task module into the Module class.
+
+class Module
+  include Taskable
+end
+
+#class Object
+#  def send_task( name )
+#    (class << self; self; end).instance_task( name )
+#  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
+
+    # TODO Appearently extending does play well with inheritor?
+    # F = Module.new { extend O }
+
+    # 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( RuntimeError ) { e.e1 }
+      #assert_equal( [ 'c1', 'e1' ], e.x )
+    end
+
+    def test_E2
+      e = E.new
+      assert_raises( RuntimeError ) { 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
+