ratch 0.3.0 → 0.4.0

data/work/scrap/install.1

@@ -1,63 +0,0 @@
-#!/usr/bin/env ratch
-
-# install package to site_ruby
-#
-# This tool installs the package to site_ruby
-# using Ruby's defualt configuration settings.
-# If you want to change these you can can supply
-# config settings for 'prefix' and/or 'sitedir'.
-
-main :install do
-
-  system_prefix = Config::CONFIG['prefix']
-  system_libdir = Config::CONFIG['sitelibdir']
-
-  config = config_load('install')
-
-  prefix = config['prefix'] || system_prefix
-  libdir = config['libdir']
-
-  unless libdir
-    if (prefix == system_prefix) then
-      libdir = system_libdir
-    else
-      libdir = File.join(prefix, system_libdir[system_prefix.size..-1])
-    end
-  end
-
-  # TODO Probably should get files from manifest, if it exists.
-  # files = projectinfo.filelist
-  files = Dir.glob("{lib,ext,bin}/**/*").select{ |f| File.file?(f) }
-
-  lib_files  = files.grep(/^(lib|ext)/)
-  bin_files  = files.grep(/^bin/)
-
-  # Copy files to proper locations.
-
-  lib_files.each do |file|
-    dest = File.dirname(file).sub('lib/', '')
-    dest = File.join(libdir, dest)
-    #dest.sub!(/(core|more)\//, '')  # SPECIAL FOR FACETS !!!!!
-    if noharm?
-      puts "mkdir -p #{dest}"
-      puts "install -m 0444 #{file} #{dest}"
-    else
-      mkdir_p dest unless File.directory?(dest)
-      install file, dest, :mode => 0444
-    end
-  end
-
-  bin_files.each do |file|
-    dest = File.dirname(file)
-    dest = File.join(prefix, dest)
-    if noharm?
-      puts "mkdir -p #{dest}"
-      puts "install -m 0555 #{file} #{dest}"
-    else
-      mkdir_p dest unless File.directory?(dest)
-      install file, dest, :mode => 0555
-    end
-  end
-
-end
-

data/work/scrap/ludo

@@ -1,25 +0,0 @@
-#! /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/work/scrap/oldtaskable.rb

@@ -1,573 +0,0 @@
-# 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

data/work/scrap/ratch.man

@@ -1,39 +0,0 @@
-.\" NAME:
-.\"   ratch - ruby-based batch files
-.\"
-.\" SYNOPSIS: |
-.\"   ratch [-n] [-h] [file]
-.\"
-.\" DESCRIPTION: |
-.\"   Ratch is batch file system using a Ruby=based DSL.
-.\"
-.\" OPTIONS: |
-.\"   -h help     This option displays help.
-.\"   -n dryrun   Dry-run/no-harm mode.
-.\"
-.\" ENVIRONMENT: |
-.\"   PAGER    name of paging command, usually more(1), or less(1). If not set
-.\"            falls back to more(1).
-.\"
-.\" EXAMPLE: |
-.\"   Try this command to format this text itself:
-.\"
-.\"       $ txt2man -h 2>&1 | txt2man -T
-.\"
-.\" HINTS: >
-.\"   To obtain an overall good formating of output document, keep paragraphs
-.\"   indented correctly. If you have unwanted bold sections, search for
-.\"   multiple spaces between words, which are used to identify a tag list
-.\"   (term followed by a description). Choose also carefully the name of
-.\"   command line or function parameters, as they will be emphasized each
-.\"   time they are encountered in the document.
-.\"
-.\" SEE ALSO:
-.\"   man(1), mandoc(7), rman(1), groff(1), more(1), gxditview(1), troff(1).
-.\"
-.\" BUGS:
-.\"   Automatic probe (-p option) works only if input is a regular file (i.e. not stdin).
-.\"
-.\" AUTHOR:
-.\"   Marc Vertes <mvertes@free.fr>
-