This commit was manufactured by cvs2svn to create branch 'ruby_1_6'.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_1_6@1425 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

doc/shell.rd

@@ -0,0 +1,348 @@
+ -- shell.rb
+				$Release Version: 0.6.0 $
+			   	$Revision$
+			   	$Date$
+			   	by Keiju ISHITSUKA(keiju@ishitsuka.com)
+
+=begin
+
+= What's shell.rb?
+
+It realizes a wish to do execution of commands with filters and pipes
+like sh/csh by using just native facilities of ruby.
+
+= Main classes
+
+== Shell
+
+Every shell object has its own current working directory, and executes
+each command as if it stands in the directory.
+
+--- Shell#cwd
+--- Shell#dir
+--- Shell#getwd
+--- Shell#pwd
+
+      Returns the current directory
+
+--- Shell#system_path
+
+      Returns the command search path in an array
+
+--- Shell#umask
+
+      Returns the umask
+
+== Filter
+
+Any result of command exection is a Filter.  Filter include
+Enumerable, therefore a Filter object can use all Enumerable
+facilities.
+
+= Main methods
+
+== Command definitions
+
+In order to execute a command on your OS, you need to define it as a
+Shell method.
+
+Alternatively, you can execute any command via Shell#system even if it
+is not defined.
+
+--- Shell.def_system_command(command, path = command)
+
+      Defines a command.  Registers <path> as a Shell method
+      <command>.
+
+      ex)
+      Shell.def_system_command "ls"
+        Defines ls.
+
+      Shell.def_system_command "sys_sort", "sort"
+        Defines sys_sort as sort.
+
+--- Shell.undef_system_command(command)
+
+      Undefines a commmand
+
+--- Shell.alias_command(ali, command, *opts) {...}
+
+      Aliases a command.
+
+      ex)
+        Shell.alias_command "lsC", "ls", "-CBF", "--show-control-chars"
+        Shell.alias_command("lsC", "ls"){|*opts| ["-CBF", "--show-control-chars", *opts]}
+
+--- Shell.unalias_command(ali)
+
+      Unaliases a command.
+
+--- Shell.install_system_commands(pre = "sys_")
+
+      Defines all commands in the default_system_path as Shell method,
+      all with <pre> prefixed to their names.
+
+== Creation
+
+--- Shell.new
+
+      Creates a Shell object which current directory is set to the
+      process current directory.
+
+--- Shell.cd(path)
+
+      Creates a Shell object which current directory is set to
+      <path>.
+
+== Process management
+
+--- Shell#jobs
+
+      Returns a list of scheduled jobs.
+
+--- Shell#kill sig, job
+
+      Sends a signal <sig> to <job>.
+
+== Current directory operations
+
+--- Shell#cd(path, &block)
+--- Shell#chdir
+
+      Changes the current directory to <path>.  If a block is given,
+      it restores the current directory when the block ends.
+
+--- Shell#pushd(path = nil, &block)
+--- Shell#pushdir
+
+      Pushes the current directory to the directory stack, changing
+      the current directory to <path>.  If <path> is omitted, it
+      exchanges its current directory and the top of its directory
+      stack.  If a block is given, it restores the current directory
+      when the block ends.
+
+--- Shell#popd
+--- Shell#popdir
+
+      Pops a directory from the directory stack, and sets the current
+      directory to it.
+
+== File and directory operations
+
+--- Shell#foreach(path = nil, &block)
+
+      Same as:
+        File#foreach (when path is a file)
+        Dir#foreach (when path is a directory)
+
+--- Shell#open(path, mode)
+
+      Same as:
+        File#open (when path is a file)
+        Dir#open (when path is a directory)
+
+--- Shell#unlink(path)
+
+      Same as:
+        Dir#open (when path is a file)
+        Dir#unlink (when path is a directory)
+
+--- Shell#test(command, file1, file2)
+--- Shell#[command, file1, file2]
+
+      Same as test().
+      ex)
+          sh[?e, "foo"]
+          sh[:e, "foo"]
+          sh["e", "foo"]
+          sh[:exists?, "foo"]
+          sh["exists?", "foo"]
+
+--- Shell#mkdir(*path)
+
+      Same as Dir.mkdir (with multiple directories allowed)
+
+--- Shell#rmdir(*path)
+
+      Same as Dir.rmdir (with multiple directories allowed)
+
+== Command execution
+
+--- System#system(command, *opts)
+
+      Executes <command> with <opts>.
+
+      ex)
+        print sh.system("ls", "-l")
+        sh.system("ls", "-l") | sh.head > STDOUT
+
+--- System#rehash
+
+      Does rehash.
+
+--- Shell#transact &block
+
+      Executes a block as self.
+      ex)
+        sh.transact{system("ls", "-l") | head > STDOUT}
+
+--- Shell#out(dev = STDOUT, &block)
+
+      Does transact, with redirecting the result output to <dev>.
+
+== Internal commands
+
+--- Shell#echo(*strings)
+--- Shell#cat(*files)
+--- Shell#glob(patten)
+--- Shell#tee(file)
+
+      Return Filter objects, which are results of their execution.
+
+--- Filter#each &block
+
+      Iterates a block for each line of it.
+
+--- Filter#<(src)
+
+      Inputs from <src>, which is either a string of a file name or an
+      IO.
+
+--- Filter#>(to)
+
+      Outputs to <to>, which is either a string of a file name or an
+      IO.
+
+--- Filter#>>(to)
+
+      Appends the ouput to <to>, which is either a string of a file
+      name or an IO.
+
+--- Filter#|(filter)
+
+      Processes a pipeline.
+
+--- Filter#+(filter)
+
+      (filter1 + filter2) outputs filter1, and then outputs filter2.
+
+--- Filter#to_a
+--- Filter#to_s
+
+== Built-in commands
+
+--- Shell#atime(file)
+--- Shell#basename(file, *opt)
+--- Shell#chmod(mode, *files)
+--- Shell#chown(owner, group, *file)
+--- Shell#ctime(file)
+--- Shell#delete(*file)
+--- Shell#dirname(file)
+--- Shell#ftype(file)
+--- Shell#join(*file)
+--- Shell#link(file_from, file_to)
+--- Shell#lstat(file)
+--- Shell#mtime(file)
+--- Shell#readlink(file)
+--- Shell#rename(file_from, file_to)
+--- Shell#split(file)
+--- Shell#stat(file)
+--- Shell#symlink(file_from, file_to)
+--- Shell#truncate(file, length)
+--- Shell#utime(atime, mtime, *file)
+
+      Equivalent to the class methods of File with the same names.
+
+--- Shell#blockdev?(file)
+--- Shell#chardev?(file)
+--- Shell#directory?(file)
+--- Shell#executable?(file)
+--- Shell#executable_real?(file)
+--- Shell#exist?(file)/Shell#exists?(file)
+--- Shell#file?(file)
+--- Shell#grpowned?(file)
+--- Shell#owned?(file)
+--- Shell#pipe?(file)
+--- Shell#readable?(file)
+--- Shell#readable_real?(file)
+--- Shell#setgid?(file)
+--- Shell#setuid?(file)
+--- Shell#size(file)/Shell#size?(file)
+--- Shell#socket?(file)
+--- Shell#sticky?(file)
+--- Shell#symlink?(file)
+--- Shell#writable?(file)
+--- Shell#writable_real?(file)
+--- Shell#zero?(file)
+
+      Equivalent to the class methods of FileTest with the same names.
+
+--- Shell#syscopy(filename_from, filename_to)
+--- Shell#copy(filename_from, filename_to)
+--- Shell#move(filename_from, filename_to)
+--- Shell#compare(filename_from, filename_to)
+--- Shell#safe_unlink(*filenames)
+--- Shell#makedirs(*filenames)
+--- Shell#install(filename_from, filename_to, mode)
+
+      Equivalent to the class methods of FileTools with the same
+      names.
+
+      And also, there are some aliases for convenience:
+
+--- Shell#cmp	<- Shell#compare
+--- Shell#mv	<- Shell#move
+--- Shell#cp	<- Shell#copy
+--- Shell#rm_f	<- Shell#safe_unlink
+--- Shell#mkpath	<- Shell#makedirs
+
+= Samples
+
+== ex1
+
+  sh = Shell.cd("/tmp")
+  sh.mkdir "shell-test-1" unless sh.exists?("shell-test-1")
+  sh.cd("shell-test-1")
+  for dir in ["dir1", "dir3", "dir5"]
+    if !sh.exists?(dir)
+      sh.mkdir dir
+      sh.cd(dir) do
+	f = sh.open("tmpFile", "w")
+	f.print "TEST\n"
+	f.close
+      end
+      print sh.pwd
+    end
+  end
+
+== ex2
+
+  sh = Shell.cd("/tmp")
+  sh.transact do
+    mkdir "shell-test-1" unless exists?("shell-test-1")
+    cd("shell-test-1")
+    for dir in ["dir1", "dir3", "dir5"]
+      if !exists?(dir)
+	mkdir dir
+	cd(dir) do
+	  f = open("tmpFile", "w")
+	  f.print "TEST\n"
+	  f.close
+	end
+	print pwd
+      end
+    end
+  end
+
+== ex3
+
+  sh.cat("/etc/printcap") | sh.tee("tee1") > "tee2"
+  (sh.cat < "/etc/printcap") | sh.tee("tee11") > "tee12"
+  sh.cat("/etc/printcap") | sh.tee("tee1") >> "tee2"
+  (sh.cat < "/etc/printcap") | sh.tee("tee11") >> "tee12"
+
+== ex4
+
+  print sh.cat("/etc/passwd").head.collect{|l| l =~ /keiju/}
+
+=end

