Merge pull request #145 from memspace/remove-new-keyword

Removed 'new' keyword from zefyr package

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

       );
     } else {
       assert(_text != null);
-      var style = _textStyle ?? new TextStyle();
+      var style = _textStyle ?? TextStyle();
       style = style.copyWith(color: iconColor);
       return RawZefyrButton(
         action: action,
-        child: new Text(_text, style: style),
+        child: Text(_text, style: style),
         color: _getColor(editor, toolbarTheme),
         onPressed: _getPressedHandler(editor, toolbar),
       );
     Color iconColor,
     @required this.color,
     @required this.onPressed,
-  })  : child = new Icon(icon, size: size, color: iconColor),
+  })  : child = Icon(icon, size: size, color: iconColor),
         super();
 
   /// Toolbar action associated with this button.
   void edit() {
     final toolbar = ZefyrToolbar.of(context);
     setState(() {
-      _inputKey = new UniqueKey();
+      _inputKey = UniqueKey();
       _inputController.text = getLink('https://');
       _inputController.addListener(_handleInputChange);
       toolbar.markNeedsRebuild();
   void copyToClipboard() {
     var link = getLink();
     assert(link != null);
-    Clipboard.setData(new ClipboardData(text: link));
+    Clipboard.setData(ClipboardData(text: link));
   }
 
   void openInBrowser() async {
 
   @override
   _LinkInputState createState() {
-    return new _LinkInputState();
+    return _LinkInputState();
   }
 }
 
       focusNode: _focusNode,
       controller: widget.controller,
       autofocus: true,
-      decoration: new InputDecoration(
+      decoration: InputDecoration(
         hintText: 'https://',
         filled: true,
         fillColor: toolbarTheme.color,
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final toolbarTheme = ZefyrTheme.of(context).toolbarTheme;
-    Widget widget = new ClipRect(
+    Widget widget = ClipRect(
       child: ListView(
         scrollDirection: Axis.horizontal,
         children: <Widget>[

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

   static const double _kCaretWidth = 1.0; // pixels
 
   static Rect buildPrototype(double lineHeight) {
-    return new Rect.fromLTWH(
+    return Rect.fromLTWH(
         0.0, 0.0, _kCaretWidth, lineHeight - _kCaretHeightOffset);
   }
 
   }
 
   void paint(Canvas canvas, Offset offset) {
-    final Paint paint = new Paint()..color = _color;
+    final Paint paint = Paint()..color = _color;
     final Rect caretRect = _prototype.shift(offset);
     canvas.drawRect(caretRect, paint);
   }

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

       items.add(_buildLine(line, theme.blockTheme.code.textStyle));
     }
 
-    return new Padding(
+    return Padding(
       padding: theme.blockTheme.code.padding,
-      child: new Container(
+      child: Container(
         // TODO: make decorations configurable
         decoration: BoxDecoration(
           color: Colors.blueGrey.shade50,
           borderRadius: BorderRadius.circular(3.0),
         ),
         padding: const EdgeInsets.all(16.0),
-        child: new Column(
+        child: Column(
           crossAxisAlignment: CrossAxisAlignment.stretch,
           children: items,
         ),
 
   Widget _buildLine(Node node, TextStyle style) {
     LineNode line = node;
-    return new RawZefyrLine(node: line, style: style);
+    return RawZefyrLine(node: line, style: style);
   }
 }

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

   final EdgeInsets padding;
 
   @override
-  _RawZefyrLineState createState() => new _RawZefyrLineState();
+  _RawZefyrLineState createState() => _RawZefyrLineState();
 }
 
 class _RawZefyrLineState extends State<RawZefyrLine> {
-  final LayerLink _link = new LayerLink();
+  final LayerLink _link = LayerLink();
 
   @override
   Widget build(BuildContext context) {
     final List<TextSpan> children = widget.node.children
         .map((node) => _segmentToTextSpan(node, theme))
         .toList(growable: false);
-    return new TextSpan(style: widget.style, children: children);
+    return TextSpan(style: widget.style, children: children);
   }
 
   TextSpan _segmentToTextSpan(Node node, ZefyrThemeData theme) {
     final TextNode segment = node;
     final attrs = segment.style;
 
-    return new TextSpan(
+    return TextSpan(
       text: segment.value,
       style: _getTextStyle(attrs, theme),
     );
   }
 
   TextStyle _getTextStyle(NotusStyle style, ZefyrThemeData theme) {
-    TextStyle result = new TextStyle();
+    TextStyle result = TextStyle();
     if (style.containsSame(NotusAttribute.bold)) {
       result = result.merge(theme.boldStyle);
     }
     } else if (embed.type == EmbedType.image) {
       return ZefyrImage(node: node, delegate: scope.imageDelegate);
     } else {
-      throw new UnimplementedError('Unimplemented embed type ${embed.type}');
+      throw UnimplementedError('Unimplemented embed type ${embed.type}');
     }
   }
 }

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

       } else {
         // need to transform selection position in case actual delta
         // is different from user's version (in deletes and inserts).
-        Delta user = new Delta()
+        Delta user = Delta()
           ..retain(index)
           ..insert(text)
           ..delete(length);
     // the change. This is needed in cases when format operation actually
     // inserts data into the document (e.g. embeds).
     final base = change.transformPosition(_selection.baseOffset);
-    final extent =
-        change.transformPosition(_selection.extentOffset);
+    final extent = change.transformPosition(_selection.extentOffset);
     final adjustedSelection =
         _selection.copyWith(baseOffset: base, extentOffset: extent);
     if (_selection != adjustedSelection) {
   }
 
   TextEditingValue get plainTextEditingValue {
-    return new TextEditingValue(
+    return TextEditingValue(
       text: document.toPlainText(),
       selection: selection,
-      composing: new TextRange.collapsed(0),
+      composing: TextRange.collapsed(0),
     );
   }
 

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

 
   @override
   RenderEditableProxyBox createRenderObject(BuildContext context) {
-    return new RenderEditableProxyBox(
+    return RenderEditableProxyBox(
       node: node,
       layerLink: layerLink,
       renderContext: renderContext,
   @override
   bool hitTest(HitTestResult result, {Offset position}) {
     if (size.contains(position)) {
-      result.add(new BoxHitTestEntry(this, position));
+      result.add(BoxHitTestEntry(this, position));
       return true;
     }
     return false;

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

   final EdgeInsets padding;
 
   @override
-  _ZefyrEditableTextState createState() => new _ZefyrEditableTextState();
+  _ZefyrEditableTextState createState() => _ZefyrEditableTextState();
 }
 
 class _ZefyrEditableTextState extends State<ZefyrEditableText>
     _focusNode = widget.focusNode;
     super.initState();
     _focusAttachment = _focusNode.attach(context);
-    _input = new InputConnectionController(_handleRemoteValueChange);
+    _input = InputConnectionController(_handleRemoteValueChange);
     _updateSubscriptions();
   }
 
   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.');
   }
 
   void _updateSubscriptions([ZefyrEditableText oldWidget]) {

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

   final EdgeInsets padding;
 
   @override
-  _ZefyrEditorState createState() => new _ZefyrEditorState();
+  _ZefyrEditorState createState() => _ZefyrEditorState();
 }
 
 class _ZefyrEditorState extends State<ZefyrEditor> {
 
   @override
   Widget build(BuildContext context) {
-    Widget editable = new ZefyrEditableText(
+    Widget editable = ZefyrEditableText(
       controller: _scope.controller,
       focusNode: _scope.focusNode,
       imageDelegate: _scope.imageDelegate,

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

 
   @override
   RenderEditableImage createRenderObject(BuildContext context) {
-    return new RenderEditableImage(node: node);
+    return RenderEditableImage(node: node);
   }
 
   @override
     if (local.isCollapsed) {
       final dx = local.extentOffset == 0 ? _childOffset.dx : size.width;
       return [
-        new ui.TextBox.fromLTRBD(
+        ui.TextBox.fromLTRBD(
             dx, 0.0, dx, size.height - kPaddingBottom, TextDirection.ltr),
       ];
     }
 
     final rect = _childRect;
     return [
-      new ui.TextBox.fromLTRBD(
+      ui.TextBox.fromLTRBD(
           rect.left, rect.top, rect.left, rect.bottom, TextDirection.ltr),
-      new ui.TextBox.fromLTRBD(
+      ui.TextBox.fromLTRBD(
           rect.right, rect.top, rect.right, rect.bottom, TextDirection.ltr),
     ];
   }
     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
   @override
   Offset getOffsetForCaret(TextPosition position, Rect caretPrototype) {
     final pos = position.offset - node.documentOffset;
-    Offset caretOffset = _childOffset - new Offset(kHorizontalPadding, 0.0);
+    Offset caretOffset = _childOffset - Offset(kHorizontalPadding, 0.0);
     if (pos == 1) {
-      caretOffset = caretOffset +
-          new Offset(_lastChildSize.width + kHorizontalPadding, 0.0);
+      caretOffset =
+          caretOffset + Offset(_lastChildSize.width + kHorizontalPadding, 0.0);
     }
     return caretOffset;
   }
     final localSelection = getLocalSelection(selection);
     assert(localSelection != null);
     if (!localSelection.isCollapsed) {
-      final Paint paint = new Paint()
+      final Paint paint = Paint()
         ..color = selectionColor
         ..style = PaintingStyle.stroke
         ..strokeWidth = 3.0;
-      final rect = new Rect.fromLTWH(
-          0.0, 0.0, _lastChildSize.width, _lastChildSize.height);
+      final rect =
+          Rect.fromLTWH(0.0, 0.0, _lastChildSize.width, _lastChildSize.height);
       context.canvas.drawRect(rect.shift(offset + _childOffset), paint);
     }
   }
   Offset get _childOffset {
     final dx = (size.width - _lastChildSize.width) / 2 + kHorizontalPadding;
     final dy = (size.height - _lastChildSize.height - kPaddingBottom) / 2;
-    return new Offset(dx, dy);
+    return Offset(dx, dy);
   }
 
   Rect get _childRect {
-    return new Rect.fromLTWH(_childOffset.dx, _childOffset.dy,
-        _lastChildSize.width, _lastChildSize.height);
+    return Rect.fromLTWH(_childOffset.dx, _childOffset.dy, _lastChildSize.width,
+        _lastChildSize.height);
   }
 
   @override
       );
       child.layout(childConstraints, parentUsesSize: true);
       _lastChildSize = child.size;
-      size = new Size(
-          constraints.maxWidth, _lastChildSize.height + kPaddingBottom);
+      size = Size(constraints.maxWidth, _lastChildSize.height + kPaddingBottom);
     } else {
       performResize();
     }

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

       _lastKnownRemoteTextEditingValue = value;
       _textInputConnection = TextInput.attach(
         this,
-        new TextInputConfiguration(
+        TextInputConfiguration(
           inputType: TextInputType.multiline,
           obscureText: false,
           autocorrect: true,

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

         : theme.blockTheme.bulletList.padding;
     padding = padding.copyWith(left: theme.indentSize);
 
-    return new Padding(
+    return Padding(
       padding: padding,
-      child: new Column(children: items),
+      child: Column(children: items),
     );
   }
 
   Widget _buildItem(Node node, int index) {
     LineNode line = node;
-    return new ZefyrListItem(index: index, node: line);
+    return ZefyrListItem(index: index, node: line);
   }
 }
 
       final headingTheme = ZefyrHeading.themeOf(node, context);
       textStyle = headingTheme.textStyle;
       padding = headingTheme.padding;
-      content = new ZefyrHeading(node: node);
+      content = ZefyrHeading(node: node);
     } else {
       textStyle = theme.paragraphTheme.textStyle;
-      content = new RawZefyrLine(node: node, style: textStyle);
+      content = RawZefyrLine(node: node, style: textStyle);
     }
 
     Widget bullet =

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

     if (blockStyle != null) {
       style = style.merge(blockStyle);
     }
-    return new RawZefyrLine(
+    return RawZefyrLine(
       node: node,
       style: style,
       padding: theme.paragraphTheme.padding,
     if (blockStyle != null) {
       style = style.merge(blockStyle);
     }
-    return new RawZefyrLine(
+    return RawZefyrLine(
       node: node,
       style: style,
       padding: theme.padding,
     } else if (style == NotusAttribute.heading.level3) {
       return theme.headingTheme.level3;
     }
-    throw new UnimplementedError('Unsupported heading style $style');
+    throw UnimplementedError('Unsupported heading style $style');
   }
 }

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

 
   @override
   RenderObject createRenderObject(BuildContext context) {
-    return new RenderZefyrParagraph(
+    return RenderZefyrParagraph(
       text,
       node: node,
       textDirection: Directionality.of(context),
     double textScaleFactor: 1.0,
     int maxLines,
   })  : _node = node,
-        _prototypePainter = new TextPainter(
-          text: new TextSpan(text: '.', style: text.style),
+        _prototypePainter = TextPainter(
+          text: TextSpan(text: '.', style: text.style),
           textAlign: textAlign,
           textDirection: textDirection,
           textScaleFactor: textScaleFactor,
   @override
   TextPosition getPositionForOffset(Offset offset) {
     final position = super.getPositionForOffset(offset);
-    return new TextPosition(
+    return TextPosition(
       offset: _node.documentOffset + position.offset,
       affinity: position.affinity,
     );
 
   @override
   TextRange getWordBoundary(TextPosition position) {
-    final localPosition = new TextPosition(
+    final localPosition = TextPosition(
       offset: position.offset - _node.documentOffset,
       affinity: position.affinity,
     );
     final localRange = super.getWordBoundary(localPosition);
-    return new TextRange(
+    return TextRange(
       start: _node.documentOffset + localRange.start,
       end: _node.documentOffset + localRange.end,
     );
 
   @override
   Offset getOffsetForCaret(TextPosition position, Rect caretPrototype) {
-    final localPosition = new TextPosition(
+    final localPosition = TextPosition(
       offset: position.offset - _node.documentOffset,
       affinity: position.affinity,
     );
       final caret = CursorPainter.buildPrototype(preferredLineHeight);
       final offset = getOffsetForCaret(local.extent, caret);
       return [
-        new ui.TextBox.fromLTRBD(
+        ui.TextBox.fromLTRBD(
           offset.dx,
           offset.dy,
           offset.dx,
       final box = result.first;
       final dx = isBaseShifted == -1 ? box.right : box.left;
       result.removeAt(0);
-      result.insert(0,
-          new ui.TextBox.fromLTRBD(dx, box.top, dx, box.bottom, box.direction));
+      result.insert(
+          0, ui.TextBox.fromLTRBD(dx, box.top, dx, box.bottom, box.direction));
     }
     if (isExtentShifted) {
       final box = result.last;
       result.removeLast;
-      result.add(new ui.TextBox.fromLTRBD(
+      result.add(ui.TextBox.fromLTRBD(
           box.left, box.top, box.left, box.bottom, box.direction));
     }
     return result;
 
   @override
   void set text(InlineSpan value) {
-    _prototypePainter.text = new TextSpan(text: '.', style: value.style);
+    _prototypePainter.text = TextSpan(text: '.', style: value.style);
     _selectionRects = null;
     super.text = value;
   }

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

   final TextSelectionControls controls;
 
   @override
-  _ZefyrSelectionOverlayState createState() =>
-      new _ZefyrSelectionOverlayState();
+  _ZefyrSelectionOverlayState createState() => _ZefyrSelectionOverlayState();
 }
 
 class _ZefyrSelectionOverlayState extends State<ZefyrSelectionOverlay>
 
   @override
   Widget build(BuildContext context) {
-    final overlay = new GestureDetector(
+    final overlay = GestureDetector(
       behavior: HitTestBehavior.translucent,
       onTapDown: _handleTapDown,
       onTap: _handleTap,
       onTapCancel: _handleTapCancel,
       onLongPress: _handleLongPress,
-      child: new Stack(
+      child: Stack(
         fit: StackFit.expand,
         children: <Widget>[
-          new SelectionHandleDriver(
+          SelectionHandleDriver(
             position: _SelectionHandlePosition.base,
             selectionOverlay: this,
           ),
-          new SelectionHandleDriver(
+          SelectionHandleDriver(
             position: _SelectionHandlePosition.extent,
             selectionOverlay: this,
           ),
         ],
       ),
     );
-    return new Container(child: overlay);
+    return Container(child: overlay);
   }
 
   //
     assert(_lastTapDownPosition != null);
     final globalPoint = _lastTapDownPosition;
     _lastTapDownPosition = null;
-    HitTestResult result = new HitTestResult();
+    HitTestResult result = HitTestResult();
     WidgetsBinding.instance.hitTest(result, globalPoint);
 
     RenderEditableProxyBox box = _getEditableBox(result);
 
     final localPoint = box.globalToLocal(globalPoint);
     final position = box.getPositionForOffset(localPoint);
-    final selection = new TextSelection.collapsed(
+    final selection = TextSelection.collapsed(
       offset: position.offset,
       affinity: position.affinity,
     );
   void _handleLongPress() {
     final Offset globalPoint = _longPressPosition;
     _longPressPosition = null;
-    HitTestResult result = new HitTestResult();
+    HitTestResult result = HitTestResult();
     WidgetsBinding.instance.hitTest(result, globalPoint);
     final box = _getEditableBox(result);
     if (box == null) {
     final localPoint = box.globalToLocal(globalPoint);
     final position = box.getPositionForOffset(localPoint);
     final word = box.getWordBoundary(position);
-    final selection = new TextSelection(
+    final selection = TextSelection(
       baseOffset: word.start,
       extentOffset: word.end,
     );
   final _ZefyrSelectionOverlayState selectionOverlay;
 
   @override
-  _SelectionHandleDriverState createState() =>
-      new _SelectionHandleDriverState();
+  _SelectionHandleDriverState createState() => _SelectionHandleDriverState();
 }
 
 class _SelectionHandleDriverState extends State<SelectionHandleDriver>
   @override
   Widget build(BuildContext context) {
     if (widget.selectionOverlay.shouldHideControls) {
-      return new Container();
+      return Container();
     }
     final block = _scope.renderContext.boxForTextOffset(documentOffset);
     if (block == null) {
   final _ZefyrSelectionOverlayState selectionOverlay;
 
   @override
-  _SelectionToolbarState createState() => new _SelectionToolbarState();
+  _SelectionToolbarState createState() => _SelectionToolbarState();
 }
 
 class _SelectionToolbarState extends State<_SelectionToolbar> {
     }
     final boxes = block.getEndpointsForSelection(selection);
     // Find the horizontal midpoint, just above the selected text.
-    Offset midpoint = new Offset(
+    Offset midpoint = Offset(
       (boxes.length == 1)
           ? (boxes[0].start + boxes[0].end) / 2.0
           : (boxes[0].start + boxes[1].start) / 2.0,
       ];
     }
 
-    final Rect editingRegion = new Rect.fromPoints(
+    final Rect editingRegion = Rect.fromPoints(
       block.localToGlobal(Offset.zero),
       block.localToGlobal(block.size.bottomRight(Offset.zero)),
     );
         midpoint,
         endpoints,
         widget.selectionOverlay);
-    return new CompositedTransformFollower(
+    return CompositedTransformFollower(
       link: block.layerLink,
       showWhenUnlinked: false,
       offset: -editingRegion.topLeft,

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

     } else if (autoImplyTrailing) {
       children.add(toolbar.buildButton(context, ZefyrToolbarAction.close));
     }
-    return new Container(
+    return Container(
       constraints: constraints,
       child: Material(color: theme.color, child: Row(children: children)),
     );
   ZefyrToolbarState createState() => ZefyrToolbarState();
 
   @override
-  ui.Size get preferredSize => new Size.fromHeight(ZefyrToolbar.kToolbarHeight);
+  ui.Size get preferredSize => Size.fromHeight(ZefyrToolbar.kToolbarHeight);
 }
 
 class _ZefyrToolbarScope extends InheritedWidget {
 
   Future<void> showOverlay(WidgetBuilder builder) async {
     assert(_overlayBuilder == null);
-    final completer = new Completer<void>();
+    final completer = Completer<void>();
     setState(() {
       _overlayBuilder = builder;
       _overlayCompleter = completer;
   @override
   void initState() {
     super.initState();
-    _delegate = widget.delegate ?? new _DefaultZefyrToolbarDelegate();
-    _overlayAnimation = new AnimationController(
-        vsync: this, duration: Duration(milliseconds: 100));
+    _delegate = widget.delegate ?? _DefaultZefyrToolbarDelegate();
+    _overlayAnimation =
+        AnimationController(vsync: this, duration: Duration(milliseconds: 100));
     _selection = editor.selection;
   }
 
   void didUpdateWidget(ZefyrToolbar oldWidget) {
     super.didUpdateWidget(oldWidget);
     if (widget.delegate != oldWidget.delegate) {
-      _delegate = widget.delegate ?? new _DefaultZefyrToolbarDelegate();
+      _delegate = widget.delegate ?? _DefaultZefyrToolbarDelegate();
     }
   }
 
     layers.add(toolbar);
 
     if (hasOverlay) {
-      Widget widget = new Builder(builder: _overlayBuilder);
+      Widget widget = Builder(builder: _overlayBuilder);
       assert(widget != null);
       final overlay = FadeTransition(
         key: _overlayKey,
 }
 
 class _ZefyrButtonListState extends State<ZefyrButtonList> {
-  final ScrollController _controller = new ScrollController();
+  final ScrollController _controller = ScrollController();
   bool _showLeftArrow = false;
   bool _showRightArrow = false;
 

packages/zefyr/lib/util.dart

 export 'src/fast_diff.dart';
 
 int getPositionDelta(Delta user, Delta actual) {
-  final userIter = new DeltaIterator(user);
-  final actualIter = new DeltaIterator(actual);
+  final userIter = DeltaIterator(user);
+  final actualIter = DeltaIterator(actual);
   int diff = 0;
   while (userIter.hasNext || actualIter.hasNext) {
     num length = math.min(userIter.peekLength(), actualIter.peekLength());
     } else if (userOp.isDelete && actualOp.isRetain) {
       diff += userOp.length;
     } else if (userOp.isRetain && actualOp.isInsert) {
-      if (actualOp.data.startsWith('\n') ) {
+      if (actualOp.data.startsWith('\n')) {
         // At this point user input reached its end (retain). If a heuristic
         // rule inserts a new line we should keep cursor on it's original position.
         continue;