module FileUtils

def create_shell_runner(cmd) # :nodoc:

:nodoc: 
def create_shell_runner(cmd) # :nodoc:
  show_command = cmd.join(" ")
  show_command = show_command[0, 42] + "..." unless $trace
  lambda do |ok, status|
    ok or
      fail "Command failed with status (#{status.exitstatus}): " +
      "[#{show_command}]"
  end
end

def rake_system(*cmd) # :nodoc:

:nodoc: 
def rake_system(*cmd) # :nodoc:
  Rake::AltSystem.system(*cmd)
end

def ruby(*args, &block)


ruby %{-pe '$_.upcase!' Example:

Run a Ruby interpreter with the given arguments. 
def ruby(*args, &block)
  options = (Hash === args.last) ? args.pop : {}
  if args.length > 1
    sh(*([RUBY] + args + [options]), &block)
  else
    sh("#{RUBY} #{args.first}", options, &block)
  end
end

def safe_ln(*args)

fails.
Attempt to do a normal file link, but fall back to a copy if the link 
def safe_ln(*args)
  if ! LN_SUPPORTED[0]
    cp(*args)
  else
    begin
      ln(*args)
    rescue StandardError, NotImplementedError
      LN_SUPPORTED[0] = false
      cp(*args)
    end
  end
end

def set_verbose_option(options) # :nodoc:

:nodoc: 
def set_verbose_option(options) # :nodoc:
  unless options.key? :verbose
    options[:verbose] =
      (Rake::FileUtilsExt.verbose_flag == Rake::FileUtilsExt::DEFAULT) ||
      Rake::FileUtilsExt.verbose_flag
  end
end

def sh(*cmd, &block)


end
end
puts "pattern not found (status = #{res.exitstatus})"
if ! ok
sh %{grep pattern file} do |ok, res|
# check exit status after command runs

sh 'ls', 'file with spaces'

sh 'ls -ltr'

Examples:

Without a block a RuntimeError is raised when the command exits non-zero.
OK flag (true on a zero exit status) and a Process::Status object.
If a block is given, upon command completion the block is called with an

; rm # -rf /.
tasks are not vulnerable to users providing an argument like
reserved characters in them. With the multiple argument form your rake
argument form you can easily process files with spaces or other shell
user input for both usability and security reasons. With the multiple
It is recommended you use the multiple argument form over interpolating

Kernel::system).
is run directly (without the shell, same semantics as Kernel::exec and
Run the system command +cmd+. If multiple arguments are given the command 
def sh(*cmd, &block)
  options = (Hash === cmd.last) ? cmd.pop : {}
  shell_runner = block_given? ? block : create_shell_runner(cmd)
  set_verbose_option(options)
  options[:noop] ||= Rake::FileUtilsExt.nowrite_flag
  Rake.rake_check_options options, :noop, :verbose
  Rake.rake_output_message cmd.join(" ") if options[:verbose]
  unless options[:noop]
    res = rake_system(*cmd)
    status = $?
    status = Rake::PseudoStatus.new(1) if !res && status.nil?
    shell_runner.call(res, status)
  end
end

def split_all(path)


split_all("a/b/c") => ['a', 'b', 'c']
Example:

Split a file path into individual directory names. 
def split_all(path)
  head, tail = File.split(path)
  return [tail] if head == '.' || tail == '/'
  return [head, tail] if head == '/'
  return split_all(head) + [tail]
end