doc/shell.rd.jp

@@ -0,0 +1,336 @@
+ -- shell.rb
+				$Release Version: 0.6.0 $
+			   	$Revision$
+			   	$Date$
+			   	by Keiju ISHITSUKA(keiju@ishitsuka.com)
+
+=begin
+
+= 目的
+
+ruby上でsh/cshのようにコマンドの実行及びフィルタリングを手軽に行う.
+sh/cshの制御文はrubyの機能を用いて実現する.
+
+= 主なクラス一覧
+
+== Shell
+
+Shellオブジェクトはカレントディレクトリを持ち, コマンド実行はそこからの
+相対パスになります.
+
+--- Shell#cwd
+--- Shell#dir
+--- Shell#getwd
+--- Shell#pwd
+
+      カレントディレクトリを返す。
+
+--- Shell#system_path
+
+      コマンドサーチパスの配列を返す。
+
+--- Shell#umask
+
+      umaskを返す。
+
+== Filter
+
+コマンドの実行結果はすべてFilterとしてかえります. Enumerableをincludeし
+ています.
+
+= 主なメソッド一覧
+
+== コマンド定義
+
+OS上のコマンドを実行するにはまず, Shellのメソッドとして定義します.
+
+注) コマンドを定義しなくとも直接実行できるShell#systemコマンドもあります.
+
+--- Shell.def_system_command(command, path = command)
+
+      Shellのメソッドとしてcommandを登録します. 
+
+      例)
+      Shell.def_system_command "ls"
+        ls を定義
+
+      Shell.def_system_command "sys_sort", "sort"
+        sortコマンドをsys_sortとして定義
+
+--- Shell.undef_system_command(command)
+
+      commandを削除します.
+
+--- Shell.alias_command(ali, command, *opts) {...}
+
+      commandのaliasをします. 
+
+      例)
+        Shell.alias_command "lsC", "ls", "-CBF", "--show-control-chars"
+        Shell.alias_command("lsC", "ls"){|*opts| ["-CBF", "--show-control-chars", *opts]}
+
+--- Shell.unalias_command(ali)
+
+      commandのaliasを削除します.
+
+--- Shell.install_system_commands(pre = "sys_")
+
+      system_path上にある全ての実行可能ファイルをShellに定義する. メソッ
+      ド名は元のファイル名の頭にpreをつけたものとなる.
+
+== 生成
+
+--- Shell.new
+
+      プロセスのカレントディレクトリをカレントディレクトリとするShellオ
+      ブジェクトを生成します.
+
+--- Shell.cd(path)
+
+      pathをカレントディレクトリとするShellオブジェクトを生成します.
+
+== プロセス管理
+
+--- Shell#jobs
+
+      スケジューリングされているjobの一覧を返す.
+
+--- Shell#kill sig, job
+
+      jobにシグナルsigを送る
+
+== カレントディレクトリ操作
+
+--- Shell#cd(path, &block)
+--- Shell#chdir
+
+      カレントディレクトリをpathにする. イテレータとして呼ばれたときには
+      ブロック実行中のみカレントディレクトリを変更する.
+
+--- Shell#pushd(path = nil, &block)
+--- Shell#pushdir
+
+      カレントディレクトリをディレクトリスタックにつみ, カレントディレク
+      トリをpathにする. pathが省略されたときには, カレントディレクトリと
+      ディレクトリスタックのトップを交換する. イテレータとして呼ばれたと
+      きには, ブロック実行中のみpushdする.
+
+--- Shell#popd
+--- Shell#popdir
+
+      ディレクトリスタックからポップし, それをカレントディレクトリにする.
+
+== ファイル/ディレクトリ操作
+
+--- Shell#foreach(path = nil, &block)
+
+      pathがファイルなら, File#foreach
+      pathがディレクトリなら, Dir#foreach
+
+--- Shell#open(path, mode)
+
+      pathがファイルなら, File#open
+      pathがディレクトリなら, Dir#open
+
+--- Shell#unlink(path)
+
+      pathがファイルなら, File#unlink
+      pathがディレクトリなら, Dir#unlink
+
+--- Shell#test(command, file1, file2)
+--- Shell#[command, file1, file2]
+
+      ファイルテスト関数testと同じ. 
+      例)
+          sh[?e, "foo"]
+          sh[:e, "foo"]
+          sh["e", "foo"]
+          sh[:exists?, "foo"]
+          sh["exists?", "foo"]
+
+--- Shell#mkdir(*path)
+
+      Dir.mkdirと同じ(複数可)
+
+--- Shell#rmdir(*path)
+
+      Dir.rmdirと同じ(複数可)
+
+== コマンド実行
+
+--- System#system(command, *opts)
+
+      commandを実行する.
+      例)
+        print sh.system("ls", "-l")
+        sh.system("ls", "-l") | sh.head > STDOUT
+
+--- System#rehash
+
+      リハッシュする
+
+--- Shell#transact &block
+
+      ブロック中ではshellをselfとして実行する.
+      例)
+        sh.transact{system("ls", "-l") | head > STDOUT}
+
+--- Shell#out(dev = STDOUT, &block)
+
+      transactを呼び出しその結果をdevに出力する.
+
+== 内部コマンド
+
+--- Shell#echo(*strings)
+--- Shell#cat(*files)
+--- Shell#glob(patten)
+--- Shell#tee(file)
+
+      これらは実行すると, それらを内容とするFilterオブジェクトを返します. 
+
+--- Filter#each &block
+
+      フィルタの一行ずつをblockに渡す.
+
+--- Filter#<(src)
+
+      srcをフィルタの入力とする. srcが, 文字列ならばファイルを, IOであれ
+      ばそれをそのまま入力とする.
+
+--- Filter#>(to)
+
+      srcをフィルタの出力とする. toが, 文字列ならばファイルに, IOであれ
+      ばそれをそのまま出力とする.
+
+--- Filter#>>(to)
+
+      srcをフィルタに追加する. toが, 文字列ならばファイルに, IOであれば
+      それをそのまま出力とする.
+
+--- Filter#|(filter)
+
+      パイプ結合
+
+--- Filter#+(filter)
+
+      filter1 + filter2 は filter1の出力の後, filter2の出力を行う.
+
+--- Filter#to_a
+--- Filter#to_s
+
+== 組込みコマンド
+
+--- Shell#atime(file)
+--- Shell#basename(file, *opt)
+--- Shell#chmod(mode, *files)
+--- Shell#chown(owner, group, *file)
+--- Shell#ctime(file)
+--- Shell#delete(*file)
+--- Shell#dirname(file)
+--- Shell#ftype(file)
+--- Shell#join(*file)
+--- Shell#link(file_from, file_to)
+--- Shell#lstat(file)
+--- Shell#mtime(file)
+--- Shell#readlink(file)
+--- Shell#rename(file_from, file_to)
+--- Shell#split(file)
+--- Shell#stat(file)
+--- Shell#symlink(file_from, file_to)
+--- Shell#truncate(file, length)
+--- Shell#utime(atime, mtime, *file)
+
+      これらはFileクラスにある同名のクラスメソッドと同じです.
+
+--- Shell#blockdev?(file)
+--- Shell#chardev?(file)
+--- Shell#directory?(file)
+--- Shell#executable?(file)
+--- Shell#executable_real?(file)
+--- Shell#exist?(file)/Shell#exists?(file)
+--- Shell#file?(file)
+--- Shell#grpowned?(file)
+--- Shell#owned?(file)
+--- Shell#pipe?(file)
+--- Shell#readable?(file)
+--- Shell#readable_real?(file)
+--- Shell#setgid?(file)
+--- Shell#setuid?(file)
+--- Shell#size(file)/Shell#size?(file)
+--- Shell#socket?(file)
+--- Shell#sticky?(file)
+--- Shell#symlink?(file)
+--- Shell#writable?(file)
+--- Shell#writable_real?(file)
+--- Shell#zero?(file)
+
+      これらはFileTestクラスにある同名のクラスメソッドと同じです.
+
+--- Shell#syscopy(filename_from, filename_to)
+--- Shell#copy(filename_from, filename_to)
+--- Shell#move(filename_from, filename_to)
+--- Shell#compare(filename_from, filename_to)
+--- Shell#safe_unlink(*filenames)
+--- Shell#makedirs(*filenames)
+--- Shell#install(filename_from, filename_to, mode)
+
+      これらはFileToolsクラスにある同名のクラスメソッドと同じです.
+
+      その他, 以下のものがエイリアスされています.
+
+--- Shell#cmp	<- Shell#compare
+--- Shell#mv	<- Shell#move
+--- Shell#cp	<- Shell#copy
+--- Shell#rm_f	<- Shell#safe_unlink
+--- Shell#mkpath	<- Shell#makedirs
+
+= サンプル
+
+== ex1
+
+  sh = Shell.cd("/tmp")
+  sh.mkdir "shell-test-1" unless sh.exists?("shell-test-1")
+  sh.cd("shell-test-1")
+  for dir in ["dir1", "dir3", "dir5"]
+    if !sh.exists?(dir)
+      sh.mkdir dir
+      sh.cd(dir) do
+	f = sh.open("tmpFile", "w")
+	f.print "TEST\n"
+	f.close
+      end
+      print sh.pwd
+    end
+  end
+
+== ex2
+
+  sh = Shell.cd("/tmp")
+  sh.transact do
+    mkdir "shell-test-1" unless exists?("shell-test-1")
+    cd("shell-test-1")
+    for dir in ["dir1", "dir3", "dir5"]
+      if !exists?(dir)
+	mkdir dir
+	cd(dir) do
+	  f = open("tmpFile", "w")
+	  f.print "TEST\n"
+	  f.close
+	end
+	print pwd
+      end
+    end
+  end
+
+== ex3
+
+  sh.cat("/etc/printcap") | sh.tee("tee1") > "tee2"
+  (sh.cat < "/etc/printcap") | sh.tee("tee11") > "tee12"
+  sh.cat("/etc/printcap") | sh.tee("tee1") >> "tee2"
+  (sh.cat < "/etc/printcap") | sh.tee("tee11") >> "tee12"
+
+== ex4
+
+  print sh.cat("/etc/passwd").head.collect{|l| l =~ /keiju/}
+
+=end

