Format all dart: library files

sdk/lib/io/process.dart

 // Copyright (c) 2014, 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.
 
 part of dart.io;
 
 // TODO(ager): The only reason for this class is that we
 // cannot patch a top-level at this point.
 class _ProcessUtils {
   external static void _exit(int status);
@@ skipping 25 matching lines @@
  * Besides this the Dart executable itself uses an exit code of `254`
  * for reporting compile time errors and an exit code of `255` for
  * reporting runtime error (unhandled exception).
  *
  * Due to these facts it is recommended to only use exit codes in the
  * range [0..127] for communicating the result of running a Dart
  * program to the surrounding environment. This will avoid any
  * cross-platform issues.
  */
 void exit(int code) {
-  if (code is !int) {
+  if (code is! int) {
     throw new ArgumentError("Integer value for exit code expected");
   }
   _ProcessUtils._exit(code);
 }
 
 /**
  * Set the global exit code for the Dart VM.
  *
  * The exit code is global for the Dart VM and the last assignment to
  * exitCode from any isolate determines the exit code of the Dart VM
  * on normal termination.
  *
  * Default value is `0`.
  *
  * See [exit] for more information on how to chose a value for the
  * exit code.
  */
 void set exitCode(int code) {
-  if (code is !int) {
+  if (code is! int) {
     throw new ArgumentError("Integer value for exit code expected");
   }
   _ProcessUtils._setExitCode(code);
 }
 
 /**
  * Get the global exit code for the Dart VM.
  *
  * The exit code is global for the Dart VM and the last assignment to
  * exitCode from any isolate determines the exit code of the Dart VM
@@ skipping 22 matching lines @@
  * Returns the PID of the current process.
  */
 int get pid => _ProcessUtils._pid(null);
 
 /**
  * Modes for running a new process.
  */
 enum ProcessStartMode {
   /// Normal child process.
   NORMAL,
+
   /// Detached child process with no open communication channel.
   DETACHED,
+
   /// Detached child process with stdin, stdout and stderr still open
   /// for communication with the child.
   DETACHED_WITH_STDIO
 }
 
 /**
  * The means to execute a program.
  *
  * Use the static [start] and [run] methods to start a new process.
  * The run method executes the process non-interactively to completion.
@@ skipping 165 matching lines @@
    * If `mode` is [ProcessStartMode.DETACHED_WITH_STDIO] a detached
    * process will be created where the `stdin`, `stdout` and `stderr`
    * are connected. The creator can communicate with the child through
    * these. The detached process will keep running even if these
    * communication channels are closed. The process' exit code will
    * not become available when it terminated.
    *
    * The default value for `mode` is `ProcessStartMode.NORMAL`.
    */
   external static Future<Process> start(
-      String executable,
-      List<String> arguments,
+      String executable, List<String> arguments,
       {String workingDirectory,
-       Map<String, String> environment,
-       bool includeParentEnvironment: true,
-       bool runInShell: false,
-       ProcessStartMode mode: ProcessStartMode.NORMAL});
+      Map<String, String> environment,
+      bool includeParentEnvironment: true,
+      bool runInShell: false,
+      ProcessStartMode mode: ProcessStartMode.NORMAL});
 
   /**
    * Starts a process and runs it non-interactively to completion. The
    * process run is [executable] with the specified [arguments].
    *
    * Use [workingDirectory] to set the working directory for the process. Note
    * that the change of directory occurs before executing the process on some
    * platforms, which may have impact when using relative paths for the
    * executable and the arguments.
    *
@@ skipping 23 matching lines @@
    *
    * The following code uses `Process.run` to grep for `main` in the
    * file `test.dart` on Linux.
    *
    *     Process.run('grep', ['-i', 'main', 'test.dart']).then((result) {
    *       stdout.write(result.stdout);
    *       stderr.write(result.stderr);
    *     });
    */
   external static Future<ProcessResult> run(
-      String executable,
-      List<String> arguments,
+      String executable, List<String> arguments,
       {String workingDirectory,
-       Map<String, String> environment,
-       bool includeParentEnvironment: true,
-       bool runInShell: false,
-       Encoding stdoutEncoding: SYSTEM_ENCODING,
-       Encoding stderrEncoding: SYSTEM_ENCODING});
-
+      Map<String, String> environment,
+      bool includeParentEnvironment: true,
+      bool runInShell: false,
+      Encoding stdoutEncoding: SYSTEM_ENCODING,
+      Encoding stderrEncoding: SYSTEM_ENCODING});
 
   /**
    * Starts a process and runs it to completion. This is a synchronous
    * call and will block until the child process terminates.
    *
    * The arguments are the same as for `Process.run`.
    *
    * Returns a `ProcessResult` with the result of running the process,
    * i.e., exit code, standard out and standard in.
    */
   external static ProcessResult runSync(
-      String executable,
-      List<String> arguments,
+      String executable, List<String> arguments,
       {String workingDirectory,
-       Map<String, String> environment,
-       bool includeParentEnvironment: true,
-       bool runInShell: false,
-       Encoding stdoutEncoding: SYSTEM_ENCODING,
-       Encoding stderrEncoding: SYSTEM_ENCODING});
+      Map<String, String> environment,
+      bool includeParentEnvironment: true,
+      bool runInShell: false,
+      Encoding stdoutEncoding: SYSTEM_ENCODING,
+      Encoding stderrEncoding: SYSTEM_ENCODING});
 
   /**
    * Kills the process with id [pid].
    *
    * Where possible, sends the [signal] to the process with id
    * `pid`. This includes Linux and OS X. The default signal is
    * [ProcessSignal.SIGTERM] which will normally terminate the
    * process.
    *
    * On platforms without signal support, including Windows, the call
    * just terminates the process with id `pid` in a platform specific
    * way, and the `signal` parameter is ignored.
    *
    * Returns `true` if the signal is successfully delivered to the
    * process. Otherwise the signal could not be sent, usually meaning
    * that the process is already dead.
    */
