facets 1.7.0 → 1.7.30

data/lib/facets/more/filesystem.rb

@@ -0,0 +1,43 @@
+
+
+require 'fileutils'
+
+
+class FileSystem
+  include FileUtils
+
+  attr_reader :root
+
+  def initialize( )
+    @root = "/"
+  end
+
+  def root?(dir=nil)
+    pth = File.expand_path(dir||work)
+    return true if pth == '/'
+    return true if pth =~ /^(\w:)?\/$/
+    false
+  end 
+
+  def work; Dir.pwd; end
+
+  def ls
+    Dir.entries.collect do |f|
+      File.directory?(f) ? Dir.new(f) : File.new(f) 
+    end
+  end
+
+  # Direct access to a directory or file.
+
+  def [](name)
+    if File.directory?(name)
+      Dir.new(name)
+    elsif File.file?(name)
+      File.new(name)
+    else
+      nil
+    end
+  end
+
+end
+

data/lib/facets/more/main_as_module.rb

@@ -0,0 +1,42 @@
+# Main as Module
+
+(Module.public_instance_methods - public_methods).each do |m|
+  next if m == "initialize"
+  next if m =~ /^\W+$/
+  eval <<-END
+    def self.#{m}( *args, &block )
+      Object.class_eval do
+        #{m}( *args, &block )
+      end
+    end
+  END
+end
+
+private
+
+(Module.private_instance_methods - private_methods).each do |m|
+  next if m == "initialize"
+  next if m =~ /^\W+$/
+  eval <<-END
+    def self.#{m}( *args, &block )
+      Object.class_eval do
+        #{m}( *args, &block )
+      end
+    end
+  END
+end
+
+protected
+
+(Module.protected_instance_methods - protected_methods).each do |m|
+  next if m == "initialize"
+  next if m =~ /^\W+$/
+  eval <<-END
+    def self.#{m}( *args, &block )
+      Object.class_eval do
+        #{m}( *args, &block )
+      end
+    end
+  END
+end
+

data/lib/facets/more/taskable.rb

@@ -19,131 +19,77 @@
 # Copyright:: Copyright (c) 2006 Thomas Sawyer
 # License::   Ruby License
 
-require 'tsort'
-require 'facets/core/kernel/cache.rb'
-require 'facets/core/kernel/method.rb'
-require 'facets/more/inheritor.rb'
+$main = self
 
-# = TSort
+# = Taskable
 #
-# TSort is used to determine which prerequisites to run
-# for a task.
+# 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.
 #
-# 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
+# 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 aslo be passed to it's prequisites.
 #
-# A Task is a Method with prerequisite dependencies.
+# To use Taskable at the toplevel do:
 #
-# 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 initialize( name, container, preq, desc=nil, &action )
-    @name = name
-    @container = container
-    @prerequisite = preq || []
-    @description = desc
-    @action = action
-  end
-
-  def prerequisite
-    @prerequisite ||= []
-  end
+#   include Taskable
 
-#   #--
-#   # 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
+module Taskable
 
-  def complete
-    # ensure no cycles in the graph and extract call graph
-    #own = (class << self; self; end) # in case there are singletons?
-    t = Graph.new( container, name )
-    t.each_strongly_connected_component_from( name ) { |c|
-      #@container.instance_task(c).call
-      @container.send("->#{d}")
-    }
+  def self.included?( base )
+    if base == $main
+      require 'facets/more/main_as_module.rb'
+    end
   end
 
-  def call
-    @action.call
-  end
+  #
 
-  def each(&blk)
-    @prerequisite.each(&blk)
+  def descriptions
+    @descriptions ||= {}
   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 )
-      @base = base.class
-      @name = name
-      instance_map( name )
-    end
+  def task( name_preqs, &action )
 
-    def instance_map( name )
-      t = @base.instance_task(name)
-      raise "prerequired task does not exist -- #{name} in #{@base}" unless t
-      self[name] = t.prerequisite || []
-      self[name].each { |r| instance_map( r ) }
+    if Hash === name_preqs
+      name = name_preqs.keys[0]
+      preqs = name_preqs.values[0]
+    else
+      name = name_preqs
+      preqs = []
     end
 
-    alias_method :tsort_each_node, :each_key
+    descriptions[name.to_sym] = desc!
 
-    def tsort_each_child(node, &block)
-      fetch(node).each(&block)
+    if action
+      define_method( "->#{name}" , &action )
+    else
+      define_method( "->#{name}" ) {}
     end
-  end
 
-end
+    preqs = preqs.collect { |q| q.to_sym }.uniq
 
-# = 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.
+    define_method( "pre-#{name}" ) do |build|
+      return build if preqs.empty?
+      bld = [*build]
+      (preqs - build).each { |n|
+        bld.concat( send("pre-#{n}", bld) )
+        bld << n
+      }
+      bld.uniq
+    end
 
-module Taskable
+    define_method( name ) do |*args|
+      first = send("pre-#{name}",[])
+      raise if first.include?(name.to_sym)
+      first.each{|n| send("->#{n}",*args)}
+      send("->#{name}",*args)
+    end
 
