Format all dart: library files

sdk/lib/io/file_system_entity.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.
 
 part of dart.io;
 
 /**
  * The type of an entity on the file system, such as a file, directory, or link.
  *
  * These constants are used by the [FileSystemEntity] class
  * to indicate the object's type.
  *
  */
 
 class FileSystemEntityType {
   static const FILE = const FileSystemEntityType._internal(0);
   static const DIRECTORY = const FileSystemEntityType._internal(1);
   static const LINK = const FileSystemEntityType._internal(2);
   static const NOT_FOUND = const FileSystemEntityType._internal(3);
-  static const _typeList = const [FileSystemEntityType.FILE,
-                                  FileSystemEntityType.DIRECTORY,
-                                  FileSystemEntityType.LINK,
-                                  FileSystemEntityType.NOT_FOUND];
+  static const _typeList = const [
+    FileSystemEntityType.FILE,
+    FileSystemEntityType.DIRECTORY,
+    FileSystemEntityType.LINK,
+    FileSystemEntityType.NOT_FOUND
+  ];
   final int _type;
 
   const FileSystemEntityType._internal(this._type);
 
   static FileSystemEntityType _lookup(int type) => _typeList[type];
   String toString() => const ['FILE', 'DIRECTORY', 'LINK', 'NOT_FOUND'][_type];
 }
 
 /**
  * A FileStat object represents the result of calling the POSIX stat() function
@@ skipping 35 matching lines @@
   /**
    * The mode of the file system object.  Permissions are encoded in the lower
    * 16 bits of this number, and can be decoded using the [modeString] getter.
    */
   final int mode;
   /**
    * The size of the file system object.
    */
   final int size;
 
-  FileStat._internal(this.changed,
-                     this.modified,
-                     this.accessed,
-                     this.type,
-                     this.mode,
-                     this.size);
+  FileStat._internal(this.changed, this.modified, this.accessed, this.type,
+      this.mode, this.size);
 
-  const FileStat._internalNotFound() :
-      changed = null,  modified = null, accessed = null,
-      type = FileSystemEntityType.NOT_FOUND, mode = 0, size = -1;
+  const FileStat._internalNotFound()
+      : changed = null,
+        modified = null,
+        accessed = null,
+        type = FileSystemEntityType.NOT_FOUND,
+        mode = 0,
+        size = -1;
 
   external static _statSync(String path);
 
