Renamed StreamSink to EventSink. Renamed signalError to addError.

utils/pub/io.dart

 // Copyright (c) 2012, 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.
 
 /// Helper functionality to make working with IO easier.
 library io;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
@@ skipping 334 matching lines @@
   }
 
   return path.normalize(path.join(utilDir, 'pub', target));
 }
 
 // TODO(nweiz): add a ByteSink wrapper to make writing strings to stdout/stderr
 // nicer.
 
 /// A sink that writes to standard output. Errors piped to this stream will be
 /// surfaced to the top-level error handler.
-final StreamSink<List<int>> stdoutSink = _wrapStdio(stdout, "stdout");
+final EventSink<List<int>> stdoutSink = _wrapStdio(stdout, "stdout");
 
 /// A sink that writes to standard error. Errors piped to this stream will be
 /// surfaced to the top-level error handler.
-final StreamSink<List<int>> stderrSink = _wrapStdio(stderr, "stderr");
+final EventSink<List<int>> stderrSink = _wrapStdio(stderr, "stderr");
 
-/// Wrap the standard output or error [stream] in a [StreamSink]. Any errors are
+/// Wrap the standard output or error [stream] in a [EventSink]. Any errors are
 /// logged, and then the program is terminated. [name] is used for debugging.
-StreamSink<List<int>> _wrapStdio(IOSink sink, String name) {
+EventSink<List<int>> _wrapStdio(IOSink sink, String name) {
   var pair = consumerToSink(sink);
   pair.last.catchError((e) {
     // This log may or may not work, depending on how the stream failed. Not
     // much we can do about that.
     log.error("Error writing to $name: $e");
     exit(exit_codes.IO);
   });
   return pair.first;
 }
 
@@ skipping 13 matching lines @@
   return streamFirst(stdinLines)
       .then((line) => new RegExp(r"^[yY]").hasMatch(line));
 }
 
 /// Reads and discards all output from [stream]. Returns a [Future] that
 /// completes when the stream is closed.
 Future drainStream(Stream stream) {
   return stream.reduce(null, (x, y) {});
 }
 
-/// Returns a [StreamSink] that pipes all data to [consumer] and a [Future] that
-/// will succeed when [StreamSink] is closed or fail with any errors that occur
+/// Returns a [EventSink] that pipes all data to [consumer] and a [Future] that
+/// will succeed when [EventSink] is closed or fail with any errors that occur
 /// while writing.
-Pair<StreamSink, Future> consumerToSink(StreamConsumer consumer) {
+Pair<EventSink, Future> consumerToSink(StreamConsumer consumer) {
   var controller = new StreamController();
   var done = controller.stream.pipe(consumer);
-  return new Pair<StreamSink, Future>(controller.sink, done);
+  return new Pair<EventSink, Future>(controller.sink, done);
 }
 
 // TODO(nweiz): remove this when issue 7786 is fixed.
 /// Pipes all data and errors from [stream] into [sink]. When [stream] is done,
 /// the returned [Future] is completed and [sink] is closed if [closeSink] is
 /// true.
 ///
 /// When an error occurs on [stream], that error is passed to [sink]. If
 /// [unsubscribeOnError] is true, [Future] will be completed successfully and no
 /// more data or errors will be piped from [stream] to [sink]. If
 /// [unsubscribeOnError] and [closeSink] are both true, [sink] will then be
 /// closed.
-Future store(Stream stream, StreamSink sink,
+Future store(Stream stream, EventSink sink,
     {bool unsubscribeOnError: true, closeSink: true}) {
   var completer = new Completer();
   stream.listen(sink.add,
       onError: (e) {
-        sink.signalError(e);
+        sink.addError(e);
         if (unsubscribeOnError) {
           completer.complete();
           if (closeSink) sink.close();
         }
       },
       onDone: () {
         if (closeSink) sink.close();
         completer.complete();
       }, unsubscribeOnError: unsubscribeOnError);
   return completer.future;
@@ skipping 36 matching lines @@
     {workingDir, Map<String, String> environment}) =>
   _doProcess(Process.start, executable, args, workingDir, environment)
       .then((process) => new PubProcess(process));
 
 /// A wrapper around [Process] that exposes `dart:async`-style APIs.
 class PubProcess {
   /// The underlying `dart:io` [Process].
   final Process _process;
 
   /// The mutable field for [stdin].
-  StreamSink<List<int>> _stdin;
+  EventSink<List<int>> _stdin;
 
   /// The mutable field for [stdinClosed].
   Future _stdinClosed;
 
   /// The mutable field for [stdout].
   ByteStream _stdout;
 
   /// The mutable field for [stderr].
   ByteStream _stderr;
 
   /// The mutable field for [exitCode].
   Future<int> _exitCode;
 
   /// The sink used for passing data to the process's standard input stream.
   /// Errors on this stream are surfaced through [stdinClosed], [stdout],
   /// [stderr], and [exitCode], which are all members of an [ErrorGroup].
-  StreamSink<List<int>> get stdin => _stdin;
+  EventSink<List<int>> get stdin => _stdin;
 
   // TODO(nweiz): write some more sophisticated Future machinery so that this
   // doesn't surface errors from the other streams/futures, but still passes its
   // unhandled errors to them. Right now it's impossible to recover from a stdin
   // error and continue interacting with the process.
   /// A [Future] that completes when [stdin] is closed, either by the user or by
   /// the process itself.
   ///
   /// This is in an [ErrorGroup] with [stdout], [stderr], and [exitCode], so any
   /// error in process will be passed to it, but won't reach the top-level error
@@ skipping 228 matching lines @@
     var args = ["--create", "--gzip", "--directory", baseDir];
     args.addAll(contents);
     // TODO(nweiz): It's possible that enough command-line arguments will make
     // the process choke, so at some point we should save the arguments to a
     // file and pass them in via --files-from for tar and -i@filename for 7zip.
     startProcess("tar", args).then((process) {
       store(process.stdout, controller);
     }).catchError((e) {
       // We don't have to worry about double-signaling here, since the store()
       // above will only be reached if startProcess succeeds.
-      controller.signalError(e.error, e.stackTrace);
+      controller.addError(e.error, e.stackTrace);
       controller.close();
     });
     return new ByteStream(controller.stream);
   }
 
   withTempDir((tempDir) {
     // Create the tar file.
     var tarFile = path.join(tempDir, "intermediate.tar");
     var args = ["a", "-w$baseDir", tarFile];
     args.addAll(contents.map((entry) => '-i!"$entry"'));
@@ skipping 16 matching lines @@
       // Ignore 7zip's stderr. 7zip writes its normal output to stderr. We don't
       // want to show that since it's meaningless.
       //
       // TODO(rnystrom): Should log the stderr and display it if an actual error
       // occurs.
       return store(process.stdout, controller);
     });
   }).catchError((e) {
     // We don't have to worry about double-signaling here, since the store()
     // above will only be reached if everything succeeds.
-    controller.signalError(e.error, e.stackTrace);
+    controller.addError(e.error, e.stackTrace);
     controller.close();
   });
   return new ByteStream(controller.stream);
 }
 
 /// Exception thrown when an operation times out.
 class TimeoutException implements Exception {
   final String message;
 
   const TimeoutException(this.message);
@@ skipping 10 matching lines @@
   const PubProcessResult(this.stdout, this.stderr, this.exitCode);
 
   bool get success => exitCode == 0;
 }
 
 /// Gets a [Uri] for [uri], which can either already be one, or be a [String].
 Uri _getUri(uri) {
   if (uri is Uri) return uri;
   return Uri.parse(uri);
 }