style(dart): Format Dart source with dart_style 0.1.8

modules/angular2/angular2_sfx.dart

@@ -1,2 +1,3 @@
 library angular2.sfx;
+
 // empty as we don't have a version for Dart

modules/angular2/src/core/compiler/directive_lifecycle_reflector.dart

@@ -13,16 +13,12 @@ bool hasLifecycleHook(LifecycleEvent e, type, Directive annotation) {
 
     if (e == onChange) {
       interface = OnChange;
-
     } else if (e == onDestroy) {
       interface = OnDestroy;
-
     } else if (e == onAllChangesDone) {
       interface = OnAllChangesDone;
-
     } else if (e == onCheck) {
       interface = OnCheck;
-
     } else if (e == onInit) {
       interface = OnInit;
     }

modules/angular2/src/core/zone/ng_zone.dart

@@ -52,15 +52,13 @@ class NgZone {
     _mountZone = Zone.current;
 
     if (enableLongStackTrace) {
-      _innerZone = Chain.capture(
+      _innerZone = Chain.capture(() => _createInnerZone(Zone.current),
-          () => _createInnerZone(Zone.current),
           onError: _onErrorWithLongStackTrace);
     } else {
-      _innerZone = _createInnerZone(
+      _innerZone = _createInnerZone(Zone.current,
-          Zone.current,
+          handleUncaughtError: (Zone self, ZoneDelegate parent, Zone zone,
-          handleUncaughtError: (Zone self, ZoneDelegate parent, Zone zone, error, StackTrace trace) =>
+              error,
-              _onErrorWithoutLongStackTrace(error, trace)
+              StackTrace trace) => _onErrorWithoutLongStackTrace(error, trace));
-      );
     }
   }
 
@@ -75,7 +73,8 @@ class NgZone {
    * @param {Function} onTurnDone called at the end of a VM turn if code has executed in the inner zone
    * @param {Function} onErrorHandler called when an exception is thrown by a macro or micro task
    */
-  void initCallbacks({Function onTurnStart, Function onTurnDone, Function onErrorHandler}) {
+  void initCallbacks(
+      {Function onTurnStart, Function onTurnDone, Function onErrorHandler}) {
     _onTurnStart = onTurnStart;
     _onTurnDone = onTurnDone;
     _onErrorHandler = onErrorHandler;
@@ -160,8 +159,8 @@ class NgZone {
   dynamic _runUnary(Zone self, ZoneDelegate parent, Zone zone, fn(arg), arg) =>
       _run(self, parent, zone, () => fn(arg));
 
-  dynamic _runBinary(Zone self, ZoneDelegate parent, Zone zone, fn(arg1, arg2), arg1, arg2) =>
+  dynamic _runBinary(Zone self, ZoneDelegate parent, Zone zone, fn(arg1, arg2),
-    _run(self, parent, zone, () => fn(arg1, arg2));
+      arg1, arg2) => _run(self, parent, zone, () => fn(arg1, arg2));
 
   void _scheduleMicrotask(Zone self, ZoneDelegate parent, Zone zone, fn) {
     _pendingMicrotasks++;
@@ -201,9 +200,7 @@ class NgZone {
             run: _run,
             runUnary: _runUnary,
             runBinary: _runBinary,
-        handleUncaughtError: handleUncaughtError
+            handleUncaughtError: handleUncaughtError),
-      ),
+        zoneValues: {'_innerZone': true});
-      zoneValues: {'_innerZone': true}
-    );
   }
 }

modules/angular2/src/facade/async.dart

@@ -6,13 +6,8 @@ export 'dart:async' show Future, Stream, StreamController, StreamSubscription;
 class PromiseWrapper {
   static Future resolve(obj) => new Future.value(obj);
 
-  static Future reject(obj, stackTrace) => new Future.error(
+  static Future reject(obj, stackTrace) => new Future.error(obj,
-      obj,
+      stackTrace != null ? stackTrace : obj is Error ? obj.stackTrace : null);
-      stackTrace != null
-        ? stackTrace
-        : obj is Error
-          ? obj.stackTrace
-          : null);
 
   static Future<List> all(List<Future> promises) => Future.wait(promises);
 
@@ -35,15 +30,17 @@ class PromiseWrapper {
 }
 
 class TimerWrapper {
-  static Timer setTimeout(fn(), int millis)
+  static Timer setTimeout(fn(), int millis) =>
-      => new Timer(new Duration(milliseconds: millis), fn);
+      new Timer(new Duration(milliseconds: millis), fn);
   static void clearTimeout(Timer timer) {
     timer.cancel();
   }
 
   static Timer setInterval(fn(), int millis) {
     var interval = new Duration(milliseconds: millis);
-    return new Timer.periodic(interval, (Timer timer) { fn(); });
+    return new Timer.periodic(interval, (Timer timer) {
+      fn();
+    });
   }
   static void clearInterval(Timer timer) {
     timer.cancel();

modules/angular2/src/reflection/reflection_capabilities.dart

@@ -57,7 +57,9 @@ class ReflectionCapabilities {
 
   List _convertParameter(ParameterMirror p) {
     var t = p.type;
-    var res = (!t.hasReflectedType || t.reflectedType == dynamic) ? [] : [t.reflectedType];
+    var res = (!t.hasReflectedType || t.reflectedType == dynamic)
+        ? []
+        : [t.reflectedType];
     res.addAll(p.metadata.map((m) => m.reflectee));
     return res;
   }

modules/angular2/src/services/xhr_impl.dart

@@ -8,10 +8,7 @@ import './xhr.dart' show XHR;
 @Injectable()
 class XHRImpl extends XHR {
   Future<String> get(String url) {
-
+    return HttpRequest.request(url).then((HttpRequest req) => req.responseText,
-    return HttpRequest
-        .request(url)
-        .then((HttpRequest req) => req.responseText,
         onError: (_) => new Future.error('Failed to load $url'));
   }
 }

modules/angular2/src/test_lib/e2e_util.dart

@@ -1,2 +1,3 @@
 library angular2.e2e_util;
+
 // empty as this file is node.js specific and should not be transpiled to dart

modules/angular2/src/test_lib/fake_async.dart

@@ -30,8 +30,18 @@ Function fakeAsync(Function fn) {
       new quiver.FakeAsync().run((quiver.FakeAsync async) {
         try {
           _fakeAsync = async;
-          List args = [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9]
+          List args = [
-              .takeWhile((a) => a != _u).toList();
+            a0,
+            a1,
+            a2,
+            a3,
+            a4,
+            a5,
+            a6,
+            a7,
+            a8,
+            a9
+          ].takeWhile((a) => a != _u).toList();
           return Function.apply(fn, args);
         } finally {
           _fakeAsync = null;
@@ -39,9 +49,8 @@ Function fakeAsync(Function fn) {
       });
     },
         zoneSpecification: new ZoneSpecification(
-        handleUncaughtError: (self, parent, zone, error, stackTrace)
+            handleUncaughtError: (self, parent, zone, error, stackTrace) =>
-            => throw error
+                throw error));
-    ));
   };
 }
 

modules/angular2/src/test_lib/perf_utils.dart

@@ -1,2 +1,3 @@
 library angular2.perf_util;
+
 // empty as this file is node.js specific and should not be transpiled to dart

modules/angular2/src/transform/common/directive_metadata_reader.dart

@@ -190,7 +190,6 @@ class _DirectiveMetadataVisitor extends Object
           '$propertyName.', '$expression' /* source */);
     }
     list.addAll(evaluated);
-
   }
 
   void _populateProperties(Expression propertiesValue) {

modules/angular2/test/core/compiler/directive_lifecycle_spec.dart

@@ -4,91 +4,110 @@ import 'package:angular2/test_lib.dart';
 import 'package:angular2/angular2.dart';
 import 'package:angular2/src/core/compiler/element_injector.dart';
 
-
 main() {
   describe('Create DirectiveMetadata', () {
     describe('lifecycle', () {
-      metadata(type, annotation) => DirectiveBinding.createFromType(type, annotation).metadata;
+      metadata(type, annotation) =>
+          DirectiveBinding.createFromType(type, annotation).metadata;
 
       describe("onChange", () {
         it("should be true when the directive implements OnChange", () {
-          expect(metadata(DirectiveImplementingOnChange, new Directive()).callOnChange).toBe(true);
+          expect(metadata(
+                  DirectiveImplementingOnChange, new Directive()).callOnChange)
+              .toBe(true);
         });
 
         it("should be true when the lifecycle includes onChange", () {
-          expect(metadata(DirectiveNoHooks, new Directive(lifecycle: [onChange])).callOnChange).toBe(true);
+          expect(metadata(DirectiveNoHooks,
+              new Directive(lifecycle: [onChange])).callOnChange).toBe(true);
         });
 
         it("should be false otherwise", () {
-          expect(metadata(DirectiveNoHooks, new Directive()).callOnChange).toBe(false);
+          expect(metadata(DirectiveNoHooks, new Directive()).callOnChange)
+              .toBe(false);
         });
 
         it("should be false when empty lifecycle", () {
-          expect(metadata(DirectiveImplementingOnChange, new Directive(lifecycle: [])).callOnChange).toBe(false);
+          expect(metadata(DirectiveImplementingOnChange,
+              new Directive(lifecycle: [])).callOnChange).toBe(false);
         });
       });
 
       describe("onDestroy", () {
         it("should be true when the directive implements OnDestroy", () {
-          expect(metadata(DirectiveImplementingOnDestroy, new Directive()).callOnDestroy).toBe(true);
+          expect(metadata(DirectiveImplementingOnDestroy,
+              new Directive()).callOnDestroy).toBe(true);
         });
 
         it("should be true when the lifecycle includes onDestroy", () {
-          expect(metadata(DirectiveNoHooks, new Directive(lifecycle: [onDestroy])).callOnDestroy).toBe(true);
+          expect(metadata(DirectiveNoHooks,
+              new Directive(lifecycle: [onDestroy])).callOnDestroy).toBe(true);
         });
 
         it("should be false otherwise", () {
-          expect(metadata(DirectiveNoHooks, new Directive()).callOnDestroy).toBe(false);
+          expect(metadata(DirectiveNoHooks, new Directive()).callOnDestroy)
+              .toBe(false);
         });
       });
 
       describe("onCheck", () {
         it("should be true when the directive implements OnCheck", () {
-          expect(metadata(DirectiveImplementingOnCheck, new Directive()).callOnCheck).toBe(true);
+          expect(metadata(
+                  DirectiveImplementingOnCheck, new Directive()).callOnCheck)
+              .toBe(true);
         });
 
         it("should be true when the lifecycle includes onCheck", () {
-          expect(metadata(DirectiveNoHooks, new Directive(lifecycle: [onCheck])).callOnCheck).toBe(true);
+          expect(metadata(DirectiveNoHooks,
+              new Directive(lifecycle: [onCheck])).callOnCheck).toBe(true);
         });
 
         it("should be false otherwise", () {
-          expect(metadata(DirectiveNoHooks, new Directive()).callOnCheck).toBe(false);
+          expect(metadata(DirectiveNoHooks, new Directive()).callOnCheck)
+              .toBe(false);
         });
       });
 
       describe("onInit", () {
         it("should be true when the directive implements OnInit", () {
-          expect(metadata(DirectiveImplementingOnInit, new Directive()).callOnInit).toBe(true);
+          expect(metadata(
+                  DirectiveImplementingOnInit, new Directive()).callOnInit)
+              .toBe(true);
         });
 
         it("should be true when the lifecycle includes onInit", () {
-          expect(metadata(DirectiveNoHooks, new Directive(lifecycle: [onInit])).callOnInit).toBe(true);
+          expect(metadata(DirectiveNoHooks,
+              new Directive(lifecycle: [onInit])).callOnInit).toBe(true);
         });
 
         it("should be false otherwise", () {
-          expect(metadata(DirectiveNoHooks, new Directive()).callOnInit).toBe(false);
+          expect(metadata(DirectiveNoHooks, new Directive()).callOnInit)
+              .toBe(false);
         });
       });
 
       describe("onAllChangesDone", () {
         it("should be true when the directive implements OnAllChangesDone", () {
-          expect(metadata(DirectiveImplementingOnAllChangesDone, new Directive()).callOnAllChangesDone).toBe(true);
+          expect(metadata(DirectiveImplementingOnAllChangesDone,
+              new Directive()).callOnAllChangesDone).toBe(true);
         });
 
         it("should be true when the lifecycle includes onAllChangesDone", () {
-          expect(metadata(DirectiveNoHooks, new Directive(lifecycle: [onAllChangesDone])).callOnAllChangesDone).toBe(true);
+          expect(metadata(DirectiveNoHooks, new Directive(
+              lifecycle: [onAllChangesDone])).callOnAllChangesDone).toBe(true);
         });
 
         it("should be false otherwise", () {
-          expect(metadata(DirectiveNoHooks, new Directive()).callOnAllChangesDone).toBe(false);
+          expect(metadata(
+                  DirectiveNoHooks, new Directive()).callOnAllChangesDone)
+              .toBe(false);
         });
       });
     });
   });
 }
 
-class DirectiveNoHooks {
+class DirectiveNoHooks {}
-}
 
 class DirectiveImplementingOnChange implements OnChange {
   onChange(_) {}

modules/angular2/test/core/compiler/integration_dart_spec.dart

@@ -6,12 +6,18 @@ import 'package:angular2/di.dart';
 import 'package:angular2/src/test_lib/test_bed.dart';
 import 'package:angular2/test_lib.dart';
 
-class MockException implements Error { var message; var stackTrace; }
+class MockException implements Error {
-class NonError { var message; }
+  var message;
+  var stackTrace;
+}
+class NonError {
+  var message;
+}
 
 void functionThatThrows() {
-  try { throw new MockException(); }
+  try {
-  catch(e, stack) {
+    throw new MockException();
+  } catch (e, stack) {
     // If we lose the stack trace the message will no longer match
     // the first line in the stack
     e.message = stack.toString().split('\n')[0];
@@ -21,8 +27,9 @@ void functionThatThrows() {
 }
 
 void functionThatThrowsNonError() {
-  try { throw new NonError(); }
+  try {
-  catch(e, stack) {
+    throw new NonError();
+  } catch (e, stack) {
     // If we lose the stack trace the message will no longer match
     // the first line in the stack
     e.message = stack.toString().split('\n')[0];
@@ -32,12 +39,13 @@ void functionThatThrowsNonError() {
 
 main() {
   describe('TypeLiteral', () {
-    it('should publish via appInjector',
+    it('should publish via appInjector', inject([
-        inject([TestBed, AsyncTestCompleter], (tb, async) {
+      TestBed,
+      AsyncTestCompleter
+    ], (tb, async) {
       tb.overrideView(Dummy, new View(
           template: '<type-literal-component></type-literal-component>',
-        directives: [TypeLiteralComponent]
+          directives: [TypeLiteralComponent]));
-      ));
 
       tb.createView(Dummy).then((view) {
         view.detectChanges();
@@ -48,12 +56,13 @@ main() {
   });
 
   describe('Error handling', () {
-    it('should preserve Error stack traces thrown from components',
+    it('should preserve Error stack traces thrown from components', inject([
-        inject([TestBed, AsyncTestCompleter], (tb, async) {
+      TestBed,
+      AsyncTestCompleter
+    ], (tb, async) {
       tb.overrideView(Dummy, new View(
           template: '<throwing-component></throwing-component>',
-        directives: [ThrowingComponent]
+          directives: [ThrowingComponent]));
-      ));
 
       tb.createView(Dummy).catchError((e, stack) {
         expect(stack.toString().split('\n')[0]).toEqual(e.message);
@@ -61,12 +70,13 @@ main() {
       });
     }));
 
-    it('should preserve non-Error stack traces thrown from components',
+    it('should preserve non-Error stack traces thrown from components', inject([
-        inject([TestBed, AsyncTestCompleter], (tb, async) {
+      TestBed,
+      AsyncTestCompleter
+    ], (tb, async) {
       tb.overrideView(Dummy, new View(
           template: '<throwing-component2></throwing-component2>',
-        directives: [ThrowingComponent2]
+          directives: [ThrowingComponent2]));
-      ));
 
       tb.createView(Dummy).catchError((e, stack) {
         expect(stack.toString().split('\n')[0]).toEqual(e.message);
@@ -76,12 +86,13 @@ main() {
   });
 
   describe('Property access', () {
-    it('should distinguish between map and property access',
+    it('should distinguish between map and property access', inject([
-        inject([TestBed, AsyncTestCompleter], (tb, async) {
+      TestBed,
+      AsyncTestCompleter
+    ], (tb, async) {
       tb.overrideView(Dummy, new View(
           template: '<property-access></property-access>',
-        directives: [PropertyAccess]
+          directives: [PropertyAccess]));
-      ));
 
       tb.createView(Dummy).then((view) {
         view.detectChanges();
@@ -90,12 +101,13 @@ main() {
       });
     }));
 
-    it('should not fallback on map access if property missing',
+    it('should not fallback on map access if property missing', inject([
-        inject([TestBed, AsyncTestCompleter], (tb, async) {
+      TestBed,
+      AsyncTestCompleter
+    ], (tb, async) {
       tb.overrideView(Dummy, new View(
           template: '<no-property-access></no-property-access>',
-        directives: [NoPropertyAccess]
+          directives: [NoPropertyAccess]));
-      ));
 
       tb.createView(Dummy).then((view) {
         expect(() => view.detectChanges())
@@ -106,12 +118,13 @@ main() {
   });
 
   describe('OnChange', () {
-    it('should be notified of changes',
+    it('should be notified of changes', inject([
-        inject([TestBed, AsyncTestCompleter], (tb, async) {
+      TestBed,
+      AsyncTestCompleter
+    ], (tb, async) {
       tb.overrideView(Dummy, new View(
           template: '''<on-change [prop]="'hello'"></on-change>''',
-        directives: [OnChangeComponent]
+          directives: [OnChangeComponent]));
-      ));
 
       tb.createView(Dummy).then((view) {
         view.detectChanges();
@@ -130,23 +143,17 @@ class Dummy {}
 @Component(
     selector: 'type-literal-component',
     appInjector: const [
-      const Binding(
+  const Binding(const TypeLiteral<List<String>>(),
-          const TypeLiteral<List<String>>(),
       toValue: const <String>['Hello', 'World'])
-  ]
+])
-)
+@View(template: '{{list}}')
-@View(
-  template: '{{list}}'
-)
 class TypeLiteralComponent {
   final List<String> list;
 
   TypeLiteralComponent(this.list);
 }
 
-@Component(
+@Component(selector: 'throwing-component')
-  selector: 'throwing-component'
-)
 @View(template: '')
 class ThrowingComponent {
   ThrowingComponent() {
@@ -154,9 +161,7 @@ class ThrowingComponent {
   }
 }
 
-@Component(
+@Component(selector: 'throwing-component2')
-  selector: 'throwing-component2'
-)
 @View(template: '')
 class ThrowingComponent2 {
   ThrowingComponent2() {
@@ -187,12 +192,9 @@ class NoPropertyAccess {
   final model = new PropModel();
 }
 
-@Component(
+@Component(selector: 'on-change',
-  selector: 'on-change',
     // TODO: needed because of https://github.com/angular/angular/issues/2120
-  lifecycle: const [onChange],
+    lifecycle: const [onChange], properties: const ['prop'])
-  properties: const ['prop']
-)
 @View(template: '')
 class OnChangeComponent implements OnChange {
   Map changes;

modules/angular2/test/di/injector_dart_spec.dart

@@ -7,10 +7,8 @@ import 'package:angular2/di.dart';
 main() {
   describe('Injector', () {
     it('should support TypeLiteral', () {
-      var i = Injector.resolveAndCreate([
+      var i = Injector.resolveAndCreate(
-        bind(new TypeLiteral<List<int>>()).toValue([1, 2, 3]),
+          [bind(new TypeLiteral<List<int>>()).toValue([1, 2, 3]), Foo,]);
-        Foo,
-      ]);
       expect(i.get(Foo).value).toEqual([1, 2, 3]);
     });
   });

modules/angular2/test/facade/async_dart_spec.dart

@@ -4,12 +4,18 @@ library angular2.test.facade.async_dart_spec;
 import 'package:angular2/test_lib.dart';
 import 'package:angular2/src/facade/async.dart';
 
-class MockException implements Error { var message; var stackTrace; }
+class MockException implements Error {
-class NonError { var message; }
+  var message;
+  var stackTrace;
+}
+class NonError {
+  var message;
+}
 
 void functionThatThrows() {
-  try { throw new MockException(); }
+  try {
-  catch(e, stack) {
+    throw new MockException();
+  } catch (e, stack) {
     // If we lose the stack trace the message will no longer match
     // the first line in the stack
     e.message = stack.toString().split('\n')[0];
@@ -19,8 +25,9 @@ void functionThatThrows() {
 }
 
 void functionThatThrowsNonError() {
-  try { throw new NonError(); }
+  try {
-  catch(e, stack) {
+    throw new NonError();
+  } catch (e, stack) {
     // If we lose the stack trace the message will no longer match
     // the first line in the stack
     e.message = stack.toString().split('\n')[0];
@@ -39,9 +46,8 @@ void expectFunctionThatThrowsWithStackTrace(
 main() {
   describe('async facade', () {
     describe('Completer', () {
-
+      it('should preserve Error stack traces', inject([AsyncTestCompleter],
-      it('should preserve Error stack traces',
+          (async) {
-          inject([AsyncTestCompleter], (async) {
         var c = PromiseWrapper.completer();
 
         expectFunctionThatThrowsWithStackTrace(c.promise, async);
@@ -53,8 +59,8 @@ main() {
         }
       }));
 
-      it('should preserve error stack traces for non-Errors',
+      it('should preserve error stack traces for non-Errors', inject(
-          inject([AsyncTestCompleter], (async) {
+          [AsyncTestCompleter], (async) {
         var c = PromiseWrapper.completer();
 
         expectFunctionThatThrowsWithStackTrace(c.promise, async);
@@ -65,15 +71,12 @@ main() {
           c.reject(e, s);
         }
       }));
-
     });
 
     describe('PromiseWrapper', () {
-
       describe('reject', () {
-
+        it('should preserve Error stack traces', inject([AsyncTestCompleter],
-        it('should preserve Error stack traces',
+            (async) {
-            inject([AsyncTestCompleter], (async) {
           try {
             functionThatThrows();
           } catch (e) {
@@ -82,8 +85,8 @@ main() {
           }
         }));
 
-        it('should preserve stack traces for non-Errors',
+        it('should preserve stack traces for non-Errors', inject(
-            inject([AsyncTestCompleter], (async) {
+            [AsyncTestCompleter], (async) {
           try {
             functionThatThrowsNonError();
           } catch (e, s) {
@@ -91,10 +94,7 @@ main() {
             expectFunctionThatThrowsWithStackTrace(rejectedFuture, async);
           }
         }));
-
       });
-
     });
-
   });
 }