-
   /**
    * Calls the operating system's stat() function on [path].
    * Returns a [FileStat] object containing the data returned by stat().
    * If the call fails, returns a [FileStat] object with .type set to
    * FileSystemEntityType.NOT_FOUND and the other fields invalid.
    */
   static FileStat statSync(String path) {
     // Trailing path is not supported on Windows.
     if (Platform.isWindows) {
       path = FileSystemEntity._trimTrailingPathSeparators(path);
@@ skipping 53 matching lines @@
    * by prepending "(suid)", "(guid)", and/or "(sticky)" to the mode string.
    */
   String modeString() {
     var permissions = mode & 0xFFF;
     var codes = const ['---', '--x', '-w-', '-wx', 'r--', 'r-x', 'rw-', 'rwx'];
     var result = [];
     if ((permissions & 0x800) != 0) result.add("(suid) ");
     if ((permissions & 0x400) != 0) result.add("(guid) ");
     if ((permissions & 0x200) != 0) result.add("(sticky) ");
     result
-        ..add(codes[(permissions >> 6) & 0x7])
-        ..add(codes[(permissions >> 3) & 0x7])
-        ..add(codes[permissions & 0x7]);
+      ..add(codes[(permissions >> 6) & 0x7])
+      ..add(codes[(permissions >> 3) & 0x7])
+      ..add(codes[permissions & 0x7]);
     return result.join();
   }
 }
 
-
 /**
  * The common super class for [File], [Directory], and [Link] objects.
  *
  * [FileSystemEntity] objects are returned from directory listing
  * operations. To determine if a FileSystemEntity is a [File], a
  * [Directory], or a [Link] perform a type check:
  *
  *     if (entity is File) (entity as File).readAsStringSync();
  *
  * You can also use the [type] or [typeSync] methods to determine
@@ skipping 73 matching lines @@
    * Renames this file system entity. Returns a `Future<FileSystemEntity>`
    * that completes with a [FileSystemEntity] instance for the renamed
    * file system entity.
    *
    * If [newPath] identifies an existing entity of the same type, that entity
    * is replaced. If [newPath] identifies an existing entity of a different
    * type, the operation fails and the future completes with an exception.
    */
   Future<FileSystemEntity> rename(String newPath);
 
-   /**
+  /**
    * Synchronously renames this file system entity. Returns a [FileSystemEntity]
    * instance for the renamed entity.
    *
    * If [newPath] identifies an existing entity of the same type, that entity
    * is replaced. If [newPath] identifies an existing entity of a different
    * type, the operation fails and an exception is thrown.
    */
   FileSystemEntity renameSync(String newPath);
 
   /**
@@ skipping 18 matching lines @@
    *     var path = Uri.parse('.').resolveUri(new Uri.file(input)).toFilePath();
    *     if (path == '') path = '.';
    *     new File(path).resolveSymbolicLinks().then((resolved) {
    *       print(resolved);
    *     });
    *
    * since `Uri.resolve` removes `..` segments. This will result in the Windows
    * behavior.
    */
   Future<String> resolveSymbolicLinks() {
-    return _IOService._dispatch(_FILE_RESOLVE_SYMBOLIC_LINKS, [path])
-        .then((response) {
-          if (_isErrorResponse(response)) {
-            throw _exceptionFromResponse(response,
-                                         "Cannot resolve symbolic links",
-                                         path);
-          }
-          return response;
-        });
+    return _IOService
+        ._dispatch(_FILE_RESOLVE_SYMBOLIC_LINKS, [path]).then((response) {
+      if (_isErrorResponse(response)) {
+        throw _exceptionFromResponse(
+            response, "Cannot resolve symbolic links", path);
+      }
+      return response;
+    });
   }
 
   /**
    * Resolves the path of a file system object relative to the
    * current working directory, resolving all symbolic links on
    * the path and resolving all `..` and `.` path segments.
    *
    * [resolveSymbolicLinksSync] uses the operating system's native
    * file system API to resolve the path, using the `realpath` function
    * on linux and OS X, and the `GetFinalPathNameByHandle` function on
@@ skipping 15 matching lines @@
    *
    * since `Uri.resolve` removes `..` segments. This will result in the Windows
    * behavior.
    */
   String resolveSymbolicLinksSync() {
     var result = _resolveSymbolicLinks(path);
     _throwIfError(result, "Cannot resolve symbolic links", path);
     return result;
   }
 
-
   /**
    * Calls the operating system's stat() function on the [path] of this
    * [FileSystemEntity].  Identical to [:FileStat.stat(this.path):].
    *
    * Returns a [:Future<FileStat>:] object containing the data returned by
    * stat().
    *
    * If the call fails, completes the future with a [FileStat] object
    * with .type set to
    * FileSystemEntityType.NOT_FOUND and the other fields invalid.
@@ skipping 23 matching lines @@
    *
    * If [recursive] is true, the [FileSystemEntity] is deleted even if the type
    * of the [FileSystemEntity] doesn't match the content of the file system.
    * This behavior allows [delete] to be used to unconditionally delete any file
    * system object.
    *
    * Returns a [:Future<FileSystemEntity>:] that completes with this
    * [FileSystemEntity] when the deletion is done. If the [FileSystemEntity]
    * cannot be deleted, the future completes with an exception.
    */
-  Future<FileSystemEntity> delete({bool recursive: false})
-      => _delete(recursive: recursive);
+  Future<FileSystemEntity> delete({bool recursive: false}) =>
+      _delete(recursive: recursive);
 
   /**
    * Synchronously deletes this [FileSystemEntity].
    *
    * If the [FileSystemEntity] is a directory, and if [recursive] is false,
    * the directory must be empty. Otherwise, if [recursive] is true, the
    * directory and all sub-directories and files in the directories are
    * deleted. Links are not followed when deleting recursively. Only the link
    * is deleted, not its target.
    *
    * If [recursive] is true, the [FileSystemEntity] is deleted even if the type
    * of the [FileSystemEntity] doesn't match the content of the file system.
    * This behavior allows [deleteSync] to be used to unconditionally delete any
    * file system object.
    *
    * Throws an exception if the [FileSystemEntity] cannot be deleted.
    */
-  void deleteSync({bool recursive: false})
-      => _deleteSync(recursive: recursive);
-
+  void deleteSync({bool recursive: false}) => _deleteSync(recursive: recursive);
 
   /**
    * Start watching the [FileSystemEntity] for changes.
    *
    * The implementation uses platform-dependent event-based APIs for receiving
    * file-system notifications, thus behavior depends on the platform.
    *
    *   * `Windows`: Uses `ReadDirectoryChangesW`. The implementation only
    *     supports watching directories. Recursive watching is supported.
    *   * `Linux`: Uses `inotify`. The implementation supports watching both
@@ skipping 12 matching lines @@
    *   * The [Stream] is canceled, e.g. by calling `cancel` on the
    *      [StreamSubscription].
    *   * The [FileSystemEntity] being watches, is deleted.
    *
    * Use `events` to specify what events to listen for. The constants in
    * [FileSystemEvent] can be or'ed together to mix events. Default is
    * [FileSystemEvent.ALL].
    *
    * A move event may be reported as seperate delete and create events.
    */
-  Stream<FileSystemEvent> watch({int events: FileSystemEvent.ALL,
-                                 bool recursive: false})
-     => _FileSystemWatcher._watch(_trimTrailingPathSeparators(path),
-                                 events,
-                                 recursive);
+  Stream<FileSystemEvent> watch(
+          {int events: FileSystemEvent.ALL, bool recursive: false}) =>
+      _FileSystemWatcher._watch(
+          _trimTrailingPathSeparators(path), events, recursive);
 
   Future<FileSystemEntity> _delete({bool recursive: false});
   void _deleteSync({bool recursive: false});
 
   /**
    * Checks whether two paths refer to the same object in the
    * file system. Returns a [:Future<bool>:] that completes with the result.
    *
    * Comparing a link to its target returns false, as does comparing two links
    * that point to the same target.  To check the target of a link, use
    * Link.target explicitly to fetch it.  Directory links appearing
    * inside a path are followed, though, to find the file system object.
    *
    * Completes the returned Future with an error if one of the paths points
    * to an object that does not exist.
    */
   static Future<bool> identical(String path1, String path2) {
-    return _IOService._dispatch(_FILE_IDENTICAL, [path1, path2]).then((response) {
+    return _IOService
+        ._dispatch(_FILE_IDENTICAL, [path1, path2]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
             "Error in FileSystemEntity.identical($path1, $path2)", "");
       }
       return response;
     });
   }
 
   static final RegExp _absoluteWindowsPathPattern =
       new RegExp(r'^(\\\\|[a-zA-Z]:[/\\])');