-  # Provide a mapping of tasks, including task from ancestors.
-  # TODO Not sure this is properly reading from ancestors.
+  end
 
   # Define description for subsequent task.
 
@@ -155,131 +101,41 @@ module Taskable
   # Use up the description for subsequent task.
 
   def desc!
-    l = @last_description
-    @last_description = nil
+    l, @last_description = @last_description, nil
     l
   end
 
-  # Access a task.
-
-  def instance_task( name )
-    instance_task_table[ name.to_sym ]
-  end
-
-  # List of task names.
+ public
 
   def instance_tasks
-    instance_task_table.keys
-  #  t = instance_methods(true).select{ |m| m =~ /^->/ }
-  #  t.collect { |e| e[2..-1].to_sym }
+    i = []
+    instance_methods.each do |name|
+      if name =~ /^->(.*)/
+        i << $1
+      end
+    end
+    i
   end
 
   # List of task names with descriptions.
 
   def described_tasks
-    instance_tasks.select { |name| instance_task(name).description }
+    instance_tasks.select { |name| descriptions[name.to_sym] }
   end
 
   # List of task names without descriptions.
 
   def undescribed_tasks
-    instance_tasks.select { |name| ! instance_task(name).description }
-  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 via create core and callable methods.
-    # We do it this way b/c otherwise we'd have to use
-    # instance_eval and then can't ever pass paramaters.
-    if action
-      define_method( "->#{name}", &action ) # core of the task
-      define_method( name ) do |*args|
-        # ensure no cycles in the graph and extract call graph
-        #own = (class << self; self; end) # in case there are singletons?
-        todolist = Task::Graph.new( self, name )
-        todolist.each_strongly_connected_component_from( name ) do |c|
-          send("->#{c}", *args)
-        end
-      end
-      instance_task_table![name] = Task.new( name, self, deps, desc!, &action )
-    elsif !instance_task_table![name]
-      #define_method( "->#{name}", lambda{} )  # empty action
-      define_method( name ) do |*args|
-        # ensure no cycles in the graph and extract call graph
-        #own = (class << self; self; end) # in case there are singletons?
-        todolist = Task::Graph.new( self, name )
-        todolist.each_strongly_connected_component_from( name ) do |c|
-          send("->#{c}", *args) unless "#{c}" == "#{name}"
-        end
-      end
-      instance_task_table![name] = Task.new( name, self, deps, desc!, &action )
-    else
-      m = instance_task_table![name]
-      #m.description = desc!  # TODO should this apply only if there is an action?
-      m.prerequisite.concat deps unless deps.empty?
-      m
-    end
-  end
-
-  # Include the Task module into the Module class.
-
-  class ::Module
-    include Taskable
-    # This has to be down here and not in Taskable b/c of
-    # a glitch in inheritor's design.
-    inheritor :instance_task_table, {}, :merge
+    instance_tasks.select { |name| ! descriptions[name.to_sym] }
   end
 
 end
 
-#
 
-class Object
-  def send_task( name )
-    (class << self; self; end).instance_task( name )
-  end
+class Module
+  include Taskable
 end
 
-#--
-# TODO Allows tasks to defined at the toplevel (main).
-# This may need work b/c it might cause an infinite loop.
-# Plus there are a few method missing yet. Anyway,
-# I'm not needing this functionality at the moment, and
-# I leave it to somone else to finish when they do.
-#
-# class Object
-#
-#   def instance_tasks
-#     (class << self; self; end).instance_tasks
-#   end
-#
-#   def instance_task(*args, &blk)
-#     (class << self; self; end).task(*args, &blk)
-#   end
-#
-#   def desc(*args, &blk)
-#     (class << self; self; end).desc(*args, &blk)
-#   end
-#
-#   def desc!(*args, &blk)
-#     (class << self; self; end).desc!(*args, &blk)
-#   end
-#
-#   def task(*args, &blk)
-#     (class << self; self; end).desc(*args, &blk)
-#   end
-#
-# end
-#++
 
 
 #  _____         _
@@ -292,7 +148,7 @@ end
 
   require 'test/unit'
 
-  class TCTask < Test::Unit::TestCase
+  class TestTaskable1 < Test::Unit::TestCase
 
     module M
       task :m1 => [ :c1 ] do @x << "m1" end
@@ -349,9 +205,6 @@ 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
@@ -416,13 +269,13 @@ end
 
     def test_E1
       e = E.new
-      assert_raises( RuntimeError ) { e.e1 }
+      assert_raises( NoMethodError ) { e.e1 }
       #assert_equal( [ 'c1', 'e1' ], e.x )
     end
 
     def test_E2
       e = E.new
-      assert_raises( RuntimeError ) { e.e2 }
+      assert_raises( NoMethodError ) { e.e2 }
       #assert_equal( [ 'c1', 'm1', 'e2' ], e.x )
     end
 
@@ -443,4 +296,28 @@ 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