Remove ProcessOptions and make the options named arguments.

runtime/bin/process_patch.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 patch class _WindowsCodePageDecoder {
   /* patch */ static String _decodeBytes(List<int> bytes)
       native "SystemEncodingToString";
 }
 
 
 patch class _WindowsCodePageEncoder {
   /* patch */ static List<int> _encodeString(String string)
       native "StringToSystemEncoding";
 }
 
 
 patch class Process {
-  /* patch */ static Future<Process> start(String executable,
-                                           List<String> arguments,
-                                           [ProcessOptions options]) {
-    _ProcessImpl process = new _ProcessImpl(executable, arguments, options);
+  /* patch */ static Future<Process> start(
+      String executable,
+      List<String> arguments,
+      {String workingDirectory,
+       Map<String, String> environment,
+       bool runInShell}) {
+    _ProcessImpl process = new _ProcessImpl(executable,
+                                            arguments,
+                                            workingDirectory,
+                                            environment,
+                                            runInShell);
     return process._start();
   }
 
-  /* patch */ static Future<ProcessResult> run(String executable,
-                                               List<String> arguments,
-                                               [ProcessOptions options]) {
-    return _runNonInteractiveProcess(executable, arguments, options);
+  /* patch */ static Future<ProcessResult> run(
+      String executable,
+      List<String> arguments,
+      {String workingDirectory,
+       Map<String, String> environment,
+       bool runInShell,
+       Encoding stdoutEncoding: Encoding.SYSTEM,
+       Encoding stderrEncoding: Encoding.SYSTEM}) {
+    return _runNonInteractiveProcess(executable,
+                                     arguments,
+                                     workingDirectory,
+                                     environment,
+                                     runInShell,
+                                     stdoutEncoding,
+                                     stderrEncoding);
   }
 }
 
 
 patch class _ProcessUtils {
   /* patch */ static void _exit(int status) native "Process_Exit";
   /* patch */ static void _setExitCode(int status)
       native "Process_SetExitCode";
   /* patch */ static void _sleep(int millis) native "Process_Sleep";
   /* patch */ static int _pid(Process process) native "Process_Pid";
 }
 
 
 class _ProcessStartStatus {
   int _errorCode;  // Set to OS error code if process start failed.
   String _errorMessage;  // Set to OS error message if process start failed.
 }
 
 
 class _ProcessImpl extends NativeFieldWrapperClass1 implements Process {
-  _ProcessImpl(String path, List<String> arguments, ProcessOptions options) {
+  _ProcessImpl(String path,
+               List<String> arguments,
+               String this._workingDirectory,
+               Map<String, String> environment,
+               bool runInShell) {
+    if (identical(runInShell, true)) {
+      arguments = _getShellArguments(path, arguments);
+      path = _getShellCommand();
+    }
+
     if (path is !String) {
       throw new ArgumentError("Path is not a String: $path");
     }
     _path = path;
 
     if (arguments is !List) {
       throw new ArgumentError("Arguments is not a List: $arguments");
     }
     int len = arguments.length;
     _arguments = new List<String>(len);
     for (int i = 0; i < len; i++) {
       var arg = arguments[i];
       if (arg is !String) {
         throw new ArgumentError("Non-string argument: $arg");
       }
       _arguments[i] = arguments[i];
       if (Platform.operatingSystem == 'windows') {
         _arguments[i] = _windowsArgumentEscape(_arguments[i]);
       }
     }
 
-    if (options != null && options.workingDirectory != null) {
-      _workingDirectory = options.workingDirectory;
-      if (_workingDirectory is !String) {
-        throw new ArgumentError(
-            "WorkingDirectory is not a String: $_workingDirectory");
-      }
+    if (_workingDirectory != null && _workingDirectory is !String) {
+      throw new ArgumentError(
+          "WorkingDirectory is not a String: $_workingDirectory");
     }
 
-    if (options != null && options.environment != null) {
-      var env = options.environment;
+    if (environment != null) {
+      var env = environment;
       if (env is !Map) {
         throw new ArgumentError("Environment is not a map: $env");
       }
       _environment = [];
       env.forEach((key, value) {
         if (key is !String || value is !String) {
           throw new ArgumentError(
               "Environment key or value is not a string: ($key, $value)");
         }
         _environment.add('$key=$value');
       });
     }
 
     // stdin going to process.
     _stdin = new _StdSink(new _Socket._writePipe());
     // stdout coming from process.
     _stdout = new _StdStream(new _Socket._readPipe());
     // stderr coming from process.
     _stderr = new _StdStream(new _Socket._readPipe());
     _exitHandler = new _Socket._readPipe();
     _ended = false;
     _started = false;
   }
 
+  static String _getShellCommand() {
+    if (Platform.operatingSystem == 'windows') {
+      return 'cmd.exe';
+    }
+    return '/bin/sh';
+  }
+
+  static List<String> _getShellArguments(String executable,
+                                         List<String> arguments) {
+    List<String> shellArguments = [];
+    if (Platform.operatingSystem == 'windows') {
+      shellArguments.add('/c');
+      shellArguments.add(executable);
+      for (var arg in arguments) {
+        arg = arg.replaceAll('"', r'\"');
+        shellArguments.add(arg);
+      }
+    } else {
+      var commandLine = new StringBuffer();
+      executable = executable.replaceAll("'", "'\"'\"'");
+      commandLine.write("'$executable'");
+      shellArguments.add("-c");
+      for (var arg in arguments) {
+        arg = arg.replaceAll("'", "'\"'\"'");
+        commandLine.write(" '$arg'");
+      }
+      shellArguments.add(commandLine.toString());
+    }
+    return shellArguments;
+  }
+
   String _windowsArgumentEscape(String argument) {
     var result = argument;
     if (argument.contains('\t') || argument.contains(' ')) {
       // Produce something that the C runtime on Windows will parse
       // back as this string.
 
       // Replace any number of '\' followed by '"' with
       // twice as many '\' followed by '\"'.
       var backslash = '\\'.codeUnitAt(0);
       var sb = new StringBuffer();
@@ skipping 150 matching lines @@
   final Completer<int> _exitCode = new Completer<int>();
 }
 
 
 // _NonInteractiveProcess is a wrapper around an interactive process
 // that buffers output so it can be delivered when the process exits.
 // _NonInteractiveProcess is used to implement the Process.run
 // method.
 Future<ProcessResult> _runNonInteractiveProcess(String path,
                                                 List<String> arguments,
-                                                ProcessOptions options) {
+                                                String workingDirectory,
+                                                Map<String, String> environment,
+                                                bool runInShell,
+                                                Encoding stdoutEncoding,
+                                                Encoding stderrEncoding) {
   // Extract output encoding options and verify arguments.
-  var stdoutEncoding = Encoding.SYSTEM;
-  var stderrEncoding = Encoding.SYSTEM;
-  if (options != null) {
-    if (options.stdoutEncoding != null) {
-      stdoutEncoding = options.stdoutEncoding;
-      if (stdoutEncoding is !Encoding) {
-        throw new ArgumentError(
-            'stdoutEncoding option is not an encoding: $stdoutEncoding');
-      }
-    }
-    if (options.stderrEncoding != null) {
-      stderrEncoding = options.stderrEncoding;
-      if (stderrEncoding is !Encoding) {
-        throw new ArgumentError(
-            'stderrEncoding option is not an encoding: $stderrEncoding');
-      }
-    }
-  }
+  if (stdoutEncoding == null) stdoutEncoding = Encoding.SYSTEM;
+  if (stderrEncoding == null) stderrEncoding = Encoding.SYSTEM;
 
   // Start the underlying process.
-  return Process.start(path, arguments, options).then((Process p) {
+  return Process.start(path,
+                       arguments,
+                       workingDirectory: workingDirectory,
+                       environment: environment,
+                       runInShell: runInShell).then((Process p) {
     int pid = p.pid;
 
     // Make sure the process stdin is closed.
     p.stdin.close();
 
     // Setup stdout handling.
     Future<StringBuffer> stdout = p.stdout
         .transform(new StringDecoder(stdoutEncoding))
         .fold(
             new StringBuffer(),
@@ skipping 25 matching lines @@
   const _ProcessResult(int this.pid,
                        int this.exitCode,
                        String this.stdout,
                        String this.stderr);
 
   final int pid;
   final int exitCode;
   final String stdout;
   final String stderr;
 }