module FileUtils

def create_shell_runner(cmd) # :nodoc:

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

def ruby(*args, **options, &block)


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

Run a Ruby interpreter with the given arguments. 
def ruby(*args, **options, &block)
  if args.length > 1
    sh(RUBY, *args, **options, &block)
  else
    sh("#{RUBY} #{args.first}", **options, &block)
  end
end

def safe_ln(*args, **options)

fails.
Attempt to do a normal file link, but fall back to a copy if the link 
def safe_ln(*args, **options)
  if LN_SUPPORTED[0]
    begin
      return options.empty? ? ln(*args) : ln(*args, **options)
    rescue StandardError, NotImplementedError
      LN_SUPPORTED[0] = false
    end
  end
  options.empty? ? cp(*args) : cp(*args, **options)
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)
  verbose = options.delete :verbose
  noop    = options.delete(:noop) || Rake::FileUtilsExt.nowrite_flag
  Rake.rake_output_message sh_show_command cmd if verbose
  unless noop
    res = (Hash === cmd.last) ? system(*cmd) : system(*cmd, options)
    status = $?
    status = Rake::PseudoStatus.new(1) if !res && status.nil?
    shell_runner.call(res, status)
  end
end

def sh_show_command(cmd) # :nodoc:

:nodoc: 
def sh_show_command(cmd) # :nodoc:
  cmd = cmd.dup
  if Hash === cmd.first
    env = cmd.first
    env = env.map { |name, value| "#{name}=#{value}" }.join " "
    cmd[0] = env
  end
  cmd.join " "
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