lib/shell/builtin-command.rb

@@ -0,0 +1,154 @@
+#
+#   shell/builtin-command.rb - 
+#   	$Release Version: 0.6.0 $
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nihon Rational Software Co.,Ltd)
+#
+# --
+#
+#   
+#
+
+require "shell/filter"
+
+class Shell
+  class BuiltInCommand<Filter
+    def wait?
+      false
+    end
+    def active?
+      true
+    end
+  end
+
+  class Echo < BuiltInCommand
+    def initialize(sh, *strings)
+      super sh
+      @strings = strings
+    end
+    
+    def each(rs = nil)
+      rs =  @shell.record_separator unless rs
+      for str  in @strings
+	yield str + rs
+      end
+    end
+  end
+
+  class Cat < BuiltInCommand
+    def initialize(sh, *filenames)
+      super sh
+      @cat_files = filenames
+    end
+
+    def each(rs = nil)
+      if @cat_files.empty?
+	super
+      else
+	for src in @cat_files
+	  @shell.foreach(src, rs){|l| yield l}
+	end
+      end
+    end
+  end
+
+  class Glob < BuiltInCommand
+    def initialize(sh, pattern)
+      super sh
+
+      @pattern = pattern
+      Thread.critical = true
+      back = Dir.pwd
+      begin
+	Dir.chdir @shell.cwd
+	@files = Dir[pattern]
+      ensure
+	Dir.chdir back
+	Thread.critical = false
+      end
+    end
+
+    def each(rs = nil)
+      rs =  @shell.record_separator unless rs
+      for f  in @files
+	yield f+rs
+      end
+    end
+  end
+
+#   class Sort < Cat
+#     def initialize(sh, *filenames)
+#       super
+#     end
+#
+#     def each(rs = nil)
+#       ary = []
+#       super{|l|	ary.push l}
+#       for l in ary.sort!
+# 	yield l
+#       end
+#     end
+#   end
+
+  class AppendIO < BuiltInCommand
+    def initialize(sh, io, filter)
+      super sh
+      @input = filter
+      @io = io
+    end
+
+    def input=(filter)
+      @input.input=filter
+      for l in @input
+	@io << l
+      end
+    end
+
+  end
+
+  class AppendFile < AppendIO
+    def initialize(sh, to_filename, filter)
+      @file_name = to_filename
+      io = sh.open(to_filename, "a")
+      super(sh, io, filter)
+    end
+
+    def input=(filter)
+      begin
+	super
+      ensure
+	@io.close
+      end
+    end
+  end
+
+  class Tee < BuiltInCommand
+    def initialize(sh, filename)
+      super sh
+      @to_filename = filename
+    end
+
+    def each(rs = nil)
+      to = @shell.open(@to_filename, "w")
+      begin
+	super{|l| to << l; yield l}
+      ensure
+	to.close
+      end
+    end
+  end
+
+  class Concat < BuiltInCommand
+    def initialize(sh, *jobs)
+      super(sh)
+      @jobs = jobs
+    end
+
+    def each(rs = nil)
+      while job = @jobs.shift
+	job.each{|l| yield l}
+      end
+    end
+  end
+end