@@ skipping 27 matching lines @@
     if (isAbsolute) return path;
     String current = Directory.current.path;
     if (current.endsWith('/') ||
         (Platform.isWindows && current.endsWith('\\'))) {
       return '$current$path';
     } else {
       return '$current${Platform.pathSeparator}$path';
     }
   }
 
-
   /**
    * Synchronously checks whether two paths refer to the same object in the
    * file system.
    *
    * Comparing a link to its target returns false, as does comparing two links
    * that point to the same target.  To check the target of a link, use
    * Link.target explicitly to fetch it.  Directory links appearing
    * inside a path are followed, though, to find the file system object.
    *
    * Throws an error if one of the paths points to an object that does not
@@ skipping 18 matching lines @@
    *
    * [FileSystemEntityType] has the constant instances FILE, DIRECTORY,
    * LINK, and NOT_FOUND.  [type] will return LINK only if the optional
    * named argument [followLinks] is false, and [path] points to a link.
    * If the path does not point to a file system object, or any other error
    * occurs in looking up the path, NOT_FOUND is returned.  The only
    * error or exception that may be put on the returned future is ArgumentError,
    * caused by passing the wrong type of arguments to the function.
    */
   static Future<FileSystemEntityType> type(String path,
-                                           {bool followLinks: true})
-      => _getTypeAsync(path, followLinks).then(FileSystemEntityType._lookup);
+          {bool followLinks: true}) =>
+      _getTypeAsync(path, followLinks).then(FileSystemEntityType._lookup);
 
   /**
    * Synchronously finds the type of file system object that a path points to.
    * Returns a [FileSystemEntityType].
    *
    * [FileSystemEntityType] has the constant instances FILE, DIRECTORY,
    * LINK, and NOT_FOUND.  [type] will return LINK only if the optional
    * named argument [followLinks] is false, and [path] points to a link.
    * If the path does not point to a file system object, or any other error
    * occurs in looking up the path, NOT_FOUND is returned.  The only
    * error or exception that may be thrown is ArgumentError,
    * caused by passing the wrong type of arguments to the function.
    */
