facets 2.2.1 → 2.3.0

data/lib/mixin/facets/cloneable.rb

@@ -0,0 +1,90 @@
+# TITLE:
+#
+#   Clonable
+#
+# SUMMARY:
+#
+#   Standard basis for adding deep #dup and #clone to a class.
+#
+# COPYRIGHT:
+#
+#   Copyright (c) 2002 Jim Weirich
+#
+# LICENSE:
+#
+#   GNU General Public License (GPL)
+#
+#   Permission is hereby granted, free of charge, to any person obtaining
+#   a copy of this software and associated documentation files (the
+#   "Software"), to deal in the Software without restriction, including
+#   without limitation the rights to use, copy, modify, merge, publish,
+#   distribute, sublicense, and/or sell copies of the Software, and to
+#   permit persons to whom the Software is furnished to do so, subject to
+#   the following conditions:
+#
+#   The above copyright notice and this permission notice shall be
+#   included in all copies or substantial portions of the Software.
+#
+#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+#   LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+#   OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+#   WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# HISTORY:
+#
+#   Cloneable was ported from Jim Weirich's Rake.
+#
+# AUTHORS:
+#
+#   - Ken Bloom    (Current Version)
+#   - Jim Weirich  (Original Version)
+#
+# TODO:
+#   - Is there a more robust means to determining if clone or dup is used?
+
+# = Cloneable
+#
+# Provides a class with deep cloneablity via the standard
+# #dup and #clone methods.
+
+module Cloneable
+  def initialize_copy(sibling)
+    #first duplicate my superclass' state. Note that if it's duplicating
+    #instance variables, this will be overwritten, but this is important
+    #because we could be dealing with a C extension with state hidden from
+    #the Ruby interpreter
+    super
+
+    #we want to know if we're being dup'ed or clone'd, because we want to
+    #preserve the state of our internals the same way our state is being
+    #preserved. (If we can't figure it out, we'll just use #dup.)
+    operation=caller.find{|x| x !~ /'initialize_copy'/}.
+      match(/`(dup|clone)'/)[1] or :dup
+
+    sibling.instance_variables.each do |ivar|
+      value = sibling.instance_variable_get(ivar)
+
+      #set my instance variable to be a #dup or #clone
+      #or my sibling, depending on what's happening to me right now
+      instance_variable_set(ivar, value.send(operation))
+    end
+  end
+end 
+
+# OLD VERSION
+
+#module Cloneable
+#  def clone
+#    sibling = self.class.new
+#    instance_variables.each do |ivar|
+#      value = self.instance_variable_get(ivar)
+#      sibling.instance_variable_set(ivar, value.dup) #rake_dup)
+#    end
+#    sibling
+#  end
+#  alias_method :dup, :clone
+#end
+

data/lib/{more → mixin}/facets/enumerablepass.rb

@@ -202,84 +202,3 @@ module EnumerableArgs
 end
 =end
 
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  # fixture
-
-  class PlusArray
-    include EnumerablePass
-    def initialize(arr)
-      @arr = arr
-    end
-    def each(n=0)
-      @arr.each{ |e| yield(e+n) }
-    end
-  end
-
-  class TC_Enumerable < Test::Unit::TestCase
-
-    def test_collect
-      t = PlusArray.new([1,2,3])
-      assert_equal( [5,6,7], t.collect(4){ |e| e } )
-    end
-
-    #def test_each_slice
-    #  t = PlusArray.new([1,2,3,4])
-    #  a = []
-    #  t.each_slice(2,4){ |e,f| a << [e,f] }
-    #  assert_equal( [[5,6],[7,8]], a )
-    #end
-
-    #def test_find
-    #  t = PlusArray.new([1,2,3,4])
-    #  f = t.find(2, :ifnone=>lambda{:NOPE}) { |a| a == 10 }
-    #  assert_equal(:NOPE, f)
-    #end
-
-    def test_grep
-      # TODO
-    end
-
-    def test_to_a
-      t = PlusArray.new([1,2,3])
-      assert_equal( [5,6,7], t.to_a(4) )
-    end
-
-    def test_min
-      t = PlusArray.new([1,2,3])
-      assert_equal( 5, t.min(4) )
-    end
-
-    def test_max
-      t = PlusArray.new([1,2,3])
-      assert_equal( 7, t.max(4) )
-    end
-
-    def test_include?
-      t = PlusArray.new([1,2,3])
-      assert( t.include?(7,4) )
-    end
-
-    def test_select
-      t = PlusArray.new([1,2,3])
-      assert_equal( [6], t.select(4){ |x| x == 6 } )
-    end
-
-    def test_reject
-      t = PlusArray.new([1,2,3])
-      assert_equal( [5,7], t.reject(4){ |x| x == 6 } )
-    end
-
-  end
-
-=end

data/lib/{more → mixin}/facets/instantiable.rb

@@ -43,33 +43,3 @@ class Module
 
 end
 
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TestInstantiable < Test::Unit::TestCase
-
-    module M
-      extend Module::Instantiable
-
-      attr_reader :a
-      def initialize( a )
-        @a = a
-      end
-    end
-
-    def test_new
-      m = M.new( 1 )
-      assert_equal( 1, m.a )
-    end
-
-  end
-
-=end

data/lib/mixin/facets/tasksystem.rb

@@ -0,0 +1,350 @@
+# = TITLE:
+#
+#   Tasks
+#
+# = COPYING:
+#
+#   Copyright (c) 2007,2008 Tiger Ops
+#
+#   This file is part of the Reap program.
+#
+#   Reap is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   Reap 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.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with Reap.  If not, see <http://www.gnu.org/licenses/>.
+
+#
+module Reap
+
+  module TaskSystem
+
+    IN_PROGRESS = :__IN_PROGRESS__
+
+    # Define main task.
+
+    def main(name, &block)
+      name, deps, block = *parse_dependencies(name, &block)
+      define_main(name, *deps, &block)
+    end
+
+    # Define a task.
+
+    def task(name, &block)
+      name, deps, block = *parse_dependencies(name, &block)
+      define_task(name, *deps, &block)
+    end
+
+    # Define a build target.
+
+    def file(name, &block)
+      name, deps, block = *parse_dependencies(name, &block)
+      define_file(name, *deps, &block)
+    end
+
+    def goals
+      @goals ||= {}
+    end
+
+    # Complete a goal.
+
+    def run(goal)
+      if rule = rules.find{ |r| r.match?(goal) }
+        action = rule.action(goal)
+        key = action.key
+        if result = goals[key]
+          if result == IN_PROGESS
+            abort "Circular dependency -- #{goal}"
+          else
+            result
+          end
+        else
+          goals[key] = IN_PROGRESS
+          action.needs.each{ |need| run(need) }
+          goals[key] = action.call
+        end
+      else
+        files = Dir.glob(goal)
+        if files.empty?
+          abort "Missing dependency -- #{goal}"
+        else
+          true
+        end
+      end
+    end
+
+    #def run(goal, arguments=nil)
+    #  plan(goal).each{ |action| action.call }
+    #end
+
+    private
+
+      def rules ; @rules ||= [] ; end
+
+      def main_rule ; @main ; end
+
+      #
+
+      def parse_dependencies(name_deps, &block)
+        if Hash===name_deps
+          name = name_deps.keys[0]
+          deps = name_deps.values[0]
+        else
+          name = name_deps
+          deps = []
+        end
+        [name, deps, block]
+      end
+
+      # Define main task.
+
+      def define_main(name=nil, *depend, &block)
+        @main = define_task(name, *depend, &block)
+      end
+
+      # Define a task rule.
+
+      def define_task(name, *depend, &block)
+        rule = Task.new(name, *depend, &block)
+        rules << rule
+        rule
+      end
+
+      # Define a file build rule.
+
+      def define_file(name, *depend, &block)
+        rule = Build.new(name, *depend, &block)
+        rules << rule
+        rule
+      end
+
+      # Call main task.
+      #--
+      # TODO If @main is nil try task by same name a file (?)
+      #      If so, be careful of infinite loop via method_missing.
+      #++
+
+      def run_main
+        return unless main_rule
+        run(main_rule.target)
+      end
+
+#       # Build a plan of action given a goal. This is a recursive
+#       # function building up the +todo+ list parameter.
+#
+#       def plan(goal, todo=[])
+#         if rule = rules.find{ |r| r.match?(goal) }
+#           todo << Action.new(goal, rule)
+#           rule.needs.each do |need|
+#             next if todo.any?{ |r| r.match?(need) }
+#             plan(need, todo)
+#           end
+#         else
+#           todo << Action.new(goal)
+#         end
+#         todo
+#       end
+
+=begin
+      # Prepare plan, checking for circular dependencies.
+
+      def task_plan(name, list=[])
+        if list.include?(name)
+          raise "Circular dependency #{name}."
+        end
+
+        if task = tasks[name]
+          task.needs.each do |need|
+            need = need.to_s
+            next if list.include?(need)
+            #@tasks[need].task_plan(need, list)
+            task_plan(need, list)
+          end
+          list << task.name
+        elsif name != main_task && fname = batch?(name)
+          # TODO THIS TIES TASKS INTO BATCH, BETTER WAY?
+          task = Task.new(name) do
+            batch(fname)
+          end
+          tasks[name] = task
+          list << task.name
+        elsif build?(name)
+          # TODO THIS TIES TASKS INTO BUILD, BETTER WAY?
+          task = Task.new(name) do
+            build(name)
+          end
+          tasks[name] = task
+          list << task.name
+        else
+          abort "no task -- #{name}"
+        end
+
+        return list
+      end
+=end
+
+    #
+
+    class Rule
+      attr_reader :target, :needs, :procedure
+
+      def initialize(target, *needs, &procedure)
+        @target        = target
+        @needs         = needs
+        @procedure     = procedure
+      end
+
+      def action(goal)
+        Action.new(self, key(goal))
+      end
+    end
+
+    # Task is a simpliest type of rule --a pure assertion. It stores a task name,
+    # action and it's prerequisite needs.
+
+    class Task < Rule
+
+      def match?(goal)
+        target.to_sym == goal.to_sym
+      end
+
+      def call(goal)
+        procedure.call if procedure
+      end
+
+      def key(goal)
+        goal.to_sym
+      end
+
+      #def action(goal)
+      #  Action.new(self, key(goal))
+      #end
+
+      #def needed?(goal)
+      #  true
+      #end
+    end
+
+    # The Build class is a file rule. It encapsulates the procedure for
+    # creating a file (or directory).
+
+    class Build < Rule
+
+      # Does a file match this build definition?
+
+      def match?(path)
+        return false unless String===path
+        case target
+        when String
+          File.fnmatch(target, path)
+        when Regexp
+          target =~ path
+        else
+          false        # ???
+        end
+      end
+
+      # Call this build process for the given path.
+
+      def call(path)
+        if needs.empty?
+          dated = true
+        elsif File.exist?(path)
+          mtime = File.mtime(path)
+          dated = needs.find do |file|
+            !File.exist?(file) || File.mtime(file) > mtime
+          end
+        else
+          dated = true
+        end
+        procedure.call(path) if dated
+      end
+
+      #
+
+      def key(path)
+        File.expand_path(path.to_s)
+      end
+
+  #     # Expanded needs.
+  #
+  #     def needs(key)
+  #       needed_paths
+  #     end
+  #
+  #     def needs
+  #       #exact = needs.select{|n| File.fnmatch?(n,n)} +
+  #       exact = needed.select{|n| n !~ /[\[*?]/ }
+  #       globs = @needs.collect{|n| Dir.glob(n)}.flatten
+  #       (exact + globs).uniq #globs.uniq
+  #     end
+  #
+  #     # Is this build needed to update/create path?
+  #
+  #     def needed_for?(path)
+  #       return true unless File.exist?(path)
+  #       return true if needed_paths.empty?  # TODO: if there are no prereqs then the file is always considered needed. Correct?
+  #       mtimes = needed_paths.collect do |f|
+  #         File.exist?(f) ? File.mtime(f) : Time.now
+  #       end
+  #       mtimes.max > File.mtime(path)
+  #     end
+    end
+
+    # An action associates a goal and the rule the fulfills it.
+
+    class Action
+      attr :rule
+      attr :goal
+
+      def initialize(rule, goal)
+        @rule = rule
+        @goal = goal
+      end
+
+      def key
+        rule.key(goal)
+      end
+
+      def call
+        rule.call(goal)
+      end
+
+      def needs
+        rule.needs #(key)
+      end
+
+      def ==(other)
+        case other
+        when Action
+          rule == other.rule && key == other.key
+        else
+          false
+  #       when Rule
+  #         rule.match?(other)
+  #       else
+  #         goal == other
+  #       end
+        end
+      end
+
+  #     def match?(need)
+  #       if rule
+  #         rule.match?(need)
+  #       else
+  #         goal == need
+  #       end
+  #     end
+
+    end
+
+  end
+
+end