-  external static bool killPid(
-      int pid, [ProcessSignal signal = ProcessSignal.SIGTERM]);
+  external static bool killPid(int pid,
+      [ProcessSignal signal = ProcessSignal.SIGTERM]);
 
   /**
    * Returns the standard output stream of the process as a [:Stream:].
    */
   Stream<List<int>> get stdout;
 
   /**
    * Returns the standard error stream of the process as a [:Stream:].
    */
   Stream<List<int>> get stderr;
@@ skipping 19 matching lines @@
    * just terminates the process in a platform specific way, and the
    * `signal` parameter is ignored.
    *
    * Returns `true` if the signal is successfully delivered to the
    * process. Otherwise the signal could not be sent, usually meaning
    * that the process is already dead.
    */
   bool kill([ProcessSignal signal = ProcessSignal.SIGTERM]);
 }
 
-
 /**
  * [ProcessResult] represents the result of running a non-interactive
  * process started with [Process.run] or [Process.runSync].
  */
 class ProcessResult {
   /**
    * Exit code for the process.
    *
    * See [Process.exitCode] for more information in the exit code
    * value.
@@ skipping 17 matching lines @@
   final stderr;
 
   /**
    * Process id of the process.
    */
   final int pid;
 
   ProcessResult(this.pid, this.exitCode, this.stdout, this.stderr);
 }
 
-
 /**
  * On Posix systems, [ProcessSignal] is used to send a specific signal
  * to a child process, see [:Process.kill:].
  *
  * Some [ProcessSignal]s can also be watched, as a way to intercept the default
  * signal handler and implement another. See [ProcessSignal.watch] for more
  * information.
  */
 class ProcessSignal {
   static const ProcessSignal SIGHUP = const ProcessSignal._(1, "SIGHUP");
@@ skipping 46 matching lines @@
    *   * [ProcessSignal.SIGWINCH]. Not available on Windows.
    *
    * Other signals are disallowed, as they may be used by the VM.
    *
    * A signal can be watched multiple times, from multiple isolates, where all
    * callbacks are invoked when signaled, in no specific order.
    */
   Stream<ProcessSignal> watch() => _ProcessUtils._watchSignal(this);
 }
 
-
 class SignalException implements IOException {
   final String message;
   final osError;
 
   const SignalException(this.message, [this.osError = null]);
 
   String toString() {
     var msg = "";
     if (osError != null) {
       msg = ", osError: $osError";
     }
     return "SignalException: $message$msg";
   }
 }
 
-
 class ProcessException implements IOException {
   /**
    * Contains the executable provided for the process.
    */
   final String executable;
 
   /**
    * Contains the arguments provided for the process.
    */
   final List<String> arguments;
 
   /**
    * Contains the system message for the process exception if any.
    */
   final String message;
 
   /**
    * Contains the OS error code for the process exception if any.
    */
   final int errorCode;
 
-  const ProcessException(this.executable, this.arguments, [this.message = "",
-                         this.errorCode = 0]);
+  const ProcessException(this.executable, this.arguments,
+      [this.message = "", this.errorCode = 0]);
   String toString() {
     var msg = (message == null) ? 'OS error code: $errorCode' : message;
     var args = arguments.join(' ');
     return "ProcessException: $msg\n  Command: $executable $args";
   }
 }