Class Shell::CommandProcessor < Object

# File ../ruby/lib/shell/command-processor.rb, line 519
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 definition 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 definition 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

# File ../ruby/lib/shell/command-processor.rb, line 410
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

# File ../ruby/lib/shell/command-processor.rb, line 407
def self.alias_map
  @alias_map
end

# File ../ruby/lib/shell/command-processor.rb, line 456
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

# File ../ruby/lib/shell/command-processor.rb, line 380
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

# File ../ruby/lib/shell/command-processor.rb, line 34
def self.initialize

  install_builtin_commands

  # define CommandProcessor#methods to Shell#methods and Filter#methods
  for m in CommandProcessor.instance_methods(false) - NoDelegateMethods
    add_delegate_command_to_shell(m)
  end

  def self.method_added(id)
    add_delegate_command_to_shell(id)
  end
end

# File ../ruby/lib/shell/command-processor.rb, line 558
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(false).collect{|m| [m, ["FILENAME"]]})

end

# File ../ruby/lib/shell/command-processor.rb, line 490
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

# File ../ruby/lib/shell/command-processor.rb, line 43
def self.method_added(id)
  add_delegate_command_to_shell(id)
end

# File ../ruby/lib/shell/command-processor.rb, line 64
def initialize(shell)
  @shell = shell
  @system_commands = {}
end

# File ../ruby/lib/shell/command-processor.rb, line 51
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 $!.class, ": ", $!, "\n"
    for err in $@[0, $@.size - 2]
      print "\t", err, "\n"
    end
  end
end

# File ../ruby/lib/shell/command-processor.rb, line 439
def self.unalias_command(ali)
  ali = ali.id2name if ali.kind_of?(Symbol)
  @alias_map.delete ali.intern
  undef_system_command(ali)
end

# File ../ruby/lib/shell/command-processor.rb, line 393
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

# File ../ruby/lib/shell/command-processor.rb, line 318
def append(to, filter)
  case to
  when String
    AppendFile.new(@shell, to, filter)
  when IO
    AppendIO.new(@shell, to, filter)
  else
    Shell.Fail Error::CantApplyMethod, "append", to.class
  end
end

# File ../ruby/lib/shell/command-processor.rb, line 306
def cat(*filenames)
  Cat.new(@shell, *filenames)
end

# File ../ruby/lib/shell/command-processor.rb, line 282
def check_point
  @shell.process_controller.wait_all_jobs_execution
end

# File ../ruby/lib/shell/command-processor.rb, line 333
def concat(*jobs)
  Concat.new(@shell, *jobs)
end

# File ../ruby/lib/shell/command-processor.rb, line 302
def echo(*strings)
  Echo.new(@shell, *strings)
end

# File ../ruby/lib/shell/command-processor.rb, line 75
def expand_path(path)
  @shell.expand_path(path)
end

# File ../ruby/lib/shell/command-processor.rb, line 350
def find_system_command(command)
  return command if /^\// =~ command
  case path = @system_commands[command]
  when String
    if exists?(path)
      return path
    else
      Shell.Fail Error::CommandNotFound, command
    end
  when false
    Shell.Fail Error::CommandNotFound, command
  end

  for p in @shell.system_path
    path = join(p, command)
    if FileTest.exist?(path)
      @system_commands[command] = path
      return path
    end
  end
  @system_commands[command] = false
  Shell.Fail Error::CommandNotFound, command
end

# File ../ruby/lib/shell/command-processor.rb, line 97
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

# File ../ruby/lib/shell/command-processor.rb, line 314
def glob(pattern)
  Glob.new(@shell, pattern)
end

# File ../ruby/lib/shell/command-processor.rb, line 215
def mkdir(*path)
  @shell.check_point
  notify("mkdir #{path.join(' ')}")

  perm = nil
  if path.last.kind_of?(Integer)
    perm = path.pop
  end
  for dir in path
    d = expand_path(dir)
    if perm
      Dir.mkdir(d, perm)
    else
      Dir.mkdir(d)
    end
    File.chmod(d, 0666 & ~@shell.umask) if @shell.umask
  end
  Void.new(@shell)
end

# File ../ruby/lib/shell/command-processor.rb, line 338
def notify(*opts, &block)
  Shell.notify(*opts) {|mes|
    yield mes if iterator?

    mes.gsub!("%pwd", "#{@cwd}")
    mes.gsub!("%cwd", "#{@cwd}")
  }
end

# File ../ruby/lib/shell/command-processor.rb, line 118
def open(path, mode = nil, perm = 0666, &b)
  path = expand_path(path)
  if File.directory?(path)
    Dir.open(path, &b)
  else
    if @shell.umask
      f = File.open(path, mode, perm)
      File.chmod(perm & ~@shell.umask, path)
      if block_given?
        f.each(&b)
      end
      f
    else
      f = File.open(path, mode, perm, &b)
    end
  end
end

# File ../ruby/lib/shell/command-processor.rb, line 298
def out(dev = STDOUT, &block)
  dev.print transact(&block)
end

# File ../ruby/lib/shell/command-processor.rb, line 275
def rehash
  @system_commands = {}
end

# File ../ruby/lib/shell/command-processor.rb, line 240
def rmdir(*path)
  @shell.check_point
  notify("rmdir #{path.join(' ')}")

  for dir in path
    Dir.rmdir(expand_path(dir))
  end
  Void.new(@shell)
end

# File ../ruby/lib/shell/command-processor.rb, line 260
def system(command, *opts)
  if opts.empty?
    if command =~ /\*|\?|\{|\}|\[|\]|<|>|\(|\)|~|&|\||\|\$|;|'|`|"|\n/
      return SystemCommand.new(@shell, find_system_command("sh"), "-c", command)
    else
      command, *opts = command.split(/\s+/)
    end
  end
  SystemCommand.new(@shell, find_system_command(command), *opts)
end

# File ../ruby/lib/shell/command-processor.rb, line 329
def tee(file)
  Tee.new(@shell, file)
end

# File ../ruby/lib/shell/command-processor.rb, line 173
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
    if file2
      top_level_test(command, file1, file2)
    else
      top_level_test(command, file1)
    end
  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

# File ../ruby/lib/shell/command-processor.rb, line 287
def transact(&block)
  begin
    @shell.instance_eval(&block)
  ensure
    check_point
  end
end

# File ../ruby/lib/shell/command-processor.rb, line 143
def unlink(path)
  @shell.check_point

  path = expand_path(path)
  if File.directory?(path)
    Dir.unlink(path)
  else
    IO.unlink(path)
  end
  Void.new(@shell)
end