Upgraded to Flutter 1.12; fixed analyzer issues

.gitignore

 .DS_Store
 .idea/
+.dart_tool/

packages/notus/lib/src/convert/markdown.dart

 
 import 'dart:convert';
 
-import 'package:quill_delta/quill_delta.dart';
 import 'package:notus/notus.dart';
+import 'package:quill_delta/quill_delta.dart';
 
 class NotusMarkdownCodec extends Codec<Delta, String> {
   const NotusMarkdownCodec();
     final buffer = StringBuffer();
     final lineBuffer = StringBuffer();
     NotusAttribute<String> currentBlockStyle;
-    NotusStyle currentInlineStyle = NotusStyle();
-    List<String> currentBlockLines = [];
+    var currentInlineStyle = NotusStyle();
+    var currentBlockLines = [];
 
     void _handleBlock(NotusAttribute<String> blockStyle) {
       if (currentBlockLines.isEmpty) {
       if (lf == -1) {
         _handleSpan(op.data, op.attributes);
       } else {
-        StringBuffer span = StringBuffer();
+        var span = StringBuffer();
         for (var i = 0; i < op.data.length; i++) {
           if (op.data.codeUnitAt(i) == 0x0A) {
             if (span.isNotEmpty) {
   }
 
   String _writeLine(String text, NotusStyle style) {
-    StringBuffer buffer = StringBuffer();
+    var buffer = StringBuffer();
     if (style.contains(NotusAttribute.heading)) {
       _writeAttribute(buffer, style.get<int>(NotusAttribute.heading));
     }
   }
 
   String _trimRight(StringBuffer buffer) {
-    String text = buffer.toString();
+    var text = buffer.toString();
     if (!text.endsWith(' ')) return '';
     final result = text.trimRight();
     buffer.clear();

packages/notus/lib/src/document.dart

   Delta replace(int index, int length, String text) {
     assert(index >= 0 && (text.isNotEmpty || length > 0),
         'With index $index, length $length and text "$text"');
-    Delta delta = Delta();
+    var delta = Delta();
     // We have to compose before applying delete rules
     // Otherwise delete would be operating on stale document snapshot.
     if (text.isNotEmpty) {
   Delta format(int index, int length, NotusAttribute attribute) {
     assert(index >= 0 && length >= 0 && attribute != null);
 
-    Delta change = Delta();
+    var change = Delta();
 
     if (attribute is EmbedAttribute && length > 0) {
       // Must delete selected length of text before applying embed attribute
     change.trim();
     assert(change.isNotEmpty);
 
-    int offset = 0;
+    var offset = 0;
     final before = toDelta();
-    for (final Operation op in change.toList()) {
+    for (final op in change.toList()) {
       final attributes =
           op.attributes != null ? NotusStyle.fromJson(op.attributes) : null;
       if (op.isInsert) {
   void _loadDocument(Delta doc) {
     assert(doc.last.data.endsWith('\n'),
         'Invalid document delta. Document delta must always end with a line-break.');
-    int offset = 0;
-    for (final Operation op in doc.toList()) {
+    var offset = 0;
+    for (final op in doc.toList()) {
       final style =
           op.attributes != null ? NotusStyle.fromJson(op.attributes) : null;
       if (op.isInsert) {
         _root.insert(offset, op.data, style);
       } else {
         throw ArgumentError.value(doc,
-            "Document Delta can only contain insert operations but ${op.key} found.");
+            'Document Delta can only contain insert operations but ${op.key} found.');
       }
       offset += op.length;
     }
     // Must remove last line if it's empty and with no styles.
     // TODO: find a way for DocumentRoot to not create extra line when composing initial delta.
-    Node node = _root.last;
+    final node = _root.last;
     if (node is LineNode &&
         node.parent is! BlockNode &&
         node.style.isEmpty &&

packages/notus/lib/src/document/attributes.dart

 abstract class NotusAttributeBuilder<T> implements NotusAttributeKey<T> {
   const NotusAttributeBuilder._(this.key, this.scope);
 
+  @override
   final String key;
   final NotusAttributeScope scope;
   NotusAttribute<T> get unset => NotusAttribute<T>._(key, scope, null);
   const NotusAttribute._(this.key, this.scope, this.value);
 
   /// Unique key of this attribute.
+  @override
   final String key;
 
   /// Scope of this attribute.
+  @override
   final NotusAttributeScope scope;
 
   /// Value of this attribute.
   ///
   /// When composed into a rich text document, unset attributes remove
   /// associated style.
+  @override
   NotusAttribute<T> get unset => NotusAttribute<T>._(key, scope, null);
 
   /// Returns `true` if this attribute is an unset attribute.
   /// Returns `true` if this is an inline-scoped attribute.
   bool get isInline => scope == NotusAttributeScope.inline;
 
+  @override
   NotusAttribute<T> withValue(T value) =>
       NotusAttribute<T>._(key, scope, value);
 
     return NotusStyle._(result);
   }
 
-  NotusStyle() : _data = Map<String, NotusAttribute>();
+  NotusStyle() : _data = <String, NotusAttribute>{};
 
   /// Returns `true` if this attribute set is empty.
   bool get isEmpty => _data.isEmpty;
   @override
   NotusAttribute<Map<String, dynamic>> get unset => EmbedAttribute._(null);
 
+  @override
   NotusAttribute<Map<String, dynamic>> withValue(Map<String, dynamic> value) =>
       EmbedAttribute._(value);
 }

packages/notus/lib/src/document/block.dart

       insertAfter(line);
     } else {
       /// need to split this block into two as [line] is in the middle.
-      BlockNode before = clone();
+      final before = clone();
       insertBefore(before);
 
-      LineNode child = this.first;
+      LineNode child = first;
       while (child != line) {
         child.unlink();
         before.add(child);
-        child = this.first as LineNode;
+        child = first as LineNode;
       }
       line.unlink();
       insertBefore(line);
   @override
   void optimize() {
     if (isEmpty) {
-      Node sibling = this.previous;
+      final sibling = previous;
       unlink();
       if (sibling != null) sibling.optimize();
       return;

packages/notus/lib/src/document/leaf.dart

     if (index == length && isLast) return null;
     if (index == length && !isLast) return next as LeafNode;
 
-    String text = _value;
+    final text = _value;
     _value = text.substring(0, index);
     final split = LeafNode(text.substring(index));
     split.applyStyle(style);
   /// method may return `null`.
   LeafNode cutAt(int index) {
     assert(index >= 0 && index <= length);
-    LeafNode cut = splitAt(index);
+    final cut = splitAt(index);
     cut?.unlink();
     return cut;
   }
         'Actual node length: ${this.length}.');
     // Since `index < this.length` (guarded by assert) below line
     // always returns a new node.
-    LeafNode target = splitAt(index);
+    final target = splitAt(index);
     target.splitAt(length);
     return target;
   }
   @override
   void applyStyle(NotusStyle value) {
     assert(value != null && (value.isInline || value.isEmpty),
-        "Style cannot be applied to this leaf node: $value");
+        'Style cannot be applied to this leaf node: $value');
     assert(() {
       if (value.contains(NotusAttribute.embed)) {
         if (value.get(NotusAttribute.embed) == NotusAttribute.embed.unset) {
     final local = math.min(this.length - index, length);
     final node = isolate(index, local);
 
-    int remaining = length - local;
+    final remaining = length - local;
     if (remaining > 0) {
       assert(node.next != null);
       node.next.retain(0, remaining, style);
     final actualNext = target.next;
     target.unlink();
 
-    int remaining = length - local;
+    final remaining = length - local;
     if (remaining > 0) {
       assert(actualNext != null);
       actualNext.delete(0, remaining);
   @override
   String toString() {
     final keys = style.keys.toList(growable: false)..sort();
-    String styleKeys = keys.join();
-    return "⟨$value⟩$styleKeys";
+    final styleKeys = keys.join();
+    return '⟨$value⟩$styleKeys';
   }
 
   /// Optimizes this text node by merging it with adjacent nodes if they share
   /// the same style.
   @override
   void optimize() {
-    LeafNode node = this;
+    var node = this;
     if (!node.isFirst) {
       LeafNode mergeWith = node.previous;
       if (mergeWith.style == node.style) {

packages/notus/lib/src/document/line.dart

   /// This is an equivalent of inserting a line-break character at [index].
   LineNode splitAt(int index) {
     assert(index == 0 || (index > 0 && index < length),
-        'Index is out of bounds. Index: $index. Actual node length: ${this.length}.');
+        'Index is out of bounds. Index: $index. Actual node length: ${length}.');
 
-    LineNode line = clone();
+    final line = clone();
     insertAfter(line);
     if (index == length - 1) return line;
 
     final split = lookup(index);
     while (!split.node.isLast) {
-      LeafNode child = this.last;
+      LeafNode child = last;
       child.unlink();
       line.addFirst(child);
     }
   /// - inline attribute X is included in the result only if it exists
   ///   for every character within this range (line-break characters excluded).
   NotusStyle collectStyle(int offset, int length) {
-    int local = math.min(this.length - offset, length);
+    final local = math.min(this.length - offset, length);
 
-    NotusStyle result = NotusStyle();
-    Set<NotusAttribute> excluded = Set();
+    var result = NotusStyle();
+    final excluded = <NotusAttribute>{};
 
     void _handle(NotusStyle style) {
       if (result.isEmpty) {
     LeafNode node = data.node;
     if (node != null) {
       result = result.mergeAll(node.style);
-      int pos = node.length - data.offset;
+      var pos = node.length - data.offset;
       while (!node.isLast && pos < local) {
         node = node.next as LeafNode;
         _handle(node.style);
       }
     }
 
-    result = result.mergeAll(this.style);
+    result = result.mergeAll(style);
     if (parent is BlockNode) {
       BlockNode block = parent;
       result = result.mergeAll(block.style);
     }
 
-    int remaining = length - local;
+    final remaining = length - local;
     if (remaining > 0) {
       final rest = nextLine.collectStyle(0, remaining);
       _handle(rest);
 
   @override
   Delta toDelta() {
-    final Delta delta = children
+    final delta = children
         .map((text) => text.toDelta())
         .fold(Delta(), (a, b) => a.concat(b));
     var attributes = style;
   @override
   void retain(int index, int length, NotusStyle style) {
     if (style == null) return;
-    int thisLength = this.length;
+    final thisLength = this.length;
 
     final local = math.min(thisLength - index, length);
     // If index is at line-break character this is line/block format update.
-    bool isLineFormat = (index + local == thisLength) && local == 1;
+    final isLineFormat = (index + local == thisLength) && local == 1;
 
     if (isLineFormat) {
       assert(
       super.retain(index, local, style);
     }
 
-    int remaining = length - local;
+    final remaining = length - local;
     if (remaining > 0) {
       assert(nextLine != null);
       nextLine.retain(0, remaining, style);
   @override
   void delete(int index, int length) {
     final local = math.min(this.length - index, length);
-    bool isLFDeleted = (index + local == this.length);
+    final isLFDeleted = (index + local == this.length);
     if (isLFDeleted) {
       // Our line-break deleted with all style information.
       clearStyle();
       super.delete(index, local);
     }
 
-    int remaining = length - local;
+    final remaining = length - local;
     if (remaining > 0) {
       assert(nextLine != null);
       nextLine.delete(0, remaining);
         unwrap();
       } else if (blockStyle != parentStyle) {
         unwrap();
-        BlockNode block = BlockNode();
+        final block = BlockNode();
         block.applyAttribute(blockStyle);
         wrap(block);
         block.optimize();
       } // else the same style, no-op.
     } else if (blockStyle != NotusAttribute.block.unset) {
       // Only wrap with a new block if this is not an unset
-      BlockNode block = BlockNode();
+      final block = BlockNode();
       block.applyAttribute(blockStyle);
       wrap(block);
       block.optimize();
       add(child);
       child.formatAndOptimize(style);
     } else {
-      final LookupResult result = lookup(index, inclusive: true);
+      final result = lookup(index, inclusive: true);
       result.node.insert(result.offset, text, style);
     }
   }

packages/notus/lib/src/document/node.dart

   /// To get offset of this node in the document see [documentOffset].
   int get offset {
     if (isFirst) return 0;
-    int offset = 0;
-    Node node = this;
+    var offset = 0;
+    var node = this;
     do {
       node = node.previous;
       offset += node.length;
 
   /// Offset in characters of this node in the document.
   int get documentOffset {
-    int parentOffset = (_parent is! RootNode) ? _parent.documentOffset : 0;
-    return parentOffset + this.offset;
+    final parentOffset = (_parent is! RootNode) ? _parent.documentOffset : 0;
+    return parentOffset + offset;
   }
 
   /// Returns `true` if this node contains character at specified [offset] in
   /// the document.
   bool containsOffset(int offset) {
-    int o = documentOffset;
+    final o = documentOffset;
     return o <= offset && offset < o + length;
   }
 
   /// which points at the same character position in the document as the
   /// original [offset].
   LookupResult lookup(int offset, {bool inclusive = false}) {
-    assert(offset >= 0 && offset <= this.length);
+    assert(offset >= 0 && offset <= length);
 
-    for (Node node in children) {
-      final int length = node.length;
+    for (final node in children) {
+      final length = node.length;
       if (offset < length || (inclusive && offset == length && (node.isLast))) {
         return LookupResult(node, offset);
       }
 
     if (isEmpty) {
       assert(index == 0);
-      T node = defaultChild;
+      final node = defaultChild;
       add(node);
       node.insert(index, value, style);
     } else {
-      LookupResult result = lookup(index);
+      final result = lookup(index);
       result.node.insert(result.offset, value, style);
     }
   }

packages/notus/lib/src/heuristics/delete_rules.dart

 // 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.
 
-import 'package:quill_delta/quill_delta.dart';
 import 'package:notus/notus.dart';
+import 'package:quill_delta/quill_delta.dart';
 
 /// A heuristic rule for delete operations.
 abstract class DeleteRule {
 
   @override
   Delta apply(Delta document, int index, int length) {
-    DeltaIterator iter = DeltaIterator(document);
+    final iter = DeltaIterator(document);
     iter.skip(index);
     final target = iter.next(1);
     if (target.data != '\n') return null;
     iter.skip(length - 1);
-    final Delta result = Delta()
+    final result = Delta()
       ..retain(index)
       ..delete(length);
 
     // Look for next line-break to apply the attributes
     while (iter.hasNext) {
       final op = iter.next();
-      int lf = op.data.indexOf('\n');
+      final lf = op.data.indexOf('\n');
       if (lf == -1) {
         result..retain(op.length);
         continue;
 
   @override
   Delta apply(Delta document, int index, int length) {
-    DeltaIterator iter = DeltaIterator(document);
+    final iter = DeltaIterator(document);
 
     // First, check if line-break deleted after an embed.
-    Operation op = iter.skip(index);
-    int indexDelta = 0;
-    int lengthDelta = 0;
-    int remaining = length;
-    bool foundEmbed = false;
-    bool hasLineBreakBefore = false;
+    var op = iter.skip(index);
+    var indexDelta = 0;
+    var lengthDelta = 0;
+    var remaining = length;
+    var foundEmbed = false;
+    var hasLineBreakBefore = false;
     if (op != null && op.data.endsWith(kZeroWidthSpace)) {
       foundEmbed = true;
-      Operation candidate = iter.next(1);
+      var candidate = iter.next(1);
       remaining--;
       if (candidate.data == '\n') {
         indexDelta += 1;

packages/notus/lib/src/heuristics/format_rules.dart

 // 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.
 
-import 'package:quill_delta/quill_delta.dart';
 import 'package:notus/notus.dart';
+import 'package:quill_delta/quill_delta.dart';
 
 /// A heuristic rule for format (retain) operations.
 abstract class FormatRule {
   Delta apply(Delta document, int index, int length, NotusAttribute attribute) {
     if (attribute.scope != NotusAttributeScope.line) return null;
 
-    Delta result = Delta()..retain(index);
+    var result = Delta()..retain(index);
     final iter = DeltaIterator(document);
     iter.skip(index);
 
     // Apply line styles to all line-break characters within range of this
     // retain operation.
-    int current = 0;
+    var current = 0;
     while (current < length && iter.hasNext) {
       final op = iter.next(length - current);
       if (op.data.contains('\n')) {
     // And include extra line-break after retain
     while (iter.hasNext) {
       final op = iter.next();
-      int lf = op.data.indexOf('\n');
+      final lf = op.data.indexOf('\n');
       if (lf == -1) {
         result..retain(op.length);
         continue;
 
   Delta _applyAttribute(String text, NotusAttribute attribute) {
     final result = Delta();
-    int offset = 0;
-    int lf = text.indexOf('\n');
+    var offset = 0;
+    var lf = text.indexOf('\n');
     while (lf >= 0) {
       result..retain(lf - offset)..retain(1, attribute.toJson());
       offset = lf + 1;
   Delta apply(Delta document, int index, int length, NotusAttribute attribute) {
     if (attribute.scope != NotusAttributeScope.inline) return null;
 
-    Delta result = Delta()..retain(index);
+    final result = Delta()..retain(index);
     final iter = DeltaIterator(document);
     iter.skip(index);
 
     // Apply inline styles to all non-line-break characters within range of this
     // retain operation.
-    int current = 0;
+    var current = 0;
     while (current < length && iter.hasNext) {
       final op = iter.next(length - current);
-      int lf = op.data.indexOf('\n');
+      var lf = op.data.indexOf('\n');
       if (lf != -1) {
-        int pos = 0;
+        var pos = 0;
         while (lf != -1) {
           result..retain(lf - pos, attribute.toJson())..retain(1);
           pos = lf + 1;
     // edge cases.
     if (length != 0) return null;
 
-    Delta result = Delta();
+    final result = Delta();
     final iter = DeltaIterator(document);
     final before = iter.skip(index);
     final after = iter.next();
-    int startIndex = index;
-    int retain = 0;
+    var startIndex = index;
+    var retain = 0;
     if (before != null && before.hasAttribute(attribute.key)) {
       startIndex -= before.length;
       retain = before.length;
 
   Delta _insertEmbed(
       Delta document, int index, int length, EmbedAttribute embed) {
-    Delta result = Delta()..retain(index);
+    final result = Delta()..retain(index);
     final iter = DeltaIterator(document);
     final previous = iter.skip(index);
     iter.skip(length); // ignore deleted part.
     Map<String, dynamic> attributes;
     while (iterator.hasNext) {
       final op = iterator.next();
-      int lf = op.data.indexOf('\n');
+      final lf = op.data.indexOf('\n');
       if (lf >= 0) {
         attributes = op.attributes;
         break;

packages/notus/lib/src/heuristics/insert_rules.dart

 // 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.
 
-import 'package:quill_delta/quill_delta.dart';
 import 'package:notus/notus.dart';
+import 'package:quill_delta/quill_delta.dart';
 
 /// A heuristic rule for insert operations.
 abstract class InsertRule {
   Delta apply(Delta document, int index, String text) {
     if (text != '\n') return null;
 
-    DeltaIterator iter = DeltaIterator(document);
+    final iter = DeltaIterator(document);
     final before = iter.skip(index);
     final after = iter.next();
     if (isEdgeLineSplit(before, after)) return null;
-    Delta result = Delta()..retain(index);
+    final result = Delta()..retain(index);
     if (after.data.contains('\n')) {
       // It is not allowed to combine line and inline styles in insert
       // operation containing line-break together with other characters.
     Map<String, dynamic> attributes;
     while (iter.hasNext) {
       final op = iter.next();
-      int lf = op.data.indexOf('\n');
+      final lf = op.data.indexOf('\n');
       if (lf >= 0) {
         attributes = op.attributes;
         break;
   Delta apply(Delta document, int index, String text) {
     if (text != '\n') return null;
 
-    DeltaIterator iter = DeltaIterator(document);
+    final iter = DeltaIterator(document);
     iter.skip(index);
     final target = iter.next();
 
   Delta apply(Delta document, int index, String text) {
     if (text != '\n') return null;
 
-    DeltaIterator iter = DeltaIterator(document);
+    final iter = DeltaIterator(document);
     final previous = iter.skip(index);
     final target = iter.next();
     final isInBlock = target.isNotPlain &&
       // We reset block style even if this line is not the last one in it's
       // block which effectively splits the block into two.
       // TODO: For code blocks this should not split the block but allow inserting as many lines as needed.
-      var attributes =
-          target.attributes != null ? target.attributes : <String, dynamic>{};
+      var attributes;
+      if (target.attributes != null) {
+        attributes = target.attributes;
+      } else {
+        attributes = <String, dynamic>{};
+      }
       attributes.addAll(NotusAttribute.block.unset.toJson());
       return Delta()..retain(index)..retain(1, attributes);
     }
     // This rule is only applicable to characters other than line-break.
     if (text.contains('\n')) return null;
 
-    DeltaIterator iter = DeltaIterator(document);
+    final iter = DeltaIterator(document);
     final previous = iter.skip(index);
     // If there is a line-break in previous chunk, there should be no inline
     // styles. Also if there is no previous operation we are at the beginning
     // everything else.
     if (text != ' ') return null;
 
-    DeltaIterator iter = DeltaIterator(document);
+    final iter = DeltaIterator(document);
     final previous = iter.skip(index);
     // No previous operation means no link.
     if (previous == null) return null;
 
   @override
   Delta apply(Delta document, int index, String text) {
-    DeltaIterator iter = DeltaIterator(document);
+    final iter = DeltaIterator(document);
     final previous = iter.skip(index);
     final target = iter.next();
     final beforeEmbed = target.data == EmbedNode.kPlainTextPlaceholder;
       return null;
     }
 
-    DeltaIterator iter = DeltaIterator(document);
+    final iter = DeltaIterator(document);
     iter.skip(index);
 
     // Look for next line-break.
     Map<String, dynamic> lineStyle;
     while (iter.hasNext) {
       final op = iter.next();
-      int lf = op.data.indexOf('\n');
+      final lf = op.data.indexOf('\n');
       if (lf >= 0) {
         lineStyle = op.attributes;
         break;
     }
 
     final lines = text.split('\n');
-    Delta result = Delta()..retain(index);
-    for (int i = 0; i < lines.length; i++) {
+    final result = Delta()..retain(index);
+    for (var i = 0; i < lines.length; i++) {
       final line = lines[i];
       if (line.isNotEmpty) {
         result.insert(line);

packages/notus/pubspec.yaml

 homepage: https://github.com/memspace/zefyr
 
 environment:
-  sdk: '>=2.0.0 <3.0.0'
+  sdk: '>=2.2.0 <3.0.0'
 
 dependencies:
   collection: ^1.14.6
 
 dev_dependencies:
   pedantic: ^1.0.0
-  test: ^1.0.0
-  test_coverage: ^0.2.1
+  test: ^1.10.0
+  test_coverage: ^0.4.0

packages/notus/test/convert/markdown_test.dart

 // BSD-style license that can be found in the LICENSE file.
 import 'dart:convert';
 
-import 'package:test/test.dart';
-import 'package:quill_delta/quill_delta.dart';
-import 'package:notus/notus.dart';
 import 'package:notus/convert.dart';
+import 'package:notus/notus.dart';
+import 'package:quill_delta/quill_delta.dart';
+import 'package:test/test.dart';
 
 void main() {
   group('$NotusMarkdownCodec.encode', () {
     });
 
     test('bold italic', () {
-      runFor(NotusAttribute<bool> attribute, String expected) {
+      void runFor(NotusAttribute<bool> attribute, String expected) {
         final delta = Delta()
           ..insert('This ')
           ..insert('house', attribute.toJson())
     });
 
     test('heading styles', () {
-      runFor(NotusAttribute<int> attribute, String source, String expected) {
+      void runFor(
+          NotusAttribute<int> attribute, String source, String expected) {
         final delta = Delta()..insert(source)..insert('\n', attribute.toJson());
         final result = notusMarkdown.encode(delta);
         expect(result, expected);
     });
 
     test('block styles', () {
-      runFor(NotusAttribute<String> attribute, String source, String expected) {
+      void runFor(
+          NotusAttribute<String> attribute, String source, String expected) {
         final delta = Delta()..insert(source)..insert('\n', attribute.toJson());
         final result = notusMarkdown.encode(delta);
         expect(result, expected);
     });
 
     test('multiline blocks', () {
-      runFor(NotusAttribute<String> attribute, String source, String expected) {
+      void runFor(
+          NotusAttribute<String> attribute, String source, String expected) {
         final delta = Delta()
           ..insert(source)
           ..insert('\n', attribute.toJson())

packages/notus/test/document/block_test.dart

 // 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.
 import 'package:notus/notus.dart';
-import 'package:test/test.dart';
 import 'package:quill_delta/quill_delta.dart';
+import 'package:test/test.dart';
 
 final ulAttrs = NotusStyle().merge(NotusAttribute.ul);
 final olAttrs = NotusStyle().merge(NotusAttribute.ol);
     });
 
     test('empty', () {
-      BlockNode node = BlockNode();
+      final node = BlockNode();
       expect(node, isEmpty);
       expect(node.length, 0);
       expect(node.style, NotusStyle());
     });
 
     test('toString', () {
-      LineNode line = LineNode();
+      final line = LineNode();
       line.add(TextNode('London "Grammar"'));
-      BlockNode block = BlockNode();
+      final block = BlockNode();
       block.applyAttribute(NotusAttribute.ul);
       block.add(line);
       final expected = '§ {ul}\n  └ ¶ ⟨London "Grammar"⟩ ⏎';
       expect(block.first, const TypeMatcher<LineNode>());
 
       LineNode line = block.first;
-      Delta delta = Delta()
+      final delta = Delta()
         ..insert('Hello world')
         ..insert('\n', ulAttrs.toJson());
       expect(line.toDelta(), delta);

packages/notus/test/document/line_test.dart

 // Copyright (c) 2018, the Zefyr 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.
-import 'package:test/test.dart';
-import 'package:quill_delta/quill_delta.dart';
 import 'package:notus/notus.dart';
+import 'package:quill_delta/quill_delta.dart';
+import 'package:test/test.dart';
 
 final boldStyle = NotusStyle().merge(NotusAttribute.bold);
 final h1Style = NotusStyle().merge(NotusAttribute.h1);
     });
 
     test('empty', () {
-      LineNode node = LineNode();
+      final node = LineNode();
       expect(node, isEmpty);
       expect(node.length, 1);
       expect(node.style, NotusStyle());
     });
 
     test('hasEmbed', () {
-      LineNode node = LineNode();
+      final node = LineNode();
       expect(node.hasEmbed, isFalse);
       node.add(EmbedNode());
       expect(node.hasEmbed, isTrue);
     });
 
     test('toString', () {
-      LineNode node = LineNode();
+      final node = LineNode();
       node.insert(0, 'London "Grammar" - Hey Now', null);
       node.retain(0, 16, boldStyle);
       node.applyAttribute(NotusAttribute.h1);
     });
 
     test('insert into empty line', () {
-      LineNode node = LineNode();
+      final node = LineNode();
       node.insert(0, 'London "Grammar" - Hey Now', null);
       expect(node, hasLength(27));
       expect(node.toDelta(), Delta()..insert('London "Grammar" - Hey Now\n'));
     });
 
     test('insert into empty line with styles', () {
-      LineNode node = LineNode();
+      final node = LineNode();
       node.insert(0, 'London "Grammar" - Hey Now', null);
       node.retain(0, 16, boldStyle);
       node.applyAttribute(NotusAttribute.h1);
     });
 
     test('insert into non-empty line', () {
-      LineNode node = LineNode();
+      final node = LineNode();
       node.insert(0, 'Hello world', null);
       node.insert(11, '!!!', null);
       expect(node, hasLength(15));
 
       LineNode line = root.first;
       expect(line, hasLength(15));
-      Delta delta = Delta()
+      final delta = Delta()
         ..insert('Hello ')
         ..insert('world', boldStyle.toJson())
         ..insert('!!!\n');
       LineNode line = root.first;
       expect(line, hasLength(12));
 
-      Delta delta = Delta()
+      final delta = Delta()
         ..insert('Hello world')
         ..insert('\n', NotusAttribute.h1.toJson());
       expect(line.toDelta(), delta);
       LineNode line = root.first;
       expect(line, hasLength(8));
       expect(line.childCount, 1);
-      Delta lineDelta = Delta()..insert('Hellord\n');
+      final lineDelta = Delta()..insert('Hellord\n');
       expect(line.toDelta(), lineDelta);
     });
 
       expect(root.childCount, 1);
       LineNode line = root.first;
       expect(line, hasLength(18));
-      Delta lineDelta = Delta()
+      final lineDelta = Delta()
         ..insert('Hello ')
         ..insert('worl', boldStyle.toJson())
         ..insert(' cd ef!\n');
 
     test('collectStyle with embed nodes', () {
       root.insert(0, 'Hello world\n\nMore text.\n', null);
-      NotusStyle style = NotusStyle();
+      var style = NotusStyle();
       style = style.put(NotusAttribute.embed.horizontalRule);
       root.insert(12, EmbedNode.kPlainTextPlaceholder, style);
 

packages/notus/test/document/node_test.dart

 // Copyright (c) 2018, the Zefyr 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.
-import 'package:test/test.dart';
 import 'package:notus/notus.dart';
+import 'package:test/test.dart';
 
 void main() {
   group('$Node', () {
     });
 
     test('mounted', () {
-      LineNode line = LineNode();
-      TextNode text = TextNode();
+      final line = LineNode();
+      final text = TextNode();
       expect(text.mounted, isFalse);
       line.add(text);
       expect(text.mounted, isTrue);

packages/notus/test/document_test.dart

 // BSD-style license that can be found in the LICENSE file.
 import 'dart:convert';
 
-import 'package:test/test.dart';
-import 'package:quill_delta/quill_delta.dart';
 import 'package:notus/notus.dart';
+import 'package:quill_delta/quill_delta.dart';
+import 'package:test/test.dart';
+
 import 'matchers.dart';
 
 NotusDocument dartconfDoc() {
-  Delta delta = Delta()..insert('DartConf\nLos Angeles\n');
+  final delta = Delta()..insert('DartConf\nLos Angeles\n');
   return NotusDocument.fromDelta(delta);
 }
 
 NotusDocument dartconfEmbedDoc() {
   final hr = NotusAttribute.embed.horizontalRule.toJson();
-  Delta delta = Delta()
+  final delta = Delta()
     ..insert('DartConf\n')
     ..insert(kZeroWidthSpace, hr)
     ..insert('\n')
     });
 
     test('empty document contains single empty line', () {
-      NotusDocument doc = NotusDocument();
+      final doc = NotusDocument();
       expect(doc.toPlainText(), '\n');
     });
 
     });
 
     test('toString', () {
-      NotusDocument doc = dartconfDoc();
+      final doc = dartconfDoc();
       expect(doc.toString(), doc.toString());
     });
 
     test('load non-empty document', () {
-      NotusDocument doc = dartconfDoc();
+      final doc = dartconfDoc();
       expect(doc.toPlainText(), 'DartConf\nLos Angeles\n');
     });
 
     test('document delta must end with line-break character', () {
-      Delta delta = Delta()..insert('DartConf\nLos Angeles');
+      final delta = Delta()..insert('DartConf\nLos Angeles');
       expect(() {
         NotusDocument.fromDelta(delta);
       }, throwsA(const TypeMatcher<AssertionError>()));
     });
 
     test('format applies heuristics', () {
-      NotusDocument doc = dartconfDoc();
+      final doc = dartconfDoc();
       doc.format(0, 15, NotusAttribute.ul);
       expect(doc.root.children, hasLength(1));
       expect(doc.root.children.first, const TypeMatcher<BlockNode>());
     });
 
     test('format ignores empty changes', () async {
-      NotusDocument doc = dartconfDoc();
+      final doc = dartconfDoc();
       var changeList = doc.changes.toList();
       var change = doc.format(1, 0, NotusAttribute.bold);
       doc.close();
     });
 
     test('format returns actual change delta', () {
-      NotusDocument doc = dartconfDoc();
+      final doc = dartconfDoc();
       final change = doc.format(0, 15, NotusAttribute.ul);
       final expectedChange = Delta()
         ..retain(8)
     });
 
     test('format updates document delta', () {
-      NotusDocument doc = dartconfDoc();
+      final doc = dartconfDoc();
       doc.format(0, 15, NotusAttribute.ul);
       final expectedDoc = Delta()
         ..insert('DartConf')
     });
 
     test('format allows zero-length updates', () {
-      NotusDocument doc = dartconfDoc();
+      final doc = dartconfDoc();
       doc.format(0, 0, NotusAttribute.ul);
       final expectedDoc = Delta()
         ..insert('DartConf')
     });
 
     test('insert applies heuristics', () {
-      NotusDocument doc = dartconfDoc();
+      final doc = dartconfDoc();
       doc.format(0, 15, NotusAttribute.ul);
       doc.insert(8, '\n');
       expect(doc.root.children, hasLength(1));
     });
 
     test('insert returns actual change delta', () {
-      NotusDocument doc = dartconfDoc();
+      final doc = dartconfDoc();
       doc.format(0, 15, NotusAttribute.ul);
       final change = doc.insert(8, '\n');
       final expectedChange = Delta()
     });
 
     test('insert updates document delta', () {
-      NotusDocument doc = dartconfDoc();
+      final doc = dartconfDoc();
       doc.format(0, 15, NotusAttribute.ul);
       doc.insert(8, '\n');
       final expectedDoc = Delta()
     });
 
     test('insert throws assert error if change is empty', () {
-      NotusDocument doc = dartconfDoc();
+      final doc = dartconfDoc();
       expect(() {
         doc.insert(8, '');
       }, throwsA(const TypeMatcher<AssertionError>()));
     });
 
     test('replace throws assert error if change is empty', () {
-      NotusDocument doc = dartconfDoc();
+      final doc = dartconfDoc();
       expect(() {
         doc.replace(8, 0, '');
       }, throwsA(const TypeMatcher<AssertionError>()));
     });
 
     test('compose throws assert error if change is empty', () {
-      NotusDocument doc = dartconfDoc();
+      final doc = dartconfDoc();
       expect(() {
         doc.compose(Delta()..retain(1), ChangeSource.local);
       }, throwsA(const TypeMatcher<AssertionError>()));
     });
 
     test('replace applies heuristic rules', () {
-      NotusDocument doc = dartconfDoc();
+      final doc = dartconfDoc();
       doc.format(0, 0, NotusAttribute.h1);
       doc.replace(8, 1, ' ');
       expect(doc.root.children, hasLength(1));
     });
 
     test('delete applies heuristic rules', () {
-      NotusDocument doc = dartconfDoc();
+      final doc = dartconfDoc();
       doc.format(0, 0, NotusAttribute.h1);
       doc.delete(8, 1);
       expect(doc.root.children, hasLength(1));
     test('delete which results in an empty change', () {
       // This test relies on a delete rule which ensures line-breaks around
       // and embed.
-      NotusDocument doc = dartconfEmbedDoc();
+      final doc = dartconfEmbedDoc();
       doc.delete(8, 1);
       expect(doc.toPlainText(), 'DartConf\n${kZeroWidthSpace}\nLos Angeles\n');
     });

packages/notus/test/heuristics_test.dart

 import 'package:test/test.dart';
 
 NotusDocument dartconfDoc() {
-  Delta delta = Delta()..insert('DartConf\nLos Angeles\n');
+  final delta = Delta()..insert('DartConf\nLos Angeles\n');
   return NotusDocument.fromDelta(delta);
 }
 

packages/zefyr/.gitignore

 coverage/
 ios/Flutter/Generated.xcconfig
 .flutter-plugins
+.flutter-plugins-dependencies
 example/ios/.symlinks
 example/ios/Flutter/Generated.xcconfig
 doc/api/

packages/zefyr/CHANGELOG.md

+## 0.9.0
+
+* Feature: toggle inline styles (works for bold and italic)
+* Updated to support Flutter 1.12.0
+* Upgraded dependencies
+* Fixed analyzer issues
+
 ## 0.8.0
 
 * Updated to support Flutter 1.9.0 (#154)

packages/zefyr/example/ios/Flutter/Flutter.podspec

+#
+# NOTE: This podspec is NOT to be published. It is only used as a local source!
+#
+
+Pod::Spec.new do |s|
+  s.name             = 'Flutter'
+  s.version          = '1.0.0'
+  s.summary          = 'High-performance, high-fidelity mobile apps.'
+  s.description      = <<-DESC
+Flutter provides an easy and productive way to build and deploy high-performance mobile apps for Android and iOS.
+                       DESC
+  s.homepage         = 'https://flutter.io'
+  s.license          = { :type => 'MIT' }
+  s.author           = { 'Flutter Dev Team' => 'flutter-dev@googlegroups.com' }
+  s.source           = { :git => 'https://github.com/flutter/engine', :tag => s.version.to_s }
+  s.ios.deployment_target = '8.0'
+  s.vendored_frameworks = 'Flutter.framework'
+end

packages/zefyr/example/ios/Podfile

 # CocoaPods analytics sends network stats synchronously affecting flutter build latency.
 ENV['COCOAPODS_DISABLE_STATS'] = 'true'
 
+project 'Runner', {
+  'Debug' => :debug,
+  'Profile' => :release,
+  'Release' => :release,
+}
+
 def parse_KV_file(file, separator='=')
   file_abs_path = File.expand_path(file)
   if !File.exists? file_abs_path
     return [];
   end
-  pods_ary = []
+  generated_key_values = {}
   skip_line_start_symbols = ["#", "/"]
-  File.foreach(file_abs_path) { |line|
-      next if skip_line_start_symbols.any? { |symbol| line =~ /^\s*#{symbol}/ }
-      plugin = line.split(pattern=separator)
-      if plugin.length == 2
-        podname = plugin[0].strip()
-        path = plugin[1].strip()
-        podpath = File.expand_path("#{path}", file_abs_path)
-        pods_ary.push({:name => podname, :path => podpath});
-      else
-        puts "Invalid plugin specification: #{line}"
-      end
-  }
-  return pods_ary
+  File.foreach(file_abs_path) do |line|
+    next if skip_line_start_symbols.any? { |symbol| line =~ /^\s*#{symbol}/ }
+    plugin = line.split(pattern=separator)
+    if plugin.length == 2
+      podname = plugin[0].strip()
+      path = plugin[1].strip()
+      podpath = File.expand_path("#{path}", file_abs_path)
+      generated_key_values[podname] = podpath
+    else
+      puts "Invalid plugin specification: #{line}"
+    end
+  end
+  generated_key_values
 end
 
 target 'Runner' do
-  # Prepare symlinks folder. We use symlinks to avoid having Podfile.lock
-  # referring to absolute paths on developers' machines.
-  system('rm -rf .symlinks')
-  system('mkdir -p .symlinks/plugins')
+  # Flutter Pod
 
-  # Flutter Pods
-  generated_xcode_build_settings = parse_KV_file('./Flutter/Generated.xcconfig')
-  if generated_xcode_build_settings.empty?
-    puts "Generated.xcconfig must exist. If you're running pod install manually, make sure flutter packages get is executed first."
-  end
-  generated_xcode_build_settings.map { |p|
-    if p[:name] == 'FLUTTER_FRAMEWORK_DIR'
-      symlink = File.join('.symlinks', 'flutter')
-      File.symlink(File.dirname(p[:path]), symlink)
-      pod 'Flutter', :path => File.join(symlink, File.basename(p[:path]))
+  copied_flutter_dir = File.join(__dir__, 'Flutter')
+  copied_framework_path = File.join(copied_flutter_dir, 'Flutter.framework')
+  copied_podspec_path = File.join(copied_flutter_dir, 'Flutter.podspec')
+  unless File.exist?(copied_framework_path) && File.exist?(copied_podspec_path)
+    # Copy Flutter.framework and Flutter.podspec to Flutter/ to have something to link against if the xcode backend script has not run yet.
+    # That script will copy the correct debug/profile/release version of the framework based on the currently selected Xcode configuration.
+    # CocoaPods will not embed the framework on pod install (before any build phases can generate) if the dylib does not exist.
+
+    generated_xcode_build_settings_path = File.join(copied_flutter_dir, 'Generated.xcconfig')
+    unless File.exist?(generated_xcode_build_settings_path)
+      raise "Generated.xcconfig must exist. If you're running pod install manually, make sure flutter pub get is executed first"
     end
-  }
+    generated_xcode_build_settings = parse_KV_file(generated_xcode_build_settings_path)
+    cached_framework_dir = generated_xcode_build_settings['FLUTTER_FRAMEWORK_DIR'];
+
+    unless File.exist?(copied_framework_path)
+      FileUtils.cp_r(File.join(cached_framework_dir, 'Flutter.framework'), copied_flutter_dir)
+    end
+    unless File.exist?(copied_podspec_path)
+      FileUtils.cp(File.join(cached_framework_dir, 'Flutter.podspec'), copied_flutter_dir)
+    end
+  end
+
+  # Keep pod path relative so it can be checked into Podfile.lock.
+  pod 'Flutter', :path => 'Flutter'
 
   # Plugin Pods
+
+  # Prepare symlinks folder. We use symlinks to avoid having Podfile.lock
+  # referring to absolute paths on developers' machines.
+  system('rm -rf .symlinks')
+  system('mkdir -p .symlinks/plugins')
   plugin_pods = parse_KV_file('../.flutter-plugins')
-  plugin_pods.map { |p|
-    symlink = File.join('.symlinks', 'plugins', p[:name])
-    File.symlink(p[:path], symlink)
-    pod p[:name], :path => File.join(symlink, 'ios')
-  }
+  plugin_pods.each do |name, path|
+    symlink = File.join('.symlinks', 'plugins', name)
+    File.symlink(path, symlink)
+    pod name, :path => File.join(symlink, 'ios')
+  end
 end
 
+# Prevent Cocoapods from embedding a second Flutter framework and causing an error with the new Xcode build system.
+install! 'cocoapods', :disable_input_output_paths => true
+
 post_install do |installer|
   installer.pods_project.targets.each do |target|
     target.build_configurations.each do |config|

packages/zefyr/example/ios/Podfile.lock

 PODS:
   - Flutter (1.0.0)
+  - flutter_plugin_android_lifecycle (0.0.1):
+    - Flutter
   - image_picker (0.0.1):
     - Flutter
   - url_launcher (0.0.1):
     - Flutter
+  - url_launcher_macos (0.0.1):
+    - Flutter
+  - url_launcher_web (0.0.1):
+    - Flutter
 
 DEPENDENCIES:
-  - Flutter (from `.symlinks/flutter/ios`)
+  - Flutter (from `Flutter`)
+  - flutter_plugin_android_lifecycle (from `.symlinks/plugins/flutter_plugin_android_lifecycle/ios`)
   - image_picker (from `.symlinks/plugins/image_picker/ios`)
   - url_launcher (from `.symlinks/plugins/url_launcher/ios`)
+  - url_launcher_macos (from `.symlinks/plugins/url_launcher_macos/ios`)
+  - url_launcher_web (from `.symlinks/plugins/url_launcher_web/ios`)
 
 EXTERNAL SOURCES:
   Flutter:
-    :path: ".symlinks/flutter/ios"
+    :path: Flutter
+  flutter_plugin_android_lifecycle:
+    :path: ".symlinks/plugins/flutter_plugin_android_lifecycle/ios"
   image_picker:
     :path: ".symlinks/plugins/image_picker/ios"
   url_launcher:
     :path: ".symlinks/plugins/url_launcher/ios"
+  url_launcher_macos:
+    :path: ".symlinks/plugins/url_launcher_macos/ios"
+  url_launcher_web:
+    :path: ".symlinks/plugins/url_launcher_web/ios"
 
 SPEC CHECKSUMS:
   Flutter: 0e3d915762c693b495b44d77113d4970485de6ec
-  image_picker: 16e5fec1fbc87fd3b297c53e4048521eaf17cd06
-  url_launcher: 0067ddb8f10d36786672aa0722a21717dba3a298
+  flutter_plugin_android_lifecycle: 47de533a02850f070f5696a623995e93eddcdb9b
+  image_picker: e3eacd46b94694dde7cf2705955cece853aa1a8f
+  url_launcher: a1c0cc845906122c4784c542523d8cacbded5626
+  url_launcher_macos: fd7894421cd39320dce5f292fc99ea9270b2a313
+  url_launcher_web: e5527357f037c87560776e36436bf2b0288b965c
 
-PODFILE CHECKSUM: 1e5af4103afd21ca5ead147d7b81d06f494f51a2
+PODFILE CHECKSUM: 3dbe063e9c90a5d7c9e4e76e70a821b9e2c1d271
 
 COCOAPODS: 1.7.2

packages/zefyr/example/ios/Runner.xcodeproj/project.pbxproj

 			files = (
 			);
 			inputPaths = (
-				"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks.sh",
-				"${PODS_ROOT}/../.symlinks/flutter/ios/Flutter.framework",
 			);
 			name = "[CP] Embed Pods Frameworks";
 			outputPaths = (
-				"${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/Flutter.framework",
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 			shellPath = /bin/sh;

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

   final TextEditingController _inputController = TextEditingController();
   Key _inputKey;
   bool _formatError = false;
-  ZefyrScope _editor;
 
   bool get isEditing => _inputKey != null;
 

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

   /// and that has not been applied yet.
   /// It gets reseted after each format action within the [document].
   NotusStyle get toggledStyles => _toggledStyles;
-  NotusStyle _toggledStyles = new NotusStyle();
+  NotusStyle _toggledStyles = NotusStyle();
 
   /// Updates selection with specified [value].
   ///
           delta.length == 2 &&
           delta[1].isInsert) {
         // Apply it.
-        Delta retainDelta = new Delta()
+        Delta retainDelta = Delta()
           ..retain(index)
           ..retain(1, toggledStyles.toJson());
         document.compose(retainDelta, ChangeSource.local);
     }
 
     // Always reset it after any user action, even if it has not been applied.
-    _toggledStyles = new NotusStyle();
+    _toggledStyles = NotusStyle();
 
     if (selection != null) {
       if (delta == null) {

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

   void updateFloatingCursor(RawFloatingCursorPoint point) {
     // TODO: implement updateFloatingCursor
   }
+
+  @override
+  void connectionClosed() {
+    if (hasConnection) {
+      _textInputConnection.connectionClosedReceived();
+      _textInputConnection = null;
+      _lastKnownRemoteTextEditingValue = null;
+      _sentRemoteValues.clear();
+    }
+  }
 }

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

 
   static ZefyrScaffoldState of(BuildContext context) {
     final _ZefyrScaffoldAccess widget =
-        context.inheritFromWidgetOfExactType(_ZefyrScaffoldAccess);
+        context.dependOnInheritedWidgetOfExactType<_ZefyrScaffoldAccess>();
     return widget.scaffold;
   }
 

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

 
   static ZefyrScope of(BuildContext context) {
     final ZefyrScopeAccess widget =
-        context.inheritFromWidgetOfExactType(ZefyrScopeAccess);
+        context.dependOnInheritedWidgetOfExactType<ZefyrScopeAccess>();
     return widget.scope;
   }
 

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

   /// 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}) {
-    final ZefyrTheme widget = context.inheritFromWidgetOfExactType(ZefyrTheme);
+    final ZefyrTheme widget =
+        context.dependOnInheritedWidgetOfExactType<ZefyrTheme>();
     if (widget == null && nullOk) return null;
     assert(widget != null,
         '$ZefyrTheme.of() called with a context that does not contain a ZefyrEditor.');

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

 
   static ZefyrToolbarState of(BuildContext context) {
     final _ZefyrToolbarScope scope =
-        context.inheritFromWidgetOfExactType(_ZefyrToolbarScope);
+        context.dependOnInheritedWidgetOfExactType<_ZefyrToolbarScope>();
     return scope?.toolbar;
   }
 

packages/zefyr/pubspec.yaml

 name: zefyr
 description: Clean, minimalistic and collaboration-ready rich text editor for Flutter.
-version: 0.8.0
+version: 0.9.0
 author: Anatoly Pulyaevskiy <anatoly.pulyaevskiy@gmail.com>
 homepage: https://github.com/memspace/zefyr
 
     sdk: flutter
   collection: ^1.14.6
   url_launcher: ^5.0.0
-  quill_delta: ^1.0.0-dev.1.0
+  quill_delta: ^1.0.0
   notus: ^0.1.0
   meta: ^1.1.0
   quiver_hashcode: ^2.0.0

packages/zefyr/test/widgets/controller_test.dart

 
       expect(
         controller.document.toDelta(),
-        new Delta()
+        Delta()
           ..insert('Won')
           ..insert('B', NotusAttribute.bold.toJson())
           ..insert('rds')
       expect(notified, isTrue);
       expect(
         controller.document.toDelta(),
-        new Delta()
+        Delta()
           ..insert('W')
           ..insert('B', NotusAttribute.bold.toJson())
           ..insert('uords')
     });
 
     test('getSelectionStyle with toggled style', () {
-      var selection = new TextSelection.collapsed(offset: 3);
+      var selection = TextSelection.collapsed(offset: 3);
       controller.replaceText(0, 0, 'Words', selection: selection);
       controller.formatText(3, 0, NotusAttribute.bold);