-  static FileSystemEntityType typeSync(String path, {bool followLinks: true})
-      => FileSystemEntityType._lookup(_getTypeSync(path, followLinks));
+  static FileSystemEntityType typeSync(String path, {bool followLinks: true}) =>
+      FileSystemEntityType._lookup(_getTypeSync(path, followLinks));
 
   /**
    * Checks if type(path, followLinks: false) returns
    * FileSystemEntityType.LINK.
    */
   static Future<bool> isLink(String path) => _getTypeAsync(path, false)
       .then((type) => (type == FileSystemEntityType.LINK._type));
 
   /**
    * Checks if type(path) returns FileSystemEntityType.FILE.
@@ skipping 26 matching lines @@
    * FileSystemEntityType.DIRECTORY.
    */
   static bool isDirectorySync(String path) =>
       (_getTypeSync(path, true) == FileSystemEntityType.DIRECTORY._type);
 
   external static _getType(String path, bool followLinks);
   external static _identical(String path1, String path2);
   external static _resolveSymbolicLinks(String path);
 
   // Finds the next-to-last component when dividing at path separators.
-  static final RegExp _parentRegExp = Platform.isWindows ?
-     new RegExp(r'[^/\\][/\\]+[^/\\]') :
-     new RegExp(r'[^/]/+[^/]');
+  static final RegExp _parentRegExp = Platform.isWindows
+      ? new RegExp(r'[^/\\][/\\]+[^/\\]')
+      : new RegExp(r'[^/]/+[^/]');
 
   /**
    * Removes the final path component of a path, using the platform's
    * path separator to split the path.  Will not remove the root component
    * of a Windows path, like "C:\\" or "\\\\server_name\\".
    * Ignores trailing path separators, and leaves no trailing path separators.
    */
   static String parentOf(String path) {
     int rootEnd = -1;
     if (Platform.isWindows) {
@@ skipping 24 matching lines @@
    */
   Directory get parent => new Directory(parentOf(path));
 
   static int _getTypeSync(String path, bool followLinks) {
     var result = _getType(path, followLinks);
     _throwIfError(result, 'Error getting type of FileSystemEntity');
     return result;
   }
 
   static Future<int> _getTypeAsync(String path, bool followLinks) {
-    return _IOService._dispatch(_FILE_TYPE, [path, followLinks])
-      .then((response) {
-        if (_isErrorResponse(response)) {
-          throw _exceptionFromResponse(response, "Error getting type", path);
-        }
-        return response;
-      });
+    return _IOService
+        ._dispatch(_FILE_TYPE, [path, followLinks]).then((response) {
+      if (_isErrorResponse(response)) {
+        throw _exceptionFromResponse(response, "Error getting type", path);
+      }
+      return response;
+    });
   }
 
   static _throwIfError(Object result, String msg, [String path]) {
     if (result is OSError) {
       throw new FileSystemException(msg, path, result);
     } else if (result is ArgumentError) {
       throw result;
     }
   }
 
   static String _trimTrailingPathSeparators(String path) {
     // Don't handle argument errors here.
     if (path is! String) return path;
     if (Platform.isWindows) {
       while (path.length > 1 &&
-             (path.endsWith(Platform.pathSeparator) ||
-              path.endsWith('/'))) {
+          (path.endsWith(Platform.pathSeparator) || path.endsWith('/'))) {
         path = path.substring(0, path.length - 1);
       }
     } else {
       while (path.length > 1 && path.endsWith(Platform.pathSeparator)) {
         path = path.substring(0, path.length - 1);
       }
     }
     return path;
   }
 
   static String _ensureTrailingPathSeparators(String path) {
     // Don't handle argument errors here.
     if (path is! String) return path;
     if (path.isEmpty) path = '.';
     if (Platform.isWindows) {
       while (!path.endsWith(Platform.pathSeparator) && !path.endsWith('/')) {
         path = "$path${Platform.pathSeparator}";
       }
     } else {
       while (!path.endsWith(Platform.pathSeparator)) {
         path = "$path${Platform.pathSeparator}";
       }
     }
     return path;
   }
 }
 
-
 /**
  * Base event class emitted by [FileSystemEntity.watch].
  */
 class FileSystemEvent {
   /**
    * Bitfield for [FileSystemEntity.watch], to enable [FileSystemCreateEvent]s.
    */
   static const int CREATE = 1 << 0;
 
   /**
@@ skipping 33 matching lines @@
   final String path;
 
   /**
    * Is `true` if the event target was a directory.
    */
   final bool isDirectory;
 
   FileSystemEvent._(this.type, this.path, this.isDirectory);
 }
 
-
 /**
  * File system event for newly created file system objects.
  */
 class FileSystemCreateEvent extends FileSystemEvent {
   FileSystemCreateEvent._(path, isDirectory)
       : super._(FileSystemEvent.CREATE, path, isDirectory);
 
   String toString() => "FileSystemCreateEvent('$path')";
 }
 
-
 /**
  * File system event for modifications of file system objects.
  */
 class FileSystemModifyEvent extends FileSystemEvent {
   /**
    * If the content was changed and not only the attributes, [contentChanged]
    * is `true`.
    */
   final bool contentChanged;
 
   FileSystemModifyEvent._(path, isDirectory, this.contentChanged)
       : super._(FileSystemEvent.MODIFY, path, isDirectory);
 
   String toString() =>
       "FileSystemModifyEvent('$path', contentChanged=$contentChanged)";
 }
 
-
 /**
  * File system event for deletion of file system objects.
  */
 class FileSystemDeleteEvent extends FileSystemEvent {
   FileSystemDeleteEvent._(path, isDirectory)
       : super._(FileSystemEvent.DELETE, path, isDirectory);
 
   String toString() => "FileSystemDeleteEvent('$path')";
 }
 
-
 /**
  * File system event for moving of file system objects.
  */
 class FileSystemMoveEvent extends FileSystemEvent {
   /**
    * If the underlying implementation is able to identify the destination of
    * the moved file, [destination] will be set. Otherwise, it will be `null`.
    */
   final String destination;
 
   FileSystemMoveEvent._(path, isDirectory, this.destination)
       : super._(FileSystemEvent.MOVE, path, isDirectory);
 
   String toString() {
     var buffer = new StringBuffer();
     buffer.write("FileSystemMoveEvent('$path'");
     if (destination != null) buffer.write(", '$destination'");
     buffer.write(')');
     return buffer.toString();
   }
 }
 
-
 class _FileSystemWatcher {
   external static Stream<FileSystemEvent> _watch(
       String path, int events, bool recursive);
   external static bool get isSupported;
 }