Reformat

pkg/analysis_server/lib/src/source/caching_pub_package_map_provider.dart

 // Copyright (c) 2015, 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.
 
 library source.caching_pub_package_map_provider;
 
 import 'dart:convert';
 import 'dart:io' as io;
 
 import 'package:analyzer/file_system/file_system.dart';
@@ skipping 57 matching lines @@
 
   /**
    * The function used to write the cache file.
    */
   WriteFile _writeFile;
 
   /**
    * Construct a new instance.
    * [RunPubList] and [WriteFile] implementations may be injected for testing
    */
-  CachingPubPackageMapProvider(ResourceProvider resourceProvider,
-      DirectoryBasedDartSdk sdk, [RunPubList runPubList, this._writeFile])
+  CachingPubPackageMapProvider(
+      ResourceProvider resourceProvider, DirectoryBasedDartSdk sdk,
+      [RunPubList runPubList, this._writeFile])
       : super(resourceProvider, sdk, runPubList) {
     if (_writeFile == null) {
       _writeFile = _writeFileDefault;
     }
   }
 
   File get cacheFile => _cacheDir.getChild('cache');
   Folder get _cacheDir => resourceProvider.getStateLocation('.pub-list');
   File get _touchFile => _cacheDir.getChild('touch');
 
@@ skipping 40 matching lines @@
       }
       // computePackageMap calls parsePackageMap which caches the result
       info = super.computePackageMap(folder);
       ++runCount;
       if (!_haveDependenciesChangedSince(info, startStamp)) {
         // If no dependencies have changed while running pub then finished
         break;
       }
       if (runCount == 4) {
         // Don't run forever
-        AnalysisEngine.instance.logger.logInformation(
-            'pub list called $runCount times: $folder');
+        AnalysisEngine.instance.logger
+            .logInformation('pub list called $runCount times: $folder');
         break;
       }
     }
     _writeCache();
     return info;
   }
 
   @override
   PackageMapInfo parsePackageMap(Map obj, Folder folder) {
     PackageMapInfo info = super.parsePackageMap(obj, folder);
@@ skipping 47 matching lines @@
   }
 
   /**
    * Read the cache from disk if it has not been read before.
    */
   void _readCache() {
     // TODO(danrubel) This implementation assumes that
     // two separate processes are not accessing the cache file at the same time
     Source source = cacheFile.createSource();
     if (source.exists() &&
-        (_cache == null || _cacheModificationTime != source.modificationStamp)) {
+        (_cache == null ||
+            _cacheModificationTime != source.modificationStamp)) {
       try {
         TimestampedData<String> data = source.contents;
         Map map = JSON.decode(data.data);
         if (map[cacheVersionKey] == cacheVersion) {
           _cache = map[cacheKey];
           _cacheModificationTime = data.modificationTime;
         }
       } catch (exception, stackTrace) {
         AnalysisEngine.instance.logger.logInformation(
             'Exception reading $cacheFile\n$exception\n$stackTrace');
       }
     }
     if (_cache == null) {
       _cache = new Map<String, Map>();
     }
   }
 
   /**
    * Write the cache to disk.
    */
   void _writeCache() {
     try {
-      _cacheModificationTime = _writeFile(cacheFile, JSON.encode({
-        cacheVersionKey: cacheVersion,
-        cacheKey: _cache
-      }));
+      _cacheModificationTime = _writeFile(cacheFile,
+          JSON.encode({cacheVersionKey: cacheVersion, cacheKey: _cache}));
     } catch (exception, stackTrace) {
       AnalysisEngine.instance.logger.logInformation(
           'Exception writing $cacheFile\n$exception\n$stackTrace');
     }
   }
 
   /**
    * Update the given file with the specified content.
    */
   int _writeFileDefault(File cacheFile, String content) {
     // TODO(danrubel) This implementation assumes that
     // two separate processes are not accessing the cache file at the same time
     io.File file = new io.File(cacheFile.path);
     if (!file.parent.existsSync()) {
       file.parent.createSync(recursive: true);
     }
     file.writeAsStringSync(content, flush: true);
     return file.lastModifiedSync().millisecondsSinceEpoch;
   }
 }