lib/shell/command-processor.rb

@@ -0,0 +1,584 @@
+#
+#   shell/command-controller.rb - 
+#   	$Release Version: 0.6.0 $
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nippon Rational Inc.)
+#
+# --
+#
+#   
+#
+
+require "e2mmap"
+require "ftools"
+require "thread"
+
+require "shell/error"
+require "shell/filter"
+require "shell/system-command"
+require "shell/builtin-command"
+
+class Shell
+  class CommandProcessor
+
+    #
+    # initialize of Shell and related classes.
+    #
+    NoDelegateMethods = ["initialize", "expand_path"]
+    def self.initialize
+
+      install_builtin_commands
+
+      # define CommandProccessor#methods to Shell#methods and Filter#methods
+      for m in CommandProcessor.instance_methods - NoDelegateMethods
+	add_delegate_command_to_shell(m)
+      end
+      
+      def self.method_added(id)
+	add_delegate_command_to_shell(id)
+      end
+    end
+
+    #
+    # include run file.
+    #
+    def self.run_config
+      begin
+	load File.expand_path("~/.rb_shell") if ENV.key?("HOME")
+      rescue LoadError, Errno::ENOENT
+      rescue
+	print "load error: #{rc}\n"
+	print $!.type, ": ", $!, "\n"
+	for err in $@[0, $@.size - 2]
+	  print "\t", err, "\n"
+	end
+      end
+    end
+
+    def initialize(shell)
+      @shell = shell
+      @system_commands = {}
+    end
+
+    #
+    # CommandProcessor#expand_path(path)
+    #	  path:	  String
+    #	  return: String
+    #	returns the absolute path for <path>
+    #
+    def expand_path(path)
+      @shell.expand_path(path)
+    end
+
+    #
+    # File related commands
+    # Shell#foreach
+    # Shell#open
+    # Shell#unlink
+    # Shell#test
+    #
+    # -
+    #	
+    # CommandProcessor#foreach(path, rs)
+    #	  path: String
+    #	  rs:	String - record separator
+    #	  iterator
+    #	Same as:
+    #	  File#foreach (when path is file)
+    #	  Dir#foreach (when path is directory)
+    #	path is relative to pwd
+    #
+    def foreach(path = nil, *rs)
+      path = "." unless path
+      path = expand_path(path)
+
+      if File.directory?(path)
+	Dir.foreach(path){|fn| yield fn}
+      else
+	IO.foreach(path, *rs){|l| yield l}
+      end
+    end
+
+    #
+    # CommandProcessor#open(path, mode)
+    #	  path:	  String
+    #	  mode:	  String
+    #	  return: File or Dir
+    #	Same as:
+    #	  File#open (when path is file)
+    #	  Dir#open  (when path is directory)
+    #	mode has an effect only when path is a file
+    #
+    def open(path, mode)
+      path = expand_path(path)
+      if File.directory?(path)
+	Dir.open(path)
+      else
+	effect_umask do
+	  File.open(path, mode)
+	end
+      end
+    end
+    #  public :open
+
+    #
+    # CommandProcessor#unlink(path)
+    #	same as:
+    #	  Dir#unlink  (when path is directory)
+    #	  File#unlink (when path is file)
+    #
+    def unlink(path)
+      path = expand_path(path)
+      if File.directory?(path)
+	Dir.unlink(path)
+      else
+	IO.unlink(path)
+      end
+    end
+
+    #
+    # CommandProcessor#test(command, file1, file2)
+    # CommandProcessor#[command, file1, file2]
+    #	  command: char or String or Symbol
+    #	  file1:   String
+    #	  file2:   String(optional)
+    #	  return: Boolean
+    #	same as:
+    #	  test()	   (when command is char or length 1 string or sumbol)
+    #	  FileTest.command (others)
+    #	example:
+    #	  sh[?e, "foo"]
+    #	  sh[:e, "foo"]
+    #	  sh["e", "foo"]
+    #	  sh[:exists?, "foo"]
+    #	  sh["exists?", "foo"]
+    #	  
+    def test(command, file1, file2=nil)
+      file1 = expand_path(file1)
+      file2 = expand_path(file2) if file2
+      command = command.id2name if command.kind_of?(Symbol)
+
+      case command
+      when Integer
+	top_level_test(command, file1, file2)
+      when String
+	if command.size == 1
+	  if file2
+	    top_level_test(command, file1, file2)
+	  else
+	    top_level_test(command, file1)
+	  end
+	else
+	  if file2
+	    FileTest.send(command, file1, file2)
+	  else
+	    FileTest.send(command, file1)
+	  end
+	end
+      end
+    end
+    alias [] test
+
+    #
+    # Dir related methods
+    #
+    # Shell#mkdir
+    # Shell#rmdir
+    #
+    #--
+    #
+    # CommandProcessor#mkdir(*path)
+    #	  path: String
+    #	same as Dir.mkdir()
+    #	  
+    def mkdir(*path)
+      for dir in path
+	Dir.mkdir(expand_path(dir))
+      end
+    end
+
+    #
+    # CommandProcessor#rmdir(*path)
+    #	  path: String
+    #	same as Dir.rmdir()
+    #	  
+    def rmdir(*path)
+      for dir in path
+	Dir.rmdir(expand_path(path))
+      end
+    end
+
+    #
+    # CommandProcessor#system(command, *opts)
+    #	  command: String
+    #	  opts:	   String
+    #	  retuen:  SystemCommand
+    #	Same as system() function
+    #	example:
+    #	  print sh.system("ls", "-l")
+    #	  sh.system("ls", "-l") | sh.head > STDOUT
+    # 
+    def system(command, *opts)
+      SystemCommand.new(@shell, find_system_command(command), *opts)
+    end
+
+    #
+    # ProcessCommand#rehash
+    #	clear command hash table.
+    #
+    def rehash
+      @system_commands = {}
+    end
+
+    #
+    # ProcessCommand#transact
+    #
+    def check_point
+      @shell.process_controller.wait_all_jobs_execution
+    end
+    alias finish_all_jobs check_point
+
+    def transact(&block)
+      begin
+	@shell.instance_eval &block
+      ensure
+	check_point
+      end
+    end
+
+    #
+    # internal commands
+    #
+    def out(dev = STDOUT, &block)
+      dev.print transact &block
+    end
+
+    def echo(*strings)
+      Echo.new(@shell, *strings)
+    end
+
+    def cat(*filenames)
+      Cat.new(@shell, *filenames)
+    end
+
+    #   def sort(*filenames)
+    #     Sort.new(self, *filenames)
+    #   end
+
+    def glob(pattern)
+      Glob.new(@shell, pattern)
+    end
+
+    def append(to, filter)
+      case to
+      when String
+	AppendFile.new(@shell, to, filter)
+      when IO
+	AppendIO.new(@shell, to, filter)
+      else
+	Shell.Fail CanNotMethodApply, "append", to.type
+      end
+    end
+
+    def tee(file)
+      Tee.new(@shell, file)
+    end
+
+    def concat(*jobs)
+      Concat.new(@shell, *jobs)
+    end
+
+    # %pwd, %cwd -> @pwd
+    def notify(*opts, &block)
+      Thread.exclusive do
+	Shell.notify(*opts) {|mes|
+	  yield mes if iterator?
+	
+	  mes.gsub!("%pwd", "#{@cwd}")
+	  mes.gsub!("%cwd", "#{@cwd}")
+	}
+      end
+    end
+
+    #
+    # private functions
+    #
+    def effect_umask
+      if @shell.umask
+	Thread.critical = true
+	save = File.umask
+	begin
+	  yield
+	ensure
+	  File.umask save
+	  Thread.critical = false
+	end
+      else
+	yield
+      end
+    end
+    private :effect_umask
+
+    def find_system_command(command)
+      return command if /^\// =~ command
+      case path = @system_commands[command]
+      when String
+	if exists?(path)
+	  return path
+	else
+	  Shell.Fail CommandNotFound, command
+	end
+      when false
+	Shell.Fail CommandNotFound, command
+      end
+
+      for p in @shell.system_path
+	path = join(p, command)
+	if FileTest.exists?(path)
+	  @system_commands[command] = path
+	  return path
+	end
+      end
+      @system_commands[command] = false
+      Shell.Fail CommandNotFound, command
+    end
+
+    #
+    # CommandProcessor.def_system_command(command, path)
+    #	  command:  String
+    #	  path:	    String
+    #	define 'command()' method as method.
+    #
+    def self.def_system_command(command, path = command)
+      begin
+	eval ((d = %Q[def #{command}(*opts)
+     	          SystemCommand.new(@shell, '#{path}', *opts)
+               end]), nil, __FILE__, __LINE__ - 1)
+      rescue SyntaxError
+	Shell.notify "warn: Can't define #{command} path: #{path}." 
+      end
+      Shell.notify "Define #{command} path: #{path}.", Shell.debug?
+      Shell.notify("Definition of #{command}: ", d, 
+	     Shell.debug.kind_of?(Integer) && Shell.debug > 1)
+    end
+
+    def self.undef_system_command(command)
+      command = command.id2name if command.kind_of?(Symbol)
+      remove_method(command)
+      Shell.module_eval{remove_method(command)}
+      Filter.module_eval{remove_method(command)}
+      self
+    end
+
+    # define command alias
+    # ex)
+    # def_alias_command("ls_c", "ls", "-C", "-F")
+    # def_alias_command("ls_c", "ls"){|*opts| ["-C", "-F", *opts]}
+    #
+    @alias_map = {}
+    def self.alias_map
+      @alias_map
+    end
+    def self.alias_command(ali, command, *opts, &block)
+      ali = ali.id2name if ali.kind_of?(Symbol)
+      command = command.id2name if command.kind_of?(Symbol)
+      begin
+	if iterator?
+	  @alias_map[ali.intern] = proc
+
+	  eval ((d = %Q[def #{ali}(*opts)
+                          @shell.__send__(:#{command},
+                                          *(CommandProcessor.alias_map[:#{ali}].call *opts))
+	                end]), nil, __FILE__, __LINE__ - 1)
+    
+	else
+           args = opts.collect{|opt| '"' + opt + '"'}.join ","
+           eval ((d = %Q[def #{ali}(*opts)
+                          @shell.__send__(:#{command}, #{args}, *opts)
+                        end]), nil, __FILE__, __LINE__ - 1)
+	end
+      rescue SyntaxError
+	Shell.notify "warn: Can't alias #{ali} command: #{command}." 
+	Shell.notify("Definition of #{ali}: ", d)
+	raise
+      end
+      Shell.notify "Define #{ali} command: #{command}.", Shell.debug?
+      Shell.notify("Definition of #{ali}: ", d, 
+	     Shell.debug.kind_of?(Integer) && Shell.debug > 1)
+      self
+    end
+   
+    def self.unalias_command(ali)
+      ali = ali.id2name if ali.kind_of?(Symbol)
+      @alias_map.delete ali.intern
+      undef_system_command(ali)
+    end
+   
+    #
+    # CommandProcessor.def_builtin_commands(delegation_class, command_specs)
+    #	  delegation_class: Class or Module
+    #	  command_specs: [[command_name, [argument,...]],...]
+    #	     command_name: String
+    #	     arguments:	   String
+    #		FILENAME?? -> expand_path(filename??)
+    #		*FILENAME?? -> filename??.collect{|f|expand_path(f)}.join(", ")
+    #	define command_name(argument,...) as
+    #	    delegation_class.command_name(argument,...)
+    #
+    def self.def_builtin_commands(delegation_class, command_specs)
+      for meth, args in command_specs
+	arg_str = args.collect{|arg| arg.downcase}.join(", ")
+	call_arg_str = args.collect{
+	  |arg|
+	  case arg
+	  when /^(FILENAME.*)$/
+	    format("expand_path(%s)", $1.downcase)
+	  when /^(\*FILENAME.*)$/
+	    # \*FILENAME* -> filenames.collect{|fn| expand_path(fn)}.join(", ")
+	    $1.downcase + '.collect{|fn| expand_path(fn)}'
+	  else
+	    arg
+	  end
+	}.join(", ")
+	d = %Q[def #{meth}(#{arg_str})
+		    #{delegation_class}.#{meth}(#{call_arg_str})
+		 end]
+	Shell.notify "Define #{meth}(#{arg_str})", Shell.debug?
+	Shell.notify("Definition of #{meth}: ", d, 
+	     Shell.debug.kind_of?(Integer) && Shell.debug > 1)
+	eval d
+      end
+    end
+
+    #
+    # CommandProcessor.install_system_commands(pre)
+    #	    pre: String - command name prefix
+    # defines every command which belongs in default_system_path via
+    # CommandProcessor.command().  It doesn't define already defined
+    # methods twice.  By default, "pre_" is prefixes to each method
+    # name.  Characters that may not be used in a method name are
+    # all converted to '_'.  Definition errors are just ignored.
+    #
+    def self.install_system_commands(pre = "sys_")
+      defined_meth = {}
+      for m in Shell.methods
+	defined_meth[m] = true
+      end
+      sh = Shell.new
+      for path in Shell.default_system_path
+	next unless sh.directory? path
+	sh.cd path
+	sh.foreach do
+	  |cn|
+	  if !defined_meth[pre + cn] && sh.file?(cn) && sh.executable?(cn)
+	    command = (pre + cn).gsub(/\W/, "_").sub(/^([0-9])/, '_\1')
+	    begin
+	      def_system_command(command, sh.expand_path(cn))
+	    rescue
+	      Shell.notify "warn: Can't define #{command} path: #{cn}"
+	    end
+	    defined_meth[command] = command
+	  end
+	end
+      end
+    end
+
+    #----------------------------------------------------------------------
+    #
+    #  class initializing methods  - 
+    #
+    #----------------------------------------------------------------------
+    def self.add_delegate_command_to_shell(id)
+      id = id.intern if id.kind_of?(String)
+      name = id.id2name
+      if Shell.method_defined?(id)
+	Shell.notify "warn: override definnition of Shell##{name}."
+	Shell.notify "warn: alias Shell##{name} to Shell##{name}_org.\n"
+	Shell.module_eval "alias #{name}_org #{name}"
+      end
+      Shell.notify "method added: Shell##{name}.", Shell.debug?
+      Shell.module_eval(%Q[def #{name}(*args, &block)
+			    begin
+			      @command_processor.__send__(:#{name}, *args, &block)
+			    rescue Exception
+			      $@.delete_if{|s| /:in `__getobj__'$/ =~ s} #`
+	                      $@.delete_if{|s| /^\\(eval\\):/ =~ s}
+			    raise
+			    end
+                          end], __FILE__, __LINE__)
+
+      if Shell::Filter.method_defined?(id)
+	Shell.notify "warn: override definnition of Shell::Filter##{name}."
+	Shell.notify "warn: alias Shell##{name} to Shell::Filter##{name}_org."
+	Filter.module_eval "alias #{name}_org #{name}"
+      end
+      Shell.notify "method added: Shell::Filter##{name}.", Shell.debug?
+      Filter.module_eval(%Q[def #{name}(*args, &block)
+			    begin
+			      self | @shell.__send__(:#{name}, *args, &block)
+			    rescue Exception
+			      $@.delete_if{|s| /:in `__getobj__'$/ =~ s} #`
+	                      $@.delete_if{|s| /^\\(eval\\):/ =~ s}
+			    raise
+			    end
+                          end], __FILE__, __LINE__)
+    end
+
+    #
+    # define default builtin commands
+    #
+    def self.install_builtin_commands
+      # method related File.
+      #	(exclude open/foreach/unlink)
+      normal_delegation_file_methods = [
+	["atime", ["FILENAME"]],
+	["basename", ["fn", "*opts"]],
+	["chmod", ["mode", "*FILENAMES"]], 
+	["chown", ["owner", "group", "*FILENAME"]],
+	["ctime", ["FILENAMES"]],
+	["delete", ["*FILENAMES"]],
+	["dirname", ["FILENAME"]],
+	["ftype", ["FILENAME"]],
+	["join", ["*items"]],
+	["link", ["FILENAME_O", "FILENAME_N"]],
+	["lstat", ["FILENAME"]],
+	["mtime", ["FILENAME"]],
+	["readlink", ["FILENAME"]],
+	["rename", ["FILENAME_FROM", "FILENAME_TO"]],
+	#      ["size", ["FILENAME"]],
+	["split", ["pathname"]],
+	["stat", ["FILENAME"]],
+	["symlink", ["FILENAME_O", "FILENAME_N"]],
+	["truncate", ["FILENAME", "length"]],
+	["utime", ["atime", "mtime", "*FILENAMES"]]]
+
+      def_builtin_commands(File, normal_delegation_file_methods)
+      alias_method :rm, :delete
+
+      # method related FileTest
+      def_builtin_commands(FileTest, 
+		   FileTest.singleton_methods.collect{|m| [m, ["FILENAME"]]})
+
+      # method related ftools
+      normal_delegation_ftools_methods = [
+	["syscopy", ["FILENAME_FROM", "FILENAME_TO"]],
+	["copy", ["FILENAME_FROM", "FILENAME_TO"]],
+	["move", ["FILENAME_FROM", "FILENAME_TO"]],
+	["compare", ["FILENAME_FROM", "FILENAME_TO"]],
+	["safe_unlink", ["*FILENAMES"]],
+	["makedirs", ["*FILENAMES"]],
+	#    ["chmod", ["mode", "*FILENAMES"]],
+	["install", ["FILENAME_FROM", "FILENAME_TO", "mode"]],
+      ]
+      def_builtin_commands(File,
+		   normal_delegation_ftools_methods)
+      alias_method :cmp, :compare
+      alias_method :mv, :move
+      alias_method :cp, :copy
+      alias_method :rm_f, :safe_unlink
+      alias_method :mkpath, :makedirs
+    end
+
+  end
+end

lib/shell/error.rb

@@ -0,0 +1,26 @@
+#
+#   shell/error.rb - 
+#   	$Release Version: 0.6.0 $
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nihon Rational Software Co.,Ltd)
+#
+# --
+#
+#   
+#
+
+require "e2mmap"
+
+class Shell
+  module Error
+    extend Exception2MessageMapper
+    def_e2message TypeError, "wrong argument type %s (expected %s)"
+
+    def_exception :DirStackEmpty, "Directory stack empty."
+    def_exception :CanNotDefine, "Can't define method(%s, %s)."
+    def_exception :CanNotMethodApply, "This method(%s) can't apply this type(%s)."
+    def_exception :CommandNotFound, "Command not found(%s)."
+  end
+end
+

lib/shell/filter.rb

@@ -0,0 +1,111 @@
+#
+#   shell/filter.rb - 
+#   	$Release Version: 0.6.0 $
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nihon Rational Software Co.,Ltd)
+#
+# --
+#
+#   
+#
+
+class Shell
+  #
+  # Filter
+  # A method to require
+  #    each()
+  #
+  class Filter
+    include Enumerable
+    include Error
+
+    def initialize(sh)
+      @shell = sh	  # parent shell
+      @input = nil	  # input filter
+    end
+
+    attr_reader :input
+
+    def input=(filter)
+      @input = filter
+    end
+    
+    def each(rs = nil)
+      rs = @shell.record_separator unless rs
+      if @input
+	@input.each(rs){|l| yield l}
+      end
+    end
+
+    def < (src)
+      case src
+      when String
+	cat = Cat.new(@shell, src)
+	cat | self
+      when IO
+	self.input = src
+	self
+      else
+	Filter.Fail CanNotMethodApply, "<", to.type
+      end
+    end
+
+    def > (to)
+      case to
+      when String
+	dst = @shell.open(to, "w")
+	begin
+	  each(){|l| dst << l}
+	ensure
+	  dst.close
+	end
+      when IO
+	each(){|l| to << l}
+      else
+	Filter.Fail CanNotMethodApply, ">", to.type
+      end
+      self
+    end
+
+    def >> (to)
+      begin
+	Shell.cd(@shell.pwd).append(to, self)
+      rescue CanNotMethodApply
+	Shell.Fail CanNotMethodApply, ">>", to.type
+      end
+    end
+
+    def | (filter)
+      filter.input = self
+      if active?
+	@shell.process_controller.start_job filter
+      end
+      filter
+    end
+
+    def + (filter)
+      Join.new(@shell, self, filter)
+    end
+
+    def to_a
+      ary = []
+      each(){|l| ary.push l}
+      ary
+    end
+
+    def to_s
+      str = ""
+      each(){|l| str.concat l}
+      str
+    end
+
+    def inspect
+      if @shell.debug.kind_of?(Integer) && @shell.debug > 2
+	super
+      else
+	to_s
+      end
+    end
+  end
+end

lib/shell/process-controller.rb

@@ -0,0 +1,258 @@
+#
+#   shell/process-controller.rb - 
+#   	$Release Version: 0.6.0 $
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nihon Rational Software Co.,Ltd)
+#
+# --
+#
+#   
+#
+
+require "mutex_m"
+require "monitor"
+require "sync"
+
+class Shell
+  class ProcessController
+
+    @ProcessControllers = {}
+    @ProcessControllers.extend Mutex_m
+
+    class<<self
+
+      def process_controllers_exclusive
+	begin
+	  @ProcessControllers.lock unless Thread.critical 
+	  yield
+	ensure
+	  @ProcessControllers.unlock unless Thread.critical 
+	end
+      end
+
+      def activate(pc)
+	process_controllers_exclusive do
+	  @ProcessControllers[pc] ||= 0
+	  @ProcessControllers[pc] += 1
+	end
+      end
+
+      def inactivate(pc)
+	process_controllers_exclusive do
+	  if @ProcessControllers[pc]
+	    if (@ProcessControllers[pc] -= 1) == 0
+	      @ProcessControllers.delete(pc)
+	    end
+	  end
+	end
+      end
+
+      def each_active_object
+	process_controllers_exclusive do
+	  for ref in @ProcessControllers.keys
+	    yield ref
+	  end
+	end
+      end
+    end
+
+    def initialize(shell)
+      @shell = shell
+      @waiting_jobs = []
+      @active_jobs = []
+      @jobs_sync = Sync.new
+
+      @job_monitor = Mutex.new
+      @job_condition = ConditionVariable.new
+    end
+
+    def jobs
+      jobs = []
+      @jobs_sync.synchronize(:SH) do
+	jobs.concat @waiting_jobs
+	jobs.concat @active_jobs
+      end
+      jobs
+    end
+
+    def active_jobs
+      @active_jobs
+    end
+
+    def waiting_jobs
+      @waiting_jobs
+    end
+    
+    def jobs_exist?
+      @jobs_sync.synchronize(:SH) do
+	@active_jobs.empty? or @waiting_jobs.empty?
+      end
+    end
+
+    def active_jobs_exist?
+      @jobs_sync.synchronize(:SH) do
+	@active_jobs.empty?
+      end
+    end
+
+    def waiting_jobs_exist?
+      @jobs_sync.synchronize(:SH) do
+	@waiting_jobs.empty?
+      end
+    end
+
+    # schedule a command
+    def add_schedule(command)
+      @jobs_sync.synchronize(:EX) do
+	ProcessController.activate(self)
+	if @active_jobs.empty?
+	  start_job command
+	else
+	  @waiting_jobs.push(command)
+	end
+      end
+    end
+
+    # start a job
+    def start_job(command = nil)
+      @jobs_sync.synchronize(:EX) do
+	if command
+	  return if command.active?
+	  @waiting_jobs.delete command
+	else
+	  command = @waiting_jobs.shift
+	  return unless command
+	end
+	@active_jobs.push command
+	command.start
+
+	# start all jobs that input from the job
+	for job in @waiting_jobs
+	  start_job(job) if job.input == command
+	end
+      end
+    end
+
+    def waiting_job?(job)
+      @jobs_sync.synchronize(:SH) do
+	@waiting_jobs.include?(job)
+      end
+    end
+
+    def active_job?(job)
+      @jobs_sync.synchronize(:SH) do
+	@active_jobs.include?(job)
+      end
+    end
+
+    # terminate a job
+    def terminate_job(command)
+      @jobs_sync.synchronize(:EX) do
+	@active_jobs.delete command
+	ProcessController.inactivate(self)
+	if @active_jobs.empty?
+	  start_job
+	end
+      end
+    end
+
+    # kill a job
+    def kill_job(sig, command)
+      @jobs_sync.synchronize(:SH) do
+	if @waiting_jobs.delete command
+	  ProcessController.inactivate(self)
+	  return
+	elsif @active_jobs.include?(command)
+	  begin
+	    r = command.kill sig
+	    ProcessController.inactivate(self)
+	  rescue
+	    print "Shell: Warn: $!\n" if @shell.verbose?
+	    return nil
+	  end
+	  @active_jobs.delete command
+	  r
+	end
+      end
+    end
+
+    # wait for all jobs to terminate
+    def wait_all_jobs_execution
+      @job_monitor.synchronize do
+	begin
+	  while !jobs.empty?
+	    @job_condition.wait(@job_monitor)
+	  end
+	ensure
+	  redo unless jobs.empty?
+	end
+      end
+    end
+
+    # simple fork
+    def sfork(command, &block)
+      pipe_me_in, pipe_peer_out = IO.pipe
+      pipe_peer_in, pipe_me_out = IO.pipe
+      Thread.critical = true
+
+      STDOUT.flush
+      ProcessController.each_active_object do |pc|
+	for jobs in pc.active_jobs
+	  jobs.flush
+	end
+      end
+      
+      pid = fork {
+	Thread.critical = true
+
+	Thread.list.each do |th| 
+	  th.kill unless [Thread.main, Thread.current].include?(th)
+	end
+
+	STDIN.reopen(pipe_peer_in)
+	STDOUT.reopen(pipe_peer_out)
+
+	ObjectSpace.each_object(IO) do |io| 
+	  if ![STDIN, STDOUT, STDERR].include?(io)
+	    io.close unless io.closed?
+	  end
+	end
+	yield
+      }
+
+      pipe_peer_in.close
+      pipe_peer_out.close
+      command.notify "job(%name:##{pid}) start", @shell.debug?
+      Thread.critical = false
+
+      th = Thread.start {
+	Thread.critical = true
+	begin
+	  _pid = nil
+	  command.notify("job(%id) start to waiting finish.", @shell.debug?)
+	  Thread.critical = false
+	  _pid = Process.waitpid(pid, nil)
+	rescue Errno::ECHILD
+	  command.notify "warn: job(%id) was done already waitipd."
+	  _pid = true
+	ensure
+	  # when the process ends, wait until the command termintes
+	  if _pid
+	  else
+	    command.notify("notice: Process finishing...",
+			   "wait for Job[%id] to finish.",
+			   "You can use Shell#transact or Shell#check_point for more safe execution.")
+	    redo
+	  end
+	  Thread.exclusive do
+	    terminate_job(command)
+	    @job_condition.signal
+	    command.notify "job(%id) finish.", @shell.debug?
+	  end
+	end
+      }
+      return pid, pipe_me_in, pipe_me_out
+    end
+  end
+end

lib/shell/system-command.rb

@@ -0,0 +1,168 @@
+#
+#   shell/system-command.rb - 
+#   	$Release Version: 0.6.0 $
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nihon Rational Software Co.,Ltd)
+#
+# --
+#
+#   
+#
+
+require "shell/filter"
+
+class Shell
+  class SystemCommand < Filter
+    def initialize(sh, command, *opts)
+      if t = opts.find{|opt| !opt.kind_of?(String) && opt.type}
+	Shell.Fail TypeError, t.type, "String"
+      end
+      super(sh)
+      @command = command
+      @opts = opts
+      
+      @input_queue = Queue.new
+      @pid = nil
+
+      sh.process_controller.add_schedule(self)
+    end
+
+    attr_reader :command
+    alias name command
+
+    def wait?
+      @shell.process_controller.waiting_job?(self)
+    end
+
+    def active?
+      @shell.process_controller.active_job?(self)
+    end
+
+    def input=(inp)
+      super
+      if active?
+	start_export
+      end
+    end
+
+    def start
+      @pid, @pipe_in, @pipe_out = @shell.process_controller.sfork(self) {
+	Dir.chdir @shell.pwd
+	exec(@command, *@opts)
+      }
+      if @input
+	start_export
+      end
+      start_import
+    end
+
+    def flush
+      @pipe_out.flush if @pipe_out and !@pipe_out.closed?
+    end
+
+    def terminate
+      begin
+	@pipe_in.close
+      rescue IOError
+      end
+      begin
+	@pipe_out.close
+      rescue IOError
+      end
+    end
+
+    def kill(sig)
+      if @pid
+	Process.kill(sig, @pid)
+      end
+    end
+
+
+    def start_import
+#      Thread.critical = true
+      notify "Job(%id) start imp-pipe.", @shell.debug?
+      rs = @shell.record_separator unless rs
+      _eop = true
+#      Thread.critical = false
+      th = Thread.start {
+	Thread.critical = true
+	begin
+	  Thread.critical = false
+	  while l = @pipe_in.gets
+	    @input_queue.push l
+	  end
+	  _eop = false
+	rescue Errno::EPIPE
+	  _eop = false
+	ensure
+	  if _eop
+	    notify("warn: Process finishing...",
+		   "wait for Job[%id] to finish pipe importing.",
+		   "You can use Shell#transact or Shell#check_point for more safe execution.")
+#	    Tracer.on
+	    Thread.current.run
+	    redo
+	  end
+	  Thread.exclusive do
+	    notify "job(%id}) close imp-pipe.", @shell.debug?
+	    @input_queue.push :EOF
+	    @pipe_in.close
+	  end
+	end
+      }
+    end
+
+    def start_export
+      notify "job(%id) start exp-pipe.", @shell.debug?
+      _eop = true
+      th = Thread.start{
+	Thread.critical = true
+	begin
+	  Thread.critical = false
+	  @input.each{|l| @pipe_out.print l}
+	  _eop = false
+	rescue Errno::EPIPE
+	  _eop = false
+	ensure
+	  if _eop
+	    notify("shell: warn: Process finishing...",
+		   "wait for Job(%id) to finish pipe exporting.",
+		   "You can use Shell#transact or Shell#check_point for more safe execution.")
+#	    Tracer.on
+	    redo
+	  end
+	  Thread.exclusive do
+	    notify "job(%id) close exp-pipe.", @shell.debug?
+	    @pipe_out.close
+	  end
+	end
+      }
+    end
+
+    alias super_each each
+    def each(rs = nil)
+      while (l = @input_queue.pop) != :EOF
+	yield l
+      end
+    end
+
+    # ex)
+    #    if you wish to output: 
+    #	    "shell: job(#{@command}:#{@pid}) close pipe-out."
+    #	 then 
+    #	    mes: "job(%id) close pipe-out."
+    #    yorn: Boolean(@shell.debug? or @shell.verbose?)
+    def notify(*opts, &block)
+      Thread.exclusive do
+	@shell.notify(*opts) {|mes|
+	  yield mes if iterator?
+
+	  mes.gsub!("%id", "#{@command}:##{@pid}")
+	  mes.gsub!("%name", "#{@command}")
+	  mes.gsub!("%pid", "#{@pid}")
+	}
+      end
+    end
+  end
+end

lib/shell/version.rb

@@ -0,0 +1,16 @@
+#
+#   version.rb - shell version definition file
+#   	$Release Version: 0.6.0$
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nihon Rational Software Co.,Ltd)
+#
+# --
+#
+#   
+#
+
+class Shell
+  @RELEASE_VERSION = "0.6.0"
+  @LAST_UPDATE_DATE = "01/03/19"
+end