module POSIX::Spawn

def `(cmd)
  r, w = IO.pipe
  command_and_args = system_command_prefixes + [cmd, {:out => w, r => :close}]
  pid = spawn(*command_and_args)
  if pid > 0
    w.close
    out = r.read
    ::Process.waitpid(pid)
    out
  else
    ''
  end
ensure
  [r, w].each{ |io| io.close rescue nil }
end

def adjust_process_spawn_argv(args)
  if args.size == 1 && args[0].is_a?(String) && args[0] =~ /[ |>]/
    # single string with these characters means run it through the shell
    command_and_args = system_command_prefixes + [args[0]]
    [*command_and_args]
  elsif !args[0].respond_to?(:to_ary)
    # [argv0, argv1, ...]
    [[args[0], args[0]], *args[1..-1]]
  else
    # [[cmdname, argv0], argv1, ...]
    args
  end
end

def default_file_reopen_info(fd, file)
  case fd
  when :in, STDIN, $stdin, 0
    [file, "r", 0644]
  when :out, STDOUT, $stdout, 1
    [file, "w", 0644]
  when :err, STDERR, $stderr, 2
    [file, "w", 0644]
  else
    [file, "r", 0644]
  end
end

def extract_process_spawn_arguments(*args)
  # pop the options hash off the end if it's there
  options =
    if args[-1].respond_to?(:to_hash)
      args.pop.to_hash
    else
      {}
    end
  flatten_process_spawn_options!(options)
  normalize_process_spawn_redirect_file_options!(options)
  # shift the environ hash off the front if it's there and account for
  # possible :env key in options hash.
  env =
    if args[0].respond_to?(:to_hash)
      args.shift.to_hash
    else
      {}
    end
  env.merge!(options.delete(:env)) if options.key?(:env)
  # remaining arguments are the argv supporting a number of variations.
  argv = adjust_process_spawn_argv(args)
  [env, argv, options]
end

def fd?(object)
  case object
  when Integer
    object >= 0
  when :in, :out, :err, STDIN, STDOUT, STDERR, $stdin, $stdout, $stderr, IO
    true
  else
    object.respond_to?(:to_io) && !object.to_io.nil?
  end
end

def fd_to_io(object)
  case object
  when STDIN, STDOUT, STDERR, $stdin, $stdout, $stderr
    object
  when :in, 0
    STDIN
  when :out, 1
    STDOUT
  when :err, 2
    STDERR
  when Integer
    object >= 0 ? IO.for_fd(object) : nil
  when IO
    object
  else
    object.respond_to?(:to_io) ? object.to_io : nil
  end
end

def flatten_process_spawn_options!(options)
  options.to_a.each do |key, value|
    if key.respond_to?(:to_ary)
      key.to_ary.each { |fd| options[fd] = value }
      options.delete(key)
    end
  end
end

def fspawn(*args)
  env, argv, options = extract_process_spawn_arguments(*args)
  valid_options = [:chdir, :unsetenv_others, :pgroup]
  if badopt = options.find{ |key,val| !fd?(key) && !valid_options.include?(key) }
    raise ArgumentError, "Invalid option: #{badopt[0].inspect}"
  elsif !argv.is_a?(Array) || !argv[0].is_a?(Array) || argv[0].size != 2
    raise ArgumentError, "Invalid command name"
  end
  fork do
    begin
      # handle FD => {FD, :close, [file,mode,perms]} options
      options.each do |key, val|
        if fd?(key)
          key = fd_to_io(key)
          if fd?(val)
            val = fd_to_io(val)
            key.reopen(val)
            if key.respond_to?(:close_on_exec=)
              key.close_on_exec = false
              val.close_on_exec = false
            end
          elsif val == :close
            if key.respond_to?(:close_on_exec=)
              key.close_on_exec = true
            else
              key.close
            end
          elsif val.is_a?(Array)
            file, mode_string, perms = *val
            key.reopen(File.open(file, mode_string, perms))
          end
        end
      end
      # setup child environment
      ENV.replace({}) if options[:unsetenv_others] == true
      env.each { |k, v| ENV[k] = v }
      # { :chdir => '/' } in options means change into that dir
      ::Dir.chdir(options[:chdir]) if options[:chdir]
      # { :pgroup => pgid } options
      pgroup = options[:pgroup]
      pgroup = 0 if pgroup == true
      Process::setpgid(0, pgroup) if pgroup
      # do the deed
      if RUBY_VERSION =~ /\A1\.8/
        ::Kernel::exec(*argv)
      else
        argv_and_options = argv + [{:close_others=>false}]
        ::Kernel::exec(*argv_and_options)
      end
    ensure
      exit!(127)
    end
  end
end

def normalize_process_spawn_redirect_file_options!(options)
  options.to_a.each do |key, value|
    next if !fd?(key)
    # convert string and short array values to
    if value.respond_to?(:to_str)
      value = default_file_reopen_info(key, value)
    elsif value.respond_to?(:to_ary) && value.size < 3
      defaults = default_file_reopen_info(key, value[0])
      value += defaults[value.size..-1]
    else
      value = nil
    end
    # replace string open mode flag maybe and replace original value
    if value
      value[1] = OFLAGS[value[1]] if value[1].respond_to?(:to_str)
      options[key] = value
    end
  end
end

def popen4(*argv)
  # create some pipes (see pipe(2) manual -- the ruby docs suck)
  ird, iwr = IO.pipe
  ord, owr = IO.pipe
  erd, ewr = IO.pipe
  # spawn the child process with either end of pipes hooked together
  opts =
    ((argv.pop if argv[-1].is_a?(Hash)) || {}).merge(
      # redirect fds        # close other sides
      :in  => ird,          iwr  => :close,
      :out => owr,          ord  => :close,
      :err => ewr,          erd  => :close
    )
  pid = spawn(*(argv + [opts]))
  [pid, iwr, ord, erd]
ensure
  # we're in the parent, close child-side fds
  [ird, owr, ewr].each { |fd| fd.close if fd }
end

def pspawn(*args)
  env, argv, options = extract_process_spawn_arguments(*args)
  raise NotImplementedError unless respond_to?(:_pspawn)
  if defined? JRUBY_VERSION
    # On the JVM, changes made to the environment are not propagated down
    # to C via get/setenv, so we have to fake it here.
    unless options[:unsetenv_others] == true
      env = ENV.merge(env)
      options[:unsetenv_others] = true
    end
  end
  _pspawn(env, argv, options)
end

def spawn(*args)
  if respond_to?(:_pspawn)
    pspawn(*args)
  elsif ::Process.respond_to?(:spawn)
    ::Process::spawn(*args)
  else
    fspawn(*args)
  end
end

def system(*args)
  pid = spawn(*args)
  return false if pid <= 0
  ::Process.waitpid(pid)
  $?.exitstatus == 0
rescue Errno::ENOENT
  false
end

def system_command_prefixes
  if RUBY_PLATFORM =~ /(mswin|mingw|cygwin|bccwin)/
    sh = ENV['COMSPEC'] || 'cmd.exe'
    [[sh, sh], '/c']
  else
    [['/bin/sh', '/bin/sh'], '-c']
  end
end