Extended maintenance of Ruby versions 1.8.7 and 1.9.2 will end on July 31, 2014. Read more

In Files

  • shell/command-processor.rb

Shell::CommandProcessor

Constants

NoDelegateMethods

Public Class Methods

add_delegate_command_to_shell(id) click to toggle source
 
               # File 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
            
alias_command(ali, command, *opts, &block) click to toggle source
 
               # File 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
            
alias_map() click to toggle source
 
               # File shell/command-processor.rb, line 407
def self.alias_map
  @alias_map
end
            
def_builtin_commands(delegation_class, command_specs) click to toggle source

::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,...)
 
               # File 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
            
def_system_command(command, path = command) click to toggle source

::def_system_command(command, path)

  command:  String
  path:       String
define 'command()' method as method.
 
               # File 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
            
initialize() click to toggle source
 
               # File 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
            
install_builtin_commands() click to toggle source

define default builtin commands

 
               # File 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
            
install_system_commands(pre = "sys_") click to toggle source

::install_system_commands

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.

 
               # File 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
            
method_added(id) click to toggle source
 
               # File shell/command-processor.rb, line 43
def self.method_added(id)
  add_delegate_command_to_shell(id)
end
            
new(shell) click to toggle source
 
               # File shell/command-processor.rb, line 64
def initialize(shell)
  @shell = shell
  @system_commands = {}
end
            
run_config() click to toggle source

include run file.

 
               # File 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
            
unalias_command(ali) click to toggle source
 
               # File 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
            
undef_system_command(command) click to toggle source
 
               # File 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
            

Public Instance Methods

[](command, file1, file2=nil) click to toggle source
Alias for: test
append(to, filter) click to toggle source
 
               # File 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
            
cat(*filenames) click to toggle source
 
               # File shell/command-processor.rb, line 306
def cat(*filenames)
  Cat.new(@shell, *filenames)
end
            
check_point() click to toggle source

ProcessCommand#transact

 
               # File shell/command-processor.rb, line 282
def check_point
  @shell.process_controller.wait_all_jobs_execution
end
            
Also aliased as: finish_all_jobs
concat(*jobs) click to toggle source
 
               # File shell/command-processor.rb, line 333
def concat(*jobs)
  Concat.new(@shell, *jobs)
end
            
echo(*strings) click to toggle source
 
               # File shell/command-processor.rb, line 302
def echo(*strings)
  Echo.new(@shell, *strings)
end
            
expand_path(path) click to toggle source

#expand_path

  path:     String
  return: String
returns the absolute path for <path>
 
               # File shell/command-processor.rb, line 75
def expand_path(path)
  @shell.expand_path(path)
end
            
find_system_command(command) click to toggle source

private functions

 
               # File 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
            
finish_all_jobs() click to toggle source
Alias for: check_point
foreach(path = nil, *rs) click to toggle source

File related commands Shell#foreach Shell#open Shell#unlink Shell#test

-

#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
 
               # File 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
            
glob(pattern) click to toggle source

def sort(*filenames)

Sort.new(self, *filenames)

end

 
               # File shell/command-processor.rb, line 314
def glob(pattern)
  Glob.new(@shell, pattern)
end
            
mkdir(*path) click to toggle source

Dir related methods

Shell#mkdir Shell#rmdir

 
               # File 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
            
notify(*opts, &block) click to toggle source

%pwd, %cwd -> @pwd

 
               # File 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
            
open(path, mode = nil, perm = 0666, &b) click to toggle source

#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
 
               # File 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
            
out(dev = STDOUT, &block) click to toggle source

internal commands

 
               # File shell/command-processor.rb, line 298
def out(dev = STDOUT, &block)
  dev.print transact(&block)
end
            
rehash() click to toggle source

ProcessCommand#rehash

clear command hash table.
 
               # File shell/command-processor.rb, line 275
def rehash
  @system_commands = {}
end
            
rmdir(*path) click to toggle source

#rmdir

  path: String
same as Dir.rmdir()
 
               # File 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
            
system(command, *opts) click to toggle source

#system(command, *opts)

  command: String
  opts:      String
  return:  SystemCommand
Same as system() function
example:
  print sh.system("ls", "-l")
  sh.system("ls", "-l") | sh.head > STDOUT
 
               # File 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
            
tee(file) click to toggle source
 
               # File shell/command-processor.rb, line 329
def tee(file)
  Tee.new(@shell, file)
end
            
test(command, file1, file2=nil) click to toggle source
 
               # File 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
            
Also aliased as: top_level_test, []
top_level_test(command, file1, file2=nil) click to toggle source

#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 symbol)
  FileTest.command (others)
example:
  sh[?e, "foo"]
  sh[:e, "foo"]
  sh["e", "foo"]
  sh[:exists?, "foo"]
  sh["exists?", "foo"]
Alias for: test
transact(&block) click to toggle source
 
               # File shell/command-processor.rb, line 287
def transact(&block)
  begin
    @shell.instance_eval(&block)
  ensure
    check_point
  end
end
            

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus