ratch 0.1 → 0.2.1

data/data/ratch/rubyproject/load

@@ -0,0 +1,39 @@
+#!/usr/bin/env ratch
+
+# Load check all libs.
+
+#
+
+require 'benchmark'
+
+$:.unshift('lib')
+
+scripts_core, scripts_more = [], []
+Dir.chdir('lib') do
+  scripts_more = glob('facets/*.rb')
+  scripts_more.collect!{ |s| File.expand_path(s) }
+  scripts_more.uniq!
+
+  scripts_core = glob('facets/*/*.rb')
+  scripts_core.collect!{ |s| File.expand_path(s) }
+  scripts_core.uniq!
+end
+
+$VERBOSE = nil
+
+def require_scripts(scripts)
+  scripts.each do |file|
+    begin
+      require file
+    rescue Exception => e
+      puts file
+      puts e.message
+    end
+  end
+end
+
+Benchmark.bm do |x|
+  x.report("core"){ require_scripts(scripts_core) }
+  x.report("more"){ require_scripts(scripts_more) }
+end
+

data/data/ratch/rubyproject/publish

@@ -0,0 +1,58 @@
+#!/usr/bin/env ratch
+
+# Publish website to rubyforge
+#
+# This task publishes the source dir (deafult 'doc/site')
+# to a rubyforge website.
+
+main :publish do
+  config = configuration['publish']
+
+  project     = config['project']
+  subdir      = config['subdir']
+  source      = config['source'] || "doc/site"
+  username    = config['username']
+  protect     = %w{usage statcvs statsvn robot.txt wiki}
+  exclude     = %w{.svn}
+
+  abort "no project"  unless project
+  abort "no username" unless username
+
+  if subdir
+    destination = File.join(project, subdir)
+  else
+    destination = project
+  end
+
+  dir = source.chomp('/') + '/'
+  url = "#{username}@rubyforge.org:/var/www/gforge-projects/#{destination}"
+
+  op = ['-rLvz', '--delete']  # maybe -p ?
+
+  # add filter options. The commandline version didn't seem
+  # to work, so I opted for creating an .rsync_filter file for
+  # all cases.
+
+  filter_file = File.join(source,'.rsync-filter')
+
+  unless file?(filter_file)
+    File.open(filter_file, 'w') do |f|
+      exclude.map{|e| f << "- #{e}\n"}
+      protect.map{|e| f << "P #{e}\n"}
+    end
+  end
+
+  op << "--filter='dir-merge #{filter_file}'"
+
+  #if file?(filter_file)
+  #  op << "--filter='dir-merge #{filter_file}'"
+  #else  # NOT WORKING?
+  #  op.concat exclude.map{|e| "--filter='- #{e}'"}
+  #  op.concat protect.map{|e| "--filter='P #{e}'"}
+  #end
+
+  args = op + [dir, url]
+
+  rsync(*args.to_params)
+end
+

data/dev/install

@@ -0,0 +1,89 @@
+# Magic Rollerball Installer
+# 
+#
+
+PROJECT_NAME    = 'multiton'
+PROJECT_VERSION = '2.1.0'
+
+##################
+
+require 'fileutils'
+require 'rbconfig'
+
+include FileUtils::DryRun
+
+
+rubyprefix = Config::CONFIG['prefix']
+sitelibdir = Config::CONFIG['sitelibdir']
+
+
+PREFIX = ENV['PREFIX'] || rubyprefix
+
+RUBYLIB = if PREFIX == rubyprefix then
+            sitelibdir
+          else
+            File.join(PREFIX, sitelibdir[rubyprefix.size..-1])
+          end
+
+ROLLLIB = File.join(File.dirname(RUBYLIB), "rolls", File.basename(RUBYLIB))
+
+RUBY_DEBUG = ENV['RUBY_DEBUG']
+RUBY_FLAGS = ENV['RUBY_FLAGS'] ||
+  "-w -I#{%w(lib ext bin test).join(File::PATH_SEPARATOR)}" +
+  (RUBY_DEBUG ? " #{RUBY_DEBUG}" : '')
+
+p PREFIX
+p RUBYLIB
+p ROLLLIB
+#p RUBY_DEBUG
+#p RUBY_FLAGS
+
+HERE = File.expand_path(File.dirname(__FILE__))
+DEST = File.join(ROLLLIB, PROJECT_NAME, PROJECT_VERSION)
+
+files  = Dir.glob("**/*")
+files -= Dir.glob("INSTALL")
+files -= Dir.glob("pkg/**/*") + ['pkg']
+
+p HERE
+p DEST
+p files
+
+mkdir_p DEST unless test ?d, DEST
+
+
+# Install libs
+
+def project_install(files)
+  bin_files = files.grep(/^bin/)
+
+  (files - bin_files).each do |file|
+    install file, DEST, :mode => 0444
+  end
+
+  bin_files.each do |file|
+    install file, DEST, :mode => 0555
+  end
+end
+
+
+# Change modes
+
+def  project_chmod(files)
+  bin_files = Files.grep(/^bin/)
+
+  (files - bin_files).each do |file|
+    chmod File.join(DEST, file), 0444
+  end
+
+  bin_files.each do |file|
+    chmod File.join(DEST, file), 0555
+  end
+end
+
+
+if HERE == DEST
+  project_chmod(files)
+else
+  project_install(files)
+end

data/dev/ludo

@@ -0,0 +1,25 @@
+#! /usr/bin/ruby
+
+#--
+# Special Thanks to Jeffrey Schwab for #root?
+#++
+
+# Is the specified directory the root directory?
+
+def FileTest.root?(dir)
+  pth = File.expand_path(dir)
+  return true if pth == '/'
+  return true if pth =~ /^(\w:)?\/$/
+  false
+end
+
+name = ARGV[0]
+
+if name
+  Dir.chdir '..' until FileTest.executable?(name) or FileTest.root?(Dir.pwd)
+  if FileTest.executable?( name )
+    system name
+  end
+else
+  puts "Script #{name} not found."
+end

data/dev/oldtaskable.rb

@@ -0,0 +1,573 @@
+# TITLE:
+#
+#   Taskable
+#
+# COPYRIGHT:
+#
+#   Copyright (c) 2006 Thomas Sawyer
+#
+# LICENSE:
+#
+#   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.
+#
+# AUTHORS:
+#
+#   - Thomas Sawyer
+#
+# 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.
+#
+#   - TODO Should Rake's namespace feature be added? This could interfer
+#     with other definitions of #namespace.
+#
+#   - TODO The only reason the :exec method is defined is b/c instance_exec
+#     is not in Ruby yet, so until then this is the working hack.
+#
+# LOG:
+#
+#   - CHANGE 2006-11-14 trans
+#
+#     Taskable has been completely rewritten. While it is essentially
+#     compatible with the previous implementation, it is not 100% the
+#     same; mainly in that tasks are not defined as methods any longer.
+#     This new implementation is now nearly 100% compatible with Rake's
+#     design. Note, for a basic "taskable" system, more like the old
+#     version, see depend.rb.
+
+require 'facets/class_extension'
+
+$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'
+      Module.module_eval{ include TaskableDSL }
+    else
+      base.extend TaskableDSL
+    end
+  end
+
+  ### CLASS LEVEL ###
+
+  module TaskableDSL
+
+    #--
+    # TODO Add task namespace functionality ???
+    #++
+    #def namespace
+    #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
+
+    # <b>Task</b>
+    #
+    #
+
+    def task( target_to_source, &build )
+      target, source = *Task.parse(target_to_source)
+      define_method("#{target}:exec",&build) if build
+      (@task||={})[target] = Task.new(target, source, desc!, &build)
+    end
+
+    # <b>File task</b>
+    #
+    # Task must be provide instructions for building the file.
+
+    def file( file_to_source, &build )
+      file, source = *Task.parse(file_to_source)
+      define_method("#{file}:exec",&build) if build
+      (@task||={})[file] = FileTask.new(file, source, desc!, &build)
+    end
+
+    # <b>Rule task</b>
+    #
+    # Task must be provide instructions for building the file(s).
+
+    def rule( pattern_to_source, &build )
+      pattern, source = *Task.parse(pattern_to_source)
+      define_method("#{pattern}:exec",&build) if build
+      (@task||={})[pattern] = RuleTask.new(pattern, source, desc!, &build)
+    end
+
+    #
+
+    def instance_tasks( ancestry=true )
+      @task ||= {}
+      if ancestry
+        ancestors.inject(@task.keys) do |m,a|
+          t = a.instance_variable_get("@task")
+          m |= t.keys if t
+          m
+        end
+      else
+        @task.keys
+      end
+    end
+
+    # List of task names with descriptions.
+
+    def described_tasks( ancestry=true )
+      memo = []
+      instance_tasks(ancestry).each do |name|
+        memo << name if @task[name].desc
+      end
+      return memo
+    end
+
+    # List of task names without descriptions.
+
+    def undescribed_tasks( ancestry=true )
+      memo = []
+      instance_tasks(ancestry).each do |name|
+        memo << name unless @task[name].desc
+      end
+      return memo
+    end
+
+    # Find matching task.
+    #--
+    # TODO Maybe this isn't really needed here and can be moved to Task class ???
+    #++
+
+    def instance_task( match )
+      hit = (@task||={}).values.find do |task|
+        task.match(match)
+      end
+      return hit if hit
+      ancestors.each do |a|
+        task_table = a.instance_variable_get("@task")
+        next unless task_table
+        hit = task_table.values.find do |task|
+          task.match(match)
+        end
+        break hit if hit
+      end
+      hit
+    end
+
+  end
+
+  ### INSTANCE LEVEL ###
+
+  #
+
+  def tasks
+    (class << self; self; end).instance_tasks
+  end
+
+  #
+
+  def task(name)
+    (class << self; self; end).instance_task(name)
+  end
+
+  # FIXME, THIS STILL WONT WORK AT TOPLEVEL!!!!
+
+  def method_missing(t, *a, &b)
+p t
+p tasks
+p task(t)
+    #if self.class.respond_to?(:instance_task) && (task = self.class.instance_task(t))
+    if tsk = task(t)
+      tsk.run(self, t)
+    else
+      super(t.to_sym,*a,&b)
+    end
+  end
+
+end
+
+#
+
+class Taskable::Task
+
+  # Parse target => [source,...] argument.
+
+  def self.parse(target_to_source)
+    if Hash === target_to_source
+      target = target_to_source.keys[0]
+      source = target_to_source.values[0]
+    else
+      target = target_to_source
+      source = []
+    end
+    return target.to_sym, source.collect{|s| s.to_sym}
+  end
+
+  #
+
+  attr_reader :target, :source, :desc, :build
+
+  alias :name :target
+  alias :description :desc
+
+  # New task.
+
+  def initialize( target, source, desc=nil, &build )
+    @target = target
+    @source = source
+    @desc   = desc
+    @build  = build
+  end
+
+  # Run task in given context.
+
+  def run( context, target )
+    task   = self
+    source = @source
+    build  = @build
+
+    presource(context).each do |d|
+      d.call(context)
+    end
+
+    call(context)
+  end
+
+  # Call build exec of task. Note that the use of :exec method
+  # is due to the lack of #instance_exec which will come wiht Ruby 1.9.
+
+  def call( context )
+    context.send("#{@target}:exec", self) if @build
+  end
+
+  #
+
+  def match( target )
+    @target.to_s == target.to_s
+  end
+
+  # Compile list of all unique prerequisite sources.
+
+  def presource( context, build=[] )
+    @source.each do |s|
+      t = context.class.instance_task(s)
+      raise NoMethodError, 'undefined source' unless t
+      build.unshift(t)
+      t.presource(context,build)
+    end
+    build.uniq!
+    build
+  end
+
+end
+
+#
+
+class Taskable::FileTask < Taskable::Task
+
+  # Run file task in a given context.
+
+  def run( context, target )
+    task   = self
+    source = @source
+    build  = @build
+
+    context.instance_eval 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(task)
+        unless File.exist?(file) and File.mtime(file) > timestamp
+          raise "failed to build -- #{file}"
+        end
+      end
+    end
+  end
+
+  #
+
+  def match(target)
+    @target.to_s == target.to_s
+  end
+
+end
+
+#
+
+class Taskable::RuleTask < Taskable::FileTask
+
+  # Run rule task in given context.
+
+  def run( context, target )
+    @target = target
+    super(context)
+  end
+
+  #
+
+  def match(target)
+    case @target
+    when Regexp
+      @target =~ target.to_s
+    when String
+      #if @target.index('*')  #TODO
+      #  /#{@target.gsub('*', '.*?')}/ =~ target
+      if @target.index('.') == 0
+        /#{Regexp.escape(@target)}$/ =~ target
+      else
+        super
+      end
+    else
+      super
+    end
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin ##test
+
+  require 'test/unit'
+
+  class TestTaskable1 < Test::Unit::TestCase
+
+    module M
+      include Taskable
+      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
+      include Taskable
+      attr :x
+      def initialize ; @x = [] ; end
+
+      desc "test-b1"
+      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
+      include Taskable
+      attr :x
+      task :o1 do (@x||=[]) << "o1" end
+      task :o2 => [ :o1 ] do (@x||=[]) << "o2" end
+    end
+
+    # tests
+
+    def test_001
+       assert( B.described_tasks.include?(:b1) )
+    end
+
+    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
+
+=end
+
+  ##
+  # Test toplevel usage.
+  #
+
+  include Taskable
+
+p Object.ancestors
+
+  task :foo do
+    "foo"
+  end
+
+  task :bar => [ :foo ] do
+    "bar"
+  end
+
+  #class TestTaskable2 #< Test::Unit::TestCase
+    def test_01
+      puts foo
+    end
+
+    def test_02
+      puts bar
+    end
+  #end
+
+  test_01
+  test_02
+
+#=end
+
+# Author::    Thomas Sawyer
+# Copyright:: Copyright (c) 2006 Thomas Sawyer
+# License::   Ruby License