Added pedantic to Zefyr and fixed lint warnings

packages/zefyr/analysis_options.yaml

-analyzer:
-  strong-mode:
-    implicit-dynamic: false
-
-# Lint rules and documentation, see http://dart-lang.github.io/linter/lints
-linter:
-  rules:
-    - avoid_init_to_null
-    - cancel_subscriptions
-    - close_sinks
-    - directives_ordering
-    - hash_and_equals
-    - iterable_contains_unrelated_type
-    - list_remove_unrelated_type
-    - prefer_final_fields
-    - prefer_is_not_empty
-    - test_types_in_equals
-    - unrelated_type_equality_checks
-    - valid_regexps
+include: package:pedantic/analysis_options.yaml

packages/zefyr/example/lib/main.dart

 import 'src/view.dart';
 
 void main() {
-  runApp(new ZefyrApp());
+  runApp(ZefyrApp());
 }
 
 class ZefyrApp extends StatelessWidget {

packages/zefyr/example/lib/src/editor_page.dart

   @override
   void initState() {
     super.initState();
-    _focusNode = new FocusNode();
+    _focusNode = FocusNode();
     _loadDocument().then((document) {
       setState(() {
-        _controller = new ZefyrController(document);
+        _controller = ZefyrController(document);
       });
     });
   }

packages/zefyr/example/lib/src/form.dart

 
 class _FormEmbeddedScreenState extends State<FormEmbeddedScreen> {
   final ZefyrController _controller = ZefyrController(NotusDocument());
-  final FocusNode _focusNode = new FocusNode();
+  final FocusNode _focusNode = FocusNode();
 
   @override
   Widget build(BuildContext context) {
   }
 
   Widget buildEditor() {
-    final theme = new ZefyrThemeData(
+    final theme = ZefyrThemeData(
       toolbarTheme: ZefyrToolbarTheme.fallback(context).copyWith(
         color: Colors.grey.shade800,
         toggleColor: Colors.grey.shade900,
         controller: _controller,
         focusNode: _focusNode,
         autofocus: true,
-        imageDelegate: new CustomImageDelegate(),
+        imageDelegate: CustomImageDelegate(),
         physics: ClampingScrollPhysics(),
       ),
     );

packages/zefyr/example/lib/src/full_page.dart

 
 class FullPageEditorScreen extends StatefulWidget {
   @override
-  _FullPageEditorScreenState createState() => new _FullPageEditorScreenState();
+  _FullPageEditorScreenState createState() => _FullPageEditorScreenState();
 }
 
 final doc =
 class _FullPageEditorScreenState extends State<FullPageEditorScreen> {
   final ZefyrController _controller =
       ZefyrController(NotusDocument.fromDelta(getDelta()));
-  final FocusNode _focusNode = new FocusNode();
+  final FocusNode _focusNode = FocusNode();
   bool _editing = false;
   StreamSubscription<NotusChange> _sub;
 
 
   @override
   Widget build(BuildContext context) {
-    final theme = new ZefyrThemeData(
+    final theme = ZefyrThemeData(
       cursorColor: Colors.blue,
       toolbarTheme: ZefyrToolbarTheme.fallback(context).copyWith(
         color: Colors.grey.shade800,
     );
 
     final done = _editing
-        ? [new FlatButton(onPressed: _stopEditing, child: Text('DONE'))]
-        : [new FlatButton(onPressed: _startEditing, child: Text('EDIT'))];
+        ? [FlatButton(onPressed: _stopEditing, child: Text('DONE'))]
+        : [FlatButton(onPressed: _startEditing, child: Text('EDIT'))];
     return Scaffold(
       resizeToAvoidBottomPadding: true,
       appBar: AppBar(
             controller: _controller,
             focusNode: _focusNode,
             mode: _editing ? ZefyrMode.edit : ZefyrMode.select,
-            imageDelegate: new CustomImageDelegate(),
+            imageDelegate: CustomImageDelegate(),
           ),
         ),
       ),

packages/zefyr/example/lib/src/images.dart

       // Otherwise assume this is a file stored locally on user's device.
       final file = File.fromUri(Uri.parse(key));
       final image = FileImage(file);
-      return new Image(image: image);
+      return Image(image: image);
     }
   }
 }

packages/zefyr/example/lib/src/view.dart

 
 class ViewScreen extends StatefulWidget {
   @override
-  _ViewScreen createState() => new _ViewScreen();
+  _ViewScreen createState() => _ViewScreen();
 }
 
 final doc =
 
   @override
   Widget build(BuildContext context) {
-    final theme = new ZefyrThemeData(
+    final theme = ZefyrThemeData(
       toolbarTheme: ZefyrToolbarTheme.fallback(context).copyWith(
         color: Colors.grey.shade800,
         toggleColor: Colors.grey.shade900,
               padding: const EdgeInsets.all(16.0),
               child: ZefyrView(
                 document: doc,
-                imageDelegate: new CustomImageDelegate(),
+                imageDelegate: CustomImageDelegate(),
               ),
             )
           ],

packages/zefyr/lib/src/fast_diff.dart

   }
   final String deleted = (start < end) ? oldText.substring(start, end) : '';
   final inserted = newText.substring(start, end + delta);
-  return new DiffResult(start, deleted, inserted);
+  return DiffResult(start, deleted, inserted);
 }
 
 /// A diff between two strings of text.

packages/zefyr/lib/src/widgets/buttons.dart

     final editor = ZefyrToolbar.of(context).editor;
     final image =
         await editor.imageDelegate.pickImage(editor.imageDelegate.cameraSource);
-    if (image != null)
+    if (image != null) {
       editor.formatSelection(NotusAttribute.embed.image(image));
+    }
   }
 
   void _pickFromGallery() async {
     final editor = ZefyrToolbar.of(context).editor;
     final image = await editor.imageDelegate
         .pickImage(editor.imageDelegate.gallerySource);
-    if (image != null)
+    if (image != null) {
       editor.formatSelection(NotusAttribute.embed.image(image));
+    }
   }
 }
 
   final bool formatError;
 
   const _LinkInput(
-      {Key key, @required this.controller, this.formatError: false})
+      {Key key, @required this.controller, this.formatError = false})
       : super(key: key);
 
   @override

packages/zefyr/lib/src/widgets/controller.dart

 import 'package:quill_delta/quill_delta.dart';
 import 'package:zefyr/util.dart';
 
-const TextSelection _kZeroSelection = const TextSelection.collapsed(
+const TextSelection _kZeroSelection = TextSelection.collapsed(
   offset: 0,
   affinity: TextAffinity.upstream,
 );
   ///
   /// [value] and [source] cannot be `null`.
   void updateSelection(TextSelection value,
-      {ChangeSource source: ChangeSource.remote}) {
+      {ChangeSource source = ChangeSource.remote}) {
     _updateSelectionSilent(value, source: source);
     notifyListeners();
   }
 
   // Updates selection without triggering notifications to listeners.
   void _updateSelectionSilent(TextSelection value,
-      {ChangeSource source: ChangeSource.remote}) {
+      {ChangeSource source = ChangeSource.remote}) {
     assert(value != null && source != null);
     _selection = value;
     _lastChangeSource = source;
   ///
   /// If composing this change fails then this method throws [ComposeError].
   void compose(Delta change,
-      {TextSelection selection, ChangeSource source: ChangeSource.remote}) {
+      {TextSelection selection, ChangeSource source = ChangeSource.remote}) {
     if (change.isNotEmpty) {
       _document.compose(change, source);
     }

packages/zefyr/lib/src/widgets/cursor_timer.dart

 
 /// Helper class that keeps state relevant to the editing cursor.
 class CursorTimer {
-  static const _kCursorBlinkHalfPeriod = const Duration(milliseconds: 500);
+  static const _kCursorBlinkHalfPeriod = Duration(milliseconds: 500);
 
   Timer _timer;
-  final ValueNotifier<bool> _showCursor = new ValueNotifier<bool>(false);
+  final ValueNotifier<bool> _showCursor = ValueNotifier<bool>(false);
 
   ValueNotifier<bool> get value => _showCursor;
 
   /// Starts cursor timer.
   void start() {
     _showCursor.value = true;
-    _timer = new Timer.periodic(_kCursorBlinkHalfPeriod, _cursorTick);
+    _timer = Timer.periodic(_kCursorBlinkHalfPeriod, _cursorTick);
   }
 
   /// Stops cursor timer.

packages/zefyr/lib/src/widgets/editable_box.dart

 
   ContainerNode get node => _node;
   ContainerNode _node;
-  void set node(ContainerNode value) {
+  set node(ContainerNode value) {
     _node = value;
   }
 
   LayerLink get layerLink => _layerLink;
   LayerLink _layerLink;
-  void set layerLink(LayerLink value) {
+  set layerLink(LayerLink value) {
     if (_layerLink == value) return;
     _layerLink = value;
   }
 
   ZefyrRenderContext _renderContext;
-  void set renderContext(ZefyrRenderContext value) {
+  set renderContext(ZefyrRenderContext value) {
     if (_renderContext == value) return;
     if (attached) _renderContext.removeBox(this);
     _renderContext = value;

packages/zefyr/lib/src/widgets/editable_text.dart

     @required this.focusNode,
     @required this.imageDelegate,
     this.selectionControls,
-    this.autofocus: true,
-    this.mode: ZefyrMode.edit,
-    this.padding: const EdgeInsets.symmetric(horizontal: 16.0),
+    this.autofocus = true,
+    this.mode = ZefyrMode.edit,
+    this.padding = const EdgeInsets.symmetric(horizontal: 16.0),
     this.physics,
   })  : assert(mode != null),
         assert(controller != null),
   /// focus, the control will then attach to the keyboard and request that the
   /// keyboard become visible.
   void requestKeyboard() {
-    if (_focusNode.hasFocus)
+    if (_focusNode.hasFocus) {
       _input.openConnection(widget.controller.plainTextEditingValue);
-    else
+    } else {
       FocusScope.of(context).requestFocus(_focusNode);
+    }
   }
 
   void focusOrUnfocusIfNeeded() {

packages/zefyr/lib/src/widgets/editor.dart

     Key key,
     @required this.controller,
     @required this.focusNode,
-    this.autofocus: true,
-    this.mode: ZefyrMode.edit,
-    this.padding: const EdgeInsets.symmetric(horizontal: 16.0),
+    this.autofocus = true,
+    this.mode = ZefyrMode.edit,
+    this.padding = const EdgeInsets.symmetric(horizontal: 16.0),
     this.toolbarDelegate,
     this.imageDelegate,
     this.selectionControls,

packages/zefyr/lib/src/widgets/field.dart

     this.height,
     this.controller,
     this.focusNode,
-    this.autofocus: false,
+    this.autofocus = false,
     this.mode,
     this.toolbarDelegate,
     this.imageDelegate,

packages/zefyr/lib/src/widgets/horizontal_rule.dart

 
   @override
   RenderHorizontalRule createRenderObject(BuildContext context) {
-    return new RenderHorizontalRule(node: node);
+    return RenderHorizontalRule(node: node);
   }
 
   @override
     if (local.isCollapsed) {
       final dx = local.extentOffset == 0 ? 0.0 : size.width;
       return [
-        new ui.TextBox.fromLTRBD(dx, 0.0, dx, size.height, TextDirection.ltr),
+        ui.TextBox.fromLTRBD(dx, 0.0, dx, size.height, TextDirection.ltr),
       ];
     }
 
     return [
-      new ui.TextBox.fromLTRBD(0.0, 0.0, 0.0, size.height, TextDirection.ltr),
-      new ui.TextBox.fromLTRBD(
+      ui.TextBox.fromLTRBD(0.0, 0.0, 0.0, size.height, TextDirection.ltr),
+      ui.TextBox.fromLTRBD(
           size.width, 0.0, size.width, size.height, TextDirection.ltr),
     ];
   }
   @override
   void performLayout() {
     assert(constraints.hasBoundedWidth);
-    size = new Size(constraints.maxWidth, _kHeight);
+    size = Size(constraints.maxWidth, _kHeight);
   }
 
   @override
   void paint(PaintingContext context, Offset offset) {
-    final rect = new Rect.fromLTWH(0.0, 0.0, size.width, _kThickness);
-    final paint = new ui.Paint()..color = Colors.grey.shade200;
+    final rect = Rect.fromLTWH(0.0, 0.0, size.width, _kThickness);
+    final paint = ui.Paint()..color = Colors.grey.shade200;
     context.canvas.drawRect(rect.shift(offset), paint);
   }
 
     if (offset.dx > size.width / 2) {
       position++;
     }
-    return new TextPosition(offset: position);
+    return TextPosition(offset: position);
   }
 
   @override
   TextRange getWordBoundary(TextPosition position) {
     final start = _node.documentOffset;
-    return new TextRange(start: start, end: start + 1);
+    return TextRange(start: start, end: start + 1);
   }
 
   @override
     final localSelection = getLocalSelection(selection);
     assert(localSelection != null);
     if (!localSelection.isCollapsed) {
-      final Paint paint = new Paint()..color = selectionColor;
-      final rect = new Rect.fromLTWH(0.0, 0.0, size.width, _kHeight);
+      final Paint paint = Paint()..color = selectionColor;
+      final rect = Rect.fromLTWH(0.0, 0.0, size.width, _kHeight);
       context.canvas.drawRect(rect.shift(offset), paint);
     }
   }
     final pos = position.offset - node.documentOffset;
     Offset caretOffset = Offset.zero;
     if (pos == 1) {
-      caretOffset = caretOffset + new Offset(size.width - 1.0, 0.0);
+      caretOffset = caretOffset + Offset(size.width - 1.0, 0.0);
     }
     return caretOffset;
   }

packages/zefyr/lib/src/widgets/image.dart

   @override
   EmbedNode get node => _node;
   EmbedNode _node;
-  void set node(EmbedNode value) {
+  set node(EmbedNode value) {
     _node = value;
   }
 

packages/zefyr/lib/src/widgets/input.dart

       : assert(onValueChanged != null);
 
   //
-  // New public members
+  // public members
   //
 
   final RemoteValueChanged onValueChanged;

packages/zefyr/lib/src/widgets/quote.dart

 
     Widget content;
     if (line.style.contains(NotusAttribute.heading)) {
-      content = new ZefyrHeading(node: line, blockStyle: blockStyle);
+      content = ZefyrHeading(node: line, blockStyle: blockStyle);
     } else {
-      content = new ZefyrParagraph(node: line, blockStyle: blockStyle);
+      content = ZefyrParagraph(node: line, blockStyle: blockStyle);
     }
 
     final row = Row(children: <Widget>[Expanded(child: content)]);

packages/zefyr/lib/src/widgets/render_context.dart

 /// When a box is detached from rendering pipeline it unregisters
 /// itself by calling [removeBox].
 class ZefyrRenderContext extends ChangeNotifier {
-  final Set<RenderEditableProxyBox> _dirtyBoxes = new Set();
-  final Set<RenderEditableProxyBox> _activeBoxes = new Set();
+  final Set<RenderEditableProxyBox> _dirtyBoxes = Set();
+  final Set<RenderEditableProxyBox> _activeBoxes = Set();
 
   Set<RenderEditableProxyBox> get dirty => _dirtyBoxes;
   Set<RenderEditableProxyBox> get active => _activeBoxes;
     box = _activeBoxes.map((p) {
       final localPoint = p.globalToLocal(point);
       final distance = localPoint.dy - p.size.height;
-      return new MapEntry(distance.abs(), p);
+      return MapEntry(distance.abs(), p);
     }).reduce((a, b) {
       return (a.key <= b.key) ? a : b;
     }).value;

packages/zefyr/lib/src/widgets/rich_text.dart

   RenderZefyrParagraph(
     TextSpan text, {
     @required LineNode node,
-    TextAlign textAlign: TextAlign.start,
+    TextAlign textAlign = TextAlign.start,
     @required TextDirection textDirection,
-    bool softWrap: true,
-    TextOverflow overflow: TextOverflow.clip,
-    double textScaleFactor: 1.0,
+    bool softWrap = true,
+    TextOverflow overflow = TextOverflow.clip,
+    double textScaleFactor = 1.0,
     int maxLines,
   })  : _node = node,
         _prototypePainter = TextPainter(
 
   LineNode get node => _node;
   LineNode _node;
-  void set node(LineNode value) {
+  set node(LineNode value) {
     _node = value;
   }
 
   //
 
   @override
-  void set text(InlineSpan value) {
+  set text(InlineSpan value) {
     _prototypePainter.text = TextSpan(text: '.', style: value.style);
     _selectionRects = null;
     super.text = value;
       _selectionRects = null;
     }
     _selectionRects ??= getBoxesForSelection(getLocalSelection(selection));
-    final Paint paint = new Paint()..color = selectionColor;
+    final Paint paint = Paint()..color = selectionColor;
     for (ui.TextBox box in _selectionRects) {
       context.canvas.drawRect(box.toRect().shift(offset), paint);
     }

packages/zefyr/lib/src/widgets/scope.dart

   }
 
   void updateSelection(TextSelection value,
-      {ChangeSource source: ChangeSource.remote}) {
+      {ChangeSource source = ChangeSource.remote}) {
     assert(isEditable);
     assert(!_disposed);
     _controller.updateSelection(value, source: source);

packages/zefyr/lib/src/widgets/selection.dart

     _toolbarController?.stop();
   }
 
-  static const Duration _kFadeDuration = const Duration(milliseconds: 150);
+  static const Duration _kFadeDuration = Duration(milliseconds: 150);
 
   @override
   void initState() {

packages/zefyr/lib/src/widgets/theme.dart

   /// Returns `null` if there is no [ZefyrTheme] in the given build context
   /// and [nullOk] is set to `true`. If [nullOk] is set to `false` (default)
   /// then this method asserts.
-  static ZefyrThemeData of(BuildContext context, {bool nullOk: false}) {
+  static ZefyrThemeData of(BuildContext context, {bool nullOk = false}) {
     final ZefyrTheme widget = context.inheritFromWidgetOfExactType(ZefyrTheme);
     if (widget == null && nullOk) return null;
     assert(widget != null,
       color: Colors.grey.shade800,
     );
     final padding = const EdgeInsets.only(bottom: 16.0);
-    final boldStyle = new TextStyle(fontWeight: FontWeight.bold);
-    final italicStyle = new TextStyle(fontStyle: FontStyle.italic);
+    final boldStyle = TextStyle(fontWeight: FontWeight.bold);
+    final italicStyle = TextStyle(fontStyle: FontStyle.italic);
     final linkStyle =
         TextStyle(color: Colors.blue, decoration: TextDecoration.underline);
 
-    return new ZefyrThemeData(
+    return ZefyrThemeData(
       boldStyle: boldStyle,
       italicStyle: italicStyle,
       linkStyle: linkStyle,
-      paragraphTheme:
-          new StyleTheme(textStyle: paragraphStyle, padding: padding),
-      headingTheme: new HeadingTheme.fallback(),
-      blockTheme: new BlockTheme.fallback(themeData),
+      paragraphTheme: StyleTheme(textStyle: paragraphStyle, padding: padding),
+      headingTheme: HeadingTheme.fallback(),
+      blockTheme: BlockTheme.fallback(themeData),
       selectionColor: Colors.lightBlueAccent.shade100,
       cursorColor: Colors.black,
       indentSize: 16.0,
-      toolbarTheme: new ZefyrToolbarTheme.fallback(context),
+      toolbarTheme: ZefyrToolbarTheme.fallback(context),
     );
   }
 
     double indentSize,
     ZefyrToolbarTheme toolbarTheme,
   }) {
-    return new ZefyrThemeData(
+    return ZefyrThemeData(
       boldStyle: boldStyle ?? this.boldStyle,
       italicStyle: italicStyle ?? this.italicStyle,
       linkStyle: linkStyle ?? this.linkStyle,
         break;
     }
 
-    return new BlockTheme(
-      bulletList: new StyleTheme(padding: padding),
-      numberList: new StyleTheme(padding: padding),
-      quote: new StyleTheme(
-        textStyle: new TextStyle(color: Colors.grey.shade700),
+    return BlockTheme(
+      bulletList: StyleTheme(padding: padding),
+      numberList: StyleTheme(padding: padding),
+      quote: StyleTheme(
+        textStyle: TextStyle(color: Colors.grey.shade700),
         padding: padding,
       ),
-      code: new StyleTheme(
-        textStyle: new TextStyle(
+      code: StyleTheme(
+        textStyle: TextStyle(
           color: Colors.blueGrey.shade800,
           fontFamily: fontFamily,
           fontSize: 14.0,

packages/zefyr/lib/src/widgets/toolbar.dart

     Key key,
     @required this.body,
     this.trailing,
-    this.autoImplyTrailing: true,
+    this.autoImplyTrailing = true,
   }) : super(key: key);
 
   final Widget body;
   const ZefyrToolbar({
     Key key,
     @required this.editor,
-    this.autoHide: true,
+    this.autoHide = true,
     this.delegate,
   }) : super(key: key);
 

packages/zefyr/lib/src/widgets/view.dart

   Widget _defaultChildBuilder(BuildContext context, Node node) {
     if (node is LineNode) {
       if (node.hasEmbed) {
-        return new RawZefyrLine(node: node);
+        return RawZefyrLine(node: node);
       } else if (node.style.contains(NotusAttribute.heading)) {
-        return new ZefyrHeading(node: node);
+        return ZefyrHeading(node: node);
       }
-      return new ZefyrParagraph(node: node);
+      return ZefyrParagraph(node: node);
     }
 
     final BlockNode block = node;
     final blockStyle = block.style.get(NotusAttribute.block);
     if (blockStyle == NotusAttribute.block.code) {
-      return new ZefyrCode(node: block);
+      return ZefyrCode(node: block);
     } else if (blockStyle == NotusAttribute.block.bulletList) {
-      return new ZefyrList(node: block);
+      return ZefyrList(node: block);
     } else if (blockStyle == NotusAttribute.block.numberList) {
-      return new ZefyrList(node: block);
+      return ZefyrList(node: block);
     } else if (blockStyle == NotusAttribute.block.quote) {
-      return new ZefyrQuote(node: block);
+      return ZefyrQuote(node: block);
     }
 
-    throw new UnimplementedError('Block format $blockStyle.');
+    throw UnimplementedError('Block format $blockStyle.');
   }
 }

packages/zefyr/pubspec.yaml

 dev_dependencies:
   flutter_test:
     sdk: flutter
+  pedantic: ^1.0.0

packages/zefyr/test/painting/caret_painter_test.dart

 void main() {
   group('$CursorPainter', () {
     test('prototype is null before layout', () {
-      var painter = new CursorPainter(Colors.black);
+      var painter = CursorPainter(Colors.black);
       expect(painter.prototype, isNull);
     });
 
     test('prototype is set after layout', () {
-      var painter = new CursorPainter(Colors.black);
+      var painter = CursorPainter(Colors.black);
       painter.layout(16.0);
-      expect(painter.prototype, new Rect.fromLTWH(0.0, 0.0, 1.0, 14.0));
+      expect(painter.prototype, Rect.fromLTWH(0.0, 0.0, 1.0, 14.0));
     });
   });
 }

packages/zefyr/test/rendering/render_editable_proxy_box_test.dart

     });
 
     test('it registers with render context', () {
-      var owner = new PipelineOwner();
+      var owner = PipelineOwner();
       expect(renderContext.active, isNot(contains(p)));
       p.attach(owner);
       expect(renderContext.dirty, contains(p));

packages/zefyr/test/rendering/render_zefyr_paragraph_test.dart

 
 void main() {
   group('$RenderZefyrParagraph', () {
-    final doc = new NotusDocument();
+    final doc = NotusDocument();
     doc.insert(0, 'This House Is A Circus');
-    final text = new TextSpan(text: 'This House Is A Circus');
+    final text = TextSpan(text: 'This House Is A Circus');
 
     ZefyrRenderContext renderContext;
     RenderZefyrParagraph p;
 
     setUp(() {
       WidgetsFlutterBinding.ensureInitialized();
-      renderContext = new ZefyrRenderContext();
-      p = new RenderZefyrParagraph(
+      renderContext = ZefyrRenderContext();
+      p = RenderZefyrParagraph(
         text,
         node: doc.root.children.first as LineNode,
         textDirection: TextDirection.ltr,
     });
 
     test('it registers with viewport', () {
-      var owner = new PipelineOwner();
+      var owner = PipelineOwner();
       expect(renderContext.active, isNot(contains(p)));
       p.attach(owner);
       expect(renderContext.dirty, contains(p));
-      p.layout(new BoxConstraints());
+      p.layout(BoxConstraints());
       expect(renderContext.active, contains(p));
     }, skip: 'TODO: move to RenderEditableProxyBox');
   });

packages/zefyr/test/testing.dart

 import 'package:zefyr/src/widgets/selection.dart';
 import 'package:zefyr/zefyr.dart';
 
-var delta = new Delta()..insert('This House Is A Circus\n');
+var delta = Delta()..insert('This House Is A Circus\n');
 
 class EditorSandBox {
   final WidgetTester tester;
     FocusNode focusNode,
     NotusDocument document,
     ZefyrThemeData theme,
-    bool autofocus: false,
+    bool autofocus = false,
     ZefyrImageDelegate imageDelegate,
   }) {
     focusNode ??= FocusNode();
 
   Future<void> updateSelection({int base, int extent}) {
     controller.updateSelection(
-      new TextSelection(baseOffset: base, extentOffset: extent),
+      TextSelection(baseOffset: base, extentOffset: extent),
     );
     return tester.pumpAndSettle();
   }
 
   @override
   Widget build(BuildContext context) {
-    return new ZefyrEditor(
+    return ZefyrEditor(
       controller: widget.controller,
       focusNode: widget.focusNode,
       mode: _enabled ? ZefyrMode.edit : ZefyrMode.view,

packages/zefyr/test/util_test.dart

 void main() {
   group('getPositionDelta', () {
     test('actual has more characters inserted than user', () {
-      final user = new Delta()
+      final user = Delta()
         ..retain(7)
         ..insert('a');
-      final actual = new Delta()
+      final actual = Delta()
         ..retain(7)
         ..insert('\na');
       final result = getPositionDelta(user, actual);
     });
 
     test('actual has less characters inserted than user', () {
-      final user = new Delta()
+      final user = Delta()
         ..retain(7)
         ..insert('abc');
-      final actual = new Delta()
+      final actual = Delta()
         ..retain(7)
         ..insert('ab');
       final result = getPositionDelta(user, actual);
     });
 
     test('actual has less characters deleted than user', () {
-      final user = new Delta()
+      final user = Delta()
         ..retain(7)
         ..delete(3);
-      final actual = new Delta()
+      final actual = Delta()
         ..retain(7)
         ..delete(2);
       final result = getPositionDelta(user, actual);

packages/zefyr/test/widgets/buttons_test.dart

 void main() {
   group('$ZefyrButton', () {
     testWidgets('toggle style', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.updateSelection(base: 5, extent: 10);
       await editor.tapButtonWithIcon(Icons.format_bold);
 
     testWidgets('toggle state for different styles of the same attribute',
         (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
 
       await editor.tapButtonWithIcon(Icons.format_list_bulleted);
 
   group('$HeadingButton', () {
     testWidgets('toggle menu', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.format_size);
 
     });
 
     testWidgets('toggle styles', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.format_size);
       await editor.tapButtonWithText('H3');
     });
 
     testWidgets('close overlay', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.format_size);
       expect(find.text('H1'), findsOneWidget);
 
   group('$LinkButton', () {
     testWidgets('disabled when selection is collapsed', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.link);
       expect(find.byIcon(Icons.link_off), findsNothing);
 
     testWidgets('enabled and toggles menu with non-empty selection',
         (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.updateSelection(base: 5, extent: 10);
       await editor.tapButtonWithIcon(Icons.link);
     });
 
     testWidgets('auto cancels edit on selection update', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.updateSelection(base: 5, extent: 10);
       await editor.tapButtonWithIcon(Icons.link);
     });
 
     testWidgets('editing link', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.updateSelection(base: 5, extent: 10);
 
 
   group('$ImageButton', () {
     testWidgets('toggle overlay', (tester) async {
-      final editor = new EditorSandBox(
+      final editor = EditorSandBox(
         tester: tester,
         imageDelegate: _TestImageDelegate(),
       );
     });
 
     testWidgets('pick from camera', (tester) async {
-      final editor = new EditorSandBox(
+      final editor = EditorSandBox(
         tester: tester,
         imageDelegate: _TestImageDelegate(),
       );
     });
 
     testWidgets('pick from gallery', (tester) async {
-      final editor = new EditorSandBox(
+      final editor = EditorSandBox(
         tester: tester,
         imageDelegate: _TestImageDelegate(),
       );

packages/zefyr/test/widgets/code_test.dart

 void main() {
   group('$ZefyrCode', () {
     testWidgets('format as code', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.code);
 

packages/zefyr/test/widgets/controller_test.dart

     ZefyrController controller;
 
     setUp(() {
-      var doc = new NotusDocument();
-      controller = new ZefyrController(doc);
+      var doc = NotusDocument();
+      controller = ZefyrController(doc);
     });
 
     test('dispose', () {
       controller.addListener(() {
         notified = true;
       });
-      controller.updateSelection(new TextSelection.collapsed(offset: 0));
+      controller.updateSelection(TextSelection.collapsed(offset: 0));
       expect(notified, isTrue);
-      expect(controller.selection, new TextSelection.collapsed(offset: 0));
+      expect(controller.selection, TextSelection.collapsed(offset: 0));
       expect(controller.lastChangeSource, ChangeSource.remote);
     });
 
       controller.addListener(() {
         notified = true;
       });
-      var selection = new TextSelection.collapsed(offset: 5);
-      var change = new Delta()..insert('Words');
+      var selection = TextSelection.collapsed(offset: 5);
+      var change = Delta()..insert('Words');
       controller.compose(change, selection: selection);
       expect(notified, isTrue);
       expect(controller.selection, selection);
-      expect(controller.document.toDelta(), new Delta()..insert('Words\n'));
+      expect(controller.document.toDelta(), Delta()..insert('Words\n'));
       expect(controller.lastChangeSource, ChangeSource.remote);
     });
 
       controller.addListener(() {
         notified = true;
       });
-      var selection = new TextSelection.collapsed(offset: 5);
-      var change = new Delta()..insert('Words');
+      var selection = TextSelection.collapsed(offset: 5);
+      var change = Delta()..insert('Words');
       controller.compose(change, selection: selection);
-      var change2 = new Delta()..insert('More ');
+      var change2 = Delta()..insert('More ');
       controller.compose(change2);
       expect(notified, isTrue);
-      var expectedSelection = new TextSelection.collapsed(offset: 10);
+      var expectedSelection = TextSelection.collapsed(offset: 10);
       expect(controller.selection, expectedSelection);
       expect(
-          controller.document.toDelta(), new Delta()..insert('More Words\n'));
+          controller.document.toDelta(), Delta()..insert('More Words\n'));
       expect(controller.lastChangeSource, ChangeSource.remote);
     });
 
       controller.addListener(() {
         notified = true;
       });
-      var selection = new TextSelection.collapsed(offset: 5);
+      var selection = TextSelection.collapsed(offset: 5);
       controller.replaceText(0, 0, 'Words', selection: selection);
       expect(notified, isTrue);
       expect(controller.selection, selection);
-      expect(controller.document.toDelta(), new Delta()..insert('Words\n'));
+      expect(controller.document.toDelta(), Delta()..insert('Words\n'));
       expect(controller.lastChangeSource, ChangeSource.local);
     });
 
       expect(notified, isTrue);
       expect(
         controller.document.toDelta(),
-        new Delta()
+        Delta()
           ..insert('Words', NotusAttribute.bold.toJson())
           ..insert('\n'),
       );
       controller.addListener(() {
         notified = true;
       });
-      var selection = new TextSelection(baseOffset: 0, extentOffset: 5);
+      var selection = TextSelection(baseOffset: 0, extentOffset: 5);
       controller.replaceText(0, 0, 'Words', selection: selection);
       controller.formatSelection(NotusAttribute.bold);
       expect(notified, isTrue);
       expect(
         controller.document.toDelta(),
-        new Delta()
+        Delta()
           ..insert('Words', NotusAttribute.bold.toJson())
           ..insert('\n'),
       );
     });
 
     test('getSelectionStyle', () {
-      var selection = new TextSelection.collapsed(offset: 3);
+      var selection = TextSelection.collapsed(offset: 3);
       controller.replaceText(0, 0, 'Words', selection: selection);
       controller.formatText(0, 5, NotusAttribute.bold);
       var result = controller.getSelectionStyle();

packages/zefyr/test/widgets/editable_text_test.dart

 void main() {
   group('$ZefyrEditableText', () {
     testWidgets('user input', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       final currentValue = editor.document.toPlainText();
       await enterText(tester, 'Added $currentValue');
     });
 
     testWidgets('autofocus', (tester) async {
-      final editor = new EditorSandBox(tester: tester, autofocus: true);
+      final editor = EditorSandBox(tester: tester, autofocus: true);
       await editor.pump();
       expect(editor.focusNode.hasFocus, isTrue);
     });
 
     testWidgets('no autofocus', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pump();
       expect(editor.focusNode.hasFocus, isFalse);
     });
 Future<Null> enterText(WidgetTester tester, String text) async {
   return TestAsyncUtils.guard(() async {
     tester.testTextInput.updateEditingValue(
-      new TextEditingValue(
+      TextEditingValue(
         text: text,
-        selection: new TextSelection.collapsed(offset: 6),
+        selection: TextSelection.collapsed(offset: 6),
       ),
     );
     await tester.idle();

packages/zefyr/test/widgets/editor_test.dart

 void main() {
   group('$ZefyrEditor', () {
     testWidgets('allows merging theme data', (tester) async {
-      var delta = new Delta()
+      var delta = Delta()
         ..insert(
           'Website',
           NotusAttribute.link.fromString('https://github.com').toJson(),
         )
         ..insert('\n');
-      var doc = new NotusDocument.fromDelta(delta);
+      var doc = NotusDocument.fromDelta(delta);
       var theme = ZefyrThemeData(linkStyle: TextStyle(color: Colors.red));
       var editor =
-          new EditorSandBox(tester: tester, document: doc, theme: theme);
+          EditorSandBox(tester: tester, document: doc, theme: theme);
       await editor.pumpAndTap();
       // TODO: figure out why this extra pump is needed here
       await tester.pumpAndSettle();
     });
 
     testWidgets('collapses selection when unfocused', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.updateSelection(base: 0, extent: 3);
       expect(editor.findSelectionHandle(), findsNWidgets(2));
     });
 
     testWidgets('toggle enabled state', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.updateSelection(base: 0, extent: 3);
       await editor.disable();

packages/zefyr/test/widgets/horizontal_rule_test.dart

 void main() {
   group('$ZefyrHorizontalRule', () {
     testWidgets('format as horizontal rule', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.remove);
 
 
     testWidgets('tap left side of horizontal rule puts caret before it',
         (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.remove);
       await editor.updateSelection(base: 0, extent: 0);
 
     testWidgets('tap right side of horizontal rule puts caret after it',
         (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.remove);
       await editor.updateSelection(base: 0, extent: 0);
 
       final hr = find.byType(ZefyrHorizontalRule);
-      final offset = tester.getBottomRight(hr) - new Offset(1.0, 1.0);
+      final offset = tester.getBottomRight(hr) - Offset(1.0, 1.0);
       await tester.tapAt(offset);
       LineNode line = editor.document.root.children.last;
       EmbedNode embed = line.children.single;
 
     testWidgets('selects on long press',
         (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.remove);
       await editor.updateSelection(base: 0, extent: 0);

packages/zefyr/test/widgets/image_test.dart

 void main() {
   group('$ZefyrImage', () {
     testWidgets('embed image', (tester) async {
-      final editor = new EditorSandBox(
+      final editor = EditorSandBox(
         tester: tester,
         imageDelegate: _TestImageDelegate(),
       );
 
     testWidgets('tap on left side of image puts caret before it',
         (tester) async {
-      final editor = new EditorSandBox(
+      final editor = EditorSandBox(
         tester: tester,
         imageDelegate: _TestImageDelegate(),
       );
     });
 
     testWidgets('tap right side of image puts caret after it', (tester) async {
-      final editor = new EditorSandBox(
+      final editor = EditorSandBox(
         tester: tester,
         imageDelegate: _TestImageDelegate(),
       );
       await editor.updateSelection(base: 0, extent: 0);
 
       final img = find.byType(ZefyrImage);
-      final offset = tester.getBottomRight(img) - new Offset(1.0, 1.0);
+      final offset = tester.getBottomRight(img) - Offset(1.0, 1.0);
       await tester.tapAt(offset);
       LineNode line = editor.document.root.children.last;
       EmbedNode embed = line.children.single;
     });
 
     testWidgets('selects on long press', (tester) async {
-      final editor = new EditorSandBox(
+      final editor = EditorSandBox(
         tester: tester,
         imageDelegate: _TestImageDelegate(),
       );

packages/zefyr/test/widgets/list_test.dart

 void main() {
   group('$ZefyrList', () {
     testWidgets('format as list', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.format_list_bulleted);
       BlockNode block = editor.document.root.children.first;

packages/zefyr/test/widgets/quote_test.dart

 void main() {
   group('$ZefyrQuote', () {
     testWidgets('format as quote', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.tapButtonWithIcon(Icons.format_quote);
 

packages/zefyr/test/widgets/render_context_test.dart

 
     setUp(() {
       WidgetsFlutterBinding.ensureInitialized();
-      context = new ZefyrRenderContext();
+      context = ZefyrRenderContext();
     });
 
     test('adds to dirty list first', () {
 
     testWidgets('notifyListeners is delayed to next frame', (tester) async {
       var focusNode = FocusNode();
-      var controller = ZefyrController(new NotusDocument());
+      var controller = ZefyrController(NotusDocument());
       var widget = MaterialApp(
         home: ZefyrScaffold(
           child: ZefyrEditor(
 }
 
 RenderEditableProxyBox createParagraph(ZefyrRenderContext viewport) {
-  final doc = new NotusDocument();
+  final doc = NotusDocument();
   doc.insert(0, 'This House Is A Circus');
   final LineNode node = doc.root.children.first;
-  final link = new LayerLink();
-  final showCursor = new ValueNotifier<bool>(true);
-  final selection = new TextSelection.collapsed(offset: 0);
+  final link = LayerLink();
+  final showCursor = ValueNotifier<bool>(true);
+  final selection = TextSelection.collapsed(offset: 0);
   final selectionColor = Colors.blue;
-  return new RenderEditableProxyBox(
+  return RenderEditableProxyBox(
     node: node,
     layerLink: link,
     renderContext: viewport,

packages/zefyr/test/widgets/rich_text_test.dart

 
 void main() {
   group('$ZefyrRichText', () {
-    final doc = new NotusDocument();
+    final doc = NotusDocument();
     doc.insert(0, 'This House Is A Circus');
-    final text = new TextSpan(text: 'This House Is A Circus');
+    final text = TextSpan(text: 'This House Is A Circus');
 
     Widget widget;
     setUp(() {
-      widget = new Directionality(
+      widget = Directionality(
         textDirection: TextDirection.ltr,
-        child: new ZefyrRichText(
+        child: ZefyrRichText(
           node: doc.root.children.first as LineNode,
           text: text,
         ),

packages/zefyr/test/widgets/selection_test.dart

 void main() {
   group('$ZefyrSelectionOverlay', () {
     testWidgets('double tap caret shows toolbar', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
 
       RenderZefyrParagraph renderObject =
     });
 
     testWidgets('hides when editor lost focus', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       await editor.updateSelection(base: 0, extent: 5);
       expect(editor.findSelectionHandle(), findsNWidgets(2));
     });
 
     testWidgets('tap on padding area finds closest paragraph', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       editor.controller
-          .updateSelection(new TextSelection.collapsed(offset: 10));
+          .updateSelection(TextSelection.collapsed(offset: 10));
       await tester.pumpAndSettle();
       expect(editor.controller.selection.extentOffset, 10);
 
     });
 
     testWidgets('tap on empty space finds closest paragraph', (tester) async {
-      final editor = new EditorSandBox(tester: tester);
+      final editor = EditorSandBox(tester: tester);
       await editor.pumpAndTap();
       editor.controller.replaceText(10, 1, '\n',
-          selection: new TextSelection.collapsed(offset: 0));
+          selection: TextSelection.collapsed(offset: 0));
       await tester.pumpAndSettle();
       expect(editor.controller.document.toPlainText(),
           'This House\nIs A Circus\n');