Added pedantic to Notus and fixed lint warnings

packages/notus/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/notus/example/main.dart

 import 'package:notus/notus.dart';
 
 void main() {
-  final doc = new NotusDocument();
+  final doc = NotusDocument();
   // Modify this document with insert, delete and format operations
   doc.insert(
       0, 'Notus package provides rich text document model for Zefyr editor');
   doc.collectStyle(1, 0); // returned style would include "bold" and "h1".
 
   // Listen to all changes applied to this document.
-  doc.changes.listen((change){
+  doc.changes.listen((change) {
     print(change);
   });
 

packages/notus/lib/convert.dart

 export 'src/convert/markdown.dart';
 
 /// Markdown codec for Notus documents.
-const NotusMarkdownCodec notusMarkdown = const NotusMarkdownCodec();
+const NotusMarkdownCodec notusMarkdown = NotusMarkdownCodec();

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

 
   @override
   Converter<String, Delta> get decoder =>
-      throw new UnimplementedError('Decoding is not implemented yet.');
+      throw UnimplementedError('Decoding is not implemented yet.');
 
   @override
-  Converter<Delta, String> get encoder => new _NotusMarkdownEncoder();
+  Converter<Delta, String> get encoder => _NotusMarkdownEncoder();
 }
 
 class _NotusMarkdownEncoder extends Converter<Delta, String> {
 
   @override
   String convert(Delta input) {
-    final iterator = new DeltaIterator(input);
-    final buffer = new StringBuffer();
-    final lineBuffer = new StringBuffer();
+    final iterator = DeltaIterator(input);
+    final buffer = StringBuffer();
+    final lineBuffer = StringBuffer();
     NotusAttribute<String> currentBlockStyle;
-    NotusStyle currentInlineStyle = new NotusStyle();
+    NotusStyle currentInlineStyle = NotusStyle();
     List<String> currentBlockLines = [];
 
     void _handleBlock(NotusAttribute<String> blockStyle) {
       if (lf == -1) {
         _handleSpan(op.data, op.attributes);
       } else {
-        StringBuffer span = new StringBuffer();
+        StringBuffer 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 = new StringBuffer();
+    StringBuffer buffer = StringBuffer();
     if (style.contains(NotusAttribute.heading)) {
       _writeAttribute(buffer, style.get<int>(NotusAttribute.heading));
     }
   }
 
   void _writeAttribute(StringBuffer buffer, NotusAttribute attribute,
-      {bool close: false}) {
+      {bool close = false}) {
     if (attribute == NotusAttribute.bold) {
       _writeBoldTag(buffer);
     } else if (attribute == NotusAttribute.italic) {
     } else if (attribute.key == NotusAttribute.block.key) {
       _writeBlockTag(buffer, attribute as NotusAttribute<String>, close: close);
     } else {
-      throw new ArgumentError('Cannot handle $attribute');
+      throw ArgumentError('Cannot handle $attribute');
     }
   }
 
   }
 
   void _writeLinkTag(StringBuffer buffer, NotusAttribute<String> link,
-      {bool close: false}) {
+      {bool close = false}) {
     if (close) {
       buffer.write('](${link.value})');
     } else {
   }
 
   void _writeBlockTag(StringBuffer buffer, NotusAttribute<String> block,
-      {bool close: false}) {
+      {bool close = false}) {
     if (block == NotusAttribute.code) {
       if (close) {
         buffer.write('\n```');

packages/notus/lib/src/document.dart

   /// Creates new empty Notus document.
   NotusDocument()
       : _heuristics = NotusHeuristics.fallback,
-        _delta = new Delta()..insert('\n') {
+        _delta = Delta()..insert('\n') {
     _loadDocument(_delta);
   }
 
 
   /// The root node of this document tree.
   RootNode get root => _root;
-  final RootNode _root = new RootNode();
+  final RootNode _root = RootNode();
 
   /// Length of this document.
   int get length => _root.length;
   Stream<NotusChange> get changes => _controller.stream;
 
   final StreamController<NotusChange> _controller =
-      new StreamController.broadcast();
+      StreamController.broadcast();
 
   /// Returns contents of this document as [Delta].
-  Delta toDelta() => new Delta.from(_delta);
+  Delta toDelta() => Delta.from(_delta);
   Delta _delta;
 
   /// Returns plain text representation of this document.
     assert(index >= 0);
     assert(text.isNotEmpty);
     text = _sanitizeString(text);
-    if (text.isEmpty) return new Delta();
+    if (text.isEmpty) return Delta();
     final change = _heuristics.applyInsertRules(this, index, text);
     compose(change, ChangeSource.local);
     return change;
   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 = new Delta();
+    Delta delta = Delta();
     // We have to compose before applying delete rules
     // Otherwise delete would be operating on stale document snapshot.
     if (text.isNotEmpty) {
     _delta = _delta.compose(change);
 
     if (_delta != _root.toDelta()) {
-      throw new StateError('Compose produced inconsistent results. '
+      throw StateError('Compose produced inconsistent results. '
           'This is likely due to a bug in the library. Tried to compose change $change from $source.');
     }
-    _controller.add(new NotusChange(before, change, source));
+    _controller.add(NotusChange(before, change, source));
   }
 
   //
       if (op.isInsert) {
         _root.insert(offset, op.data, style);
       } else {
-        throw new ArgumentError.value(doc,
+        throw ArgumentError.value(doc,
             "Document Delta can only contain insert operations but ${op.key} found.");
       }
       offset += op.length;

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

 
   final String key;
   final NotusAttributeScope scope;
-  NotusAttribute<T> get unset => new NotusAttribute<T>._(key, scope, null);
+  NotusAttribute<T> get unset => NotusAttribute<T>._(key, scope, null);
   NotusAttribute<T> withValue(T value) =>
-      new NotusAttribute<T>._(key, scope, value);
+      NotusAttribute<T>._(key, scope, value);
 }
 
 /// Style attribute applicable to a segment of a Notus document.
   // Inline attributes
 
   /// Bold style attribute.
-  static const bold = const _BoldAttribute();
+  static const bold = _BoldAttribute();
 
   /// Italic style attribute.
-  static const italic = const _ItalicAttribute();
+  static const italic = _ItalicAttribute();
 
   /// Link style attribute.
-  static const link = const LinkAttributeBuilder._();
+  // ignore: const_eval_throws_exception
+  static const link = LinkAttributeBuilder._();
 
   // Line attributes
 
   /// Heading style attribute.
-  static const heading = const HeadingAttributeBuilder._();
+  // ignore: const_eval_throws_exception
+  static const heading = HeadingAttributeBuilder._();
 
   /// Alias for [NotusAttribute.heading.level1].
   static NotusAttribute<int> get h1 => heading.level1;
   static NotusAttribute<int> get h3 => heading.level3;
 
   /// Block attribute
-  static const block = const BlockAttributeBuilder._();
+  // ignore: const_eval_throws_exception
+  static const block = BlockAttributeBuilder._();
 
   /// Alias for [NotusAttribute.block.bulletList].
   static NotusAttribute<String> get ul => block.bulletList;
   static NotusAttribute<String> get code => block.code;
 
   /// Embed style attribute.
-  static const embed = const EmbedAttributeBuilder._();
+  // ignore: const_eval_throws_exception
+  static const embed = EmbedAttributeBuilder._();
 
   static NotusAttribute _fromKeyValue(String key, dynamic value) {
-    if (!_registry.containsKey(key))
-      throw new ArgumentError.value(
+    if (!_registry.containsKey(key)) {
+      throw ArgumentError.value(
           key, 'No attribute with key "$key" registered.');
+    }
     final builder = _registry[key];
     return builder.withValue(value);
   }
   ///
   /// When composed into a rich text document, unset attributes remove
   /// associated style.
-  NotusAttribute<T> get unset => new NotusAttribute<T>._(key, scope, null);
+  NotusAttribute<T> get unset => NotusAttribute<T>._(key, scope, null);
 
   /// Returns `true` if this attribute is an unset attribute.
   bool get isUnset => value == null;
   bool get isInline => scope == NotusAttributeScope.inline;
 
   NotusAttribute<T> withValue(T value) =>
-      new NotusAttribute<T>._(key, scope, value);
+      NotusAttribute<T>._(key, scope, value);
 
   @override
   bool operator ==(Object other) {
   final Map<String, NotusAttribute> _data;
 
   static NotusStyle fromJson(Map<String, dynamic> data) {
-    if (data == null) return new NotusStyle();
+    if (data == null) return NotusStyle();
 
     final result = data.map((String key, dynamic value) {
       var attr = NotusAttribute._fromKeyValue(key, value);
-      return new MapEntry<String, NotusAttribute>(key, attr);
+      return MapEntry<String, NotusAttribute>(key, attr);
     });
-    return new NotusStyle._(result);
+    return NotusStyle._(result);
   }
 
-  NotusStyle() : _data = new Map<String, NotusAttribute>();
+  NotusStyle() : _data = Map<String, NotusAttribute>();
 
   /// Returns `true` if this attribute set is empty.
   bool get isEmpty => _data.isEmpty;
 
   /// Puts [attribute] into this attribute set and returns result as a new set.
   NotusStyle put(NotusAttribute attribute) {
-    final result = new Map<String, NotusAttribute>.from(_data);
+    final result = Map<String, NotusAttribute>.from(_data);
     result[attribute.key] = attribute;
-    return new NotusStyle._(result);
+    return NotusStyle._(result);
   }
 
   /// Merges this attribute set with [attribute] and returns result as a new
   /// See also [put] method which does not perform compaction and allows
   /// constructing styles with "unset" values.
   NotusStyle merge(NotusAttribute attribute) {
-    final merged = new Map<String, NotusAttribute>.from(_data);
+    final merged = Map<String, NotusAttribute>.from(_data);
     if (attribute.isUnset) {
       merged.remove(attribute.key);
     } else {
       merged[attribute.key] = attribute;
     }
-    return new NotusStyle._(merged);
+    return NotusStyle._(merged);
   }
 
   /// Merges all attributes from [other] into this style and returns result
   /// as a new instance of [NotusStyle].
   NotusStyle mergeAll(NotusStyle other) {
-    var result = new NotusStyle._(_data);
+    var result = NotusStyle._(_data);
     for (var value in other.values) {
       result = result.merge(value);
     }
   /// Removes [attributes] from this style and returns new instance of
   /// [NotusStyle] containing result.
   NotusStyle removeAll(Iterable<NotusAttribute> attributes) {
-    final merged = new Map<String, NotusAttribute>.from(_data);
+    final merged = Map<String, NotusAttribute>.from(_data);
     attributes.map((item) => item.key).forEach(merged.remove);
-    return new NotusStyle._(merged);
+    return NotusStyle._(merged);
   }
 
   /// Returns JSON-serializable representation of this style.
   Map<String, dynamic> toJson() => _data.isEmpty
       ? null
       : _data.map<String, dynamic>((String _, NotusAttribute value) =>
-          new MapEntry<String, dynamic>(value.key, value.value));
+          MapEntry<String, dynamic>(value.key, value.value));
 
   @override
   bool operator ==(Object other) {
 
   /// Creates a link attribute with specified link [value].
   NotusAttribute<String> fromString(String value) =>
-      new NotusAttribute<String>._(key, scope, value);
+      NotusAttribute<String>._(key, scope, value);
 }
 
 /// Builder for heading attribute styles.
       : super._(_kHeading, NotusAttributeScope.line);
 
   /// Level 1 heading, equivalent of `H1` in HTML.
-  NotusAttribute<int> get level1 => new NotusAttribute<int>._(key, scope, 1);
+  NotusAttribute<int> get level1 => NotusAttribute<int>._(key, scope, 1);
 
   /// Level 2 heading, equivalent of `H2` in HTML.
-  NotusAttribute<int> get level2 => new NotusAttribute<int>._(key, scope, 2);
+  NotusAttribute<int> get level2 => NotusAttribute<int>._(key, scope, 2);
 
   /// Level 3 heading, equivalent of `H3` in HTML.
-  NotusAttribute<int> get level3 => new NotusAttribute<int>._(key, scope, 3);
+  NotusAttribute<int> get level3 => NotusAttribute<int>._(key, scope, 3);
 }
 
 /// Builder for block attribute styles (number/bullet lists, code and quote).
 
   /// Formats a block of lines as a bullet list.
   NotusAttribute<String> get bulletList =>
-      new NotusAttribute<String>._(key, scope, 'ul');
+      NotusAttribute<String>._(key, scope, 'ul');
 
   /// Formats a block of lines as a number list.
   NotusAttribute<String> get numberList =>
-      new NotusAttribute<String>._(key, scope, 'ol');
+      NotusAttribute<String>._(key, scope, 'ol');
 
   /// Formats a block of lines as a code snippet, using monospace font.
   NotusAttribute<String> get code =>
-      new NotusAttribute<String>._(key, scope, 'code');
+      NotusAttribute<String>._(key, scope, 'code');
 
   /// Formats a block of lines as a quote.
   NotusAttribute<String> get quote =>
-      new NotusAttribute<String>._(key, scope, 'quote');
+      NotusAttribute<String>._(key, scope, 'quote');
 }
 
 class EmbedAttributeBuilder
 enum EmbedType { horizontalRule, image }
 
 class EmbedAttribute extends NotusAttribute<Map<String, dynamic>> {
-  static const _kValueEquality = const MapEquality<String, dynamic>();
+  static const _kValueEquality = MapEquality<String, dynamic>();
   static const _kEmbed = 'embed';
   static const _kHorizontalRuleEmbed = 'hr';
   static const _kImageEmbed = 'image';
   }
 
   @override
-  NotusAttribute<Map<String, dynamic>> get unset => new EmbedAttribute._(null);
+  NotusAttribute<Map<String, dynamic>> get unset => EmbedAttribute._(null);
 
   @override
   bool operator ==(other) {

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

     implements StyledNode {
   /// Creates new unmounted [BlockNode] with the same attributes.
   BlockNode clone() {
-    final node = new BlockNode();
+    final node = BlockNode();
     node.applyStyle(style);
     return node;
   }
   }
 
   @override
-  LineNode get defaultChild => new LineNode();
+  LineNode get defaultChild => LineNode();
 
   @override
   Delta toDelta() {
     // Line nodes take care of incorporating block style into their delta.
     return children
         .map((child) => child.toDelta())
-        .fold(new Delta(), (a, b) => a.concat(b));
+        .fold(Delta(), (a, b) => a.concat(b));
   }
 
   @override
   String toString() {
     final block = style.value(NotusAttribute.block);
-    final buffer = new StringBuffer('§ {$block}\n');
+    final buffer = StringBuffer('§ {$block}\n');
     for (var child in children) {
       final tree = child.isLast ? '└' : '├';
       buffer.write('  $tree $child');

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

     LeafNode node;
     if (value == kZeroWidthSpace) {
       // Zero-width space is reserved for embed nodes.
-      node = new EmbedNode();
+      node = EmbedNode();
     } else {
       assert(
           !value.contains(kZeroWidthSpace),
           'Zero-width space is reserved for embed leaf nodes and cannot be used '
           'inside regular text nodes.');
-      node = new TextNode(value);
+      node = TextNode(value);
     }
     return node;
   }
 
     String text = _value;
     _value = text.substring(0, index);
-    final split = new LeafNode(text.substring(index));
+    final split = LeafNode(text.substring(index));
     split.applyStyle(style);
     insertAfter(split);
     return split;
 
   @override
   Delta toDelta() {
-    return new Delta()..insert(_value, style.toJson());
+    return Delta()..insert(_value, style.toJson());
   }
 
   @override
   void insert(int index, String value, NotusStyle style) {
     assert(index >= 0 && (index <= length), 'Index: $index, Length: $length.');
     assert(value.isNotEmpty);
-    final node = new LeafNode(value);
+    final node = LeafNode(value);
     if (index == length) {
       insertAfter(node);
     } else {
   TextNode([String content = '']) : super._(content);
 }
 
-final kZeroWidthSpace = new String.fromCharCode(0x200b);
+final kZeroWidthSpace = String.fromCharCode(0x200b);
 
 /// An embed node inside of a line in a Notus document.
 ///
 /// applying "bold" style to an image gives no effect, while adding a "link" to
 /// an image actually makes the image react to user's action.
 class EmbedNode extends LeafNode {
-  static final kPlainTextPlaceholder = new String.fromCharCode(0x200b);
+  static final kPlainTextPlaceholder = String.fromCharCode(0x200b);
 
   EmbedNode() : super._(kPlainTextPlaceholder);
 }

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

             ? (parent.next as BlockNode).first
             : parent.next;
         return line;
-      } else
+      } else {
         return null;
+      }
     } else {
       LineNode line = (next is BlockNode) ? (next as BlockNode).first : next;
       return line;
 
   /// Creates new empty [LineNode] with the same style.
   LineNode clone() {
-    final node = new LineNode();
+    final node = LineNode();
     node.applyStyle(style);
     return node;
   }
   NotusStyle collectStyle(int offset, int length) {
     int local = math.min(this.length - offset, length);
 
-    NotusStyle result = new NotusStyle();
-    Set<NotusAttribute> excluded = new Set();
+    NotusStyle result = NotusStyle();
+    Set<NotusAttribute> excluded = Set();
 
     void _handle(NotusStyle style) {
       if (result.isEmpty) {
   }
 
   @override
-  LeafNode get defaultChild => new TextNode();
+  LeafNode get defaultChild => TextNode();
 
   // TODO: should be able to cache length and invalidate on any child-related operation
   @override
   Delta toDelta() {
     final Delta delta = children
         .map((text) => text.toDelta())
-        .fold(new Delta(), (a, b) => a.concat(b));
+        .fold(Delta(), (a, b) => a.concat(b));
     var attributes = style;
     if (parent is BlockNode) {
       BlockNode block = parent;
     if (newStyle == null || newStyle.isEmpty) return;
 
     applyStyle(newStyle);
-    if (!newStyle.contains(NotusAttribute.block))
-      return; // no block-level changes
+    if (!newStyle.contains(NotusAttribute.block)) {
+      return;
+    } // no block-level changes
 
     final blockStyle = newStyle.get(NotusAttribute.block);
     if (parent is BlockNode) {
         unwrap();
       } else if (blockStyle != parentStyle) {
         unwrap();
-        BlockNode block = new BlockNode();
+        BlockNode 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 = new BlockNode();
+      BlockNode block = BlockNode();
       block.applyAttribute(blockStyle);
       wrap(block);
       block.optimize();
     if (text.isEmpty) return;
 
     if (isEmpty) {
-      final child = new LeafNode(text);
+      final child = LeafNode(text);
       add(child);
       child.formatAndOptimize(style);
     } else {

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

 /// Most of the operation handling logic is implemented by [LineNode] and
 /// [TextNode].
 abstract class ContainerNode<T extends Node> extends Node {
-  final LinkedList<Node> _children = new LinkedList<Node>();
+  final LinkedList<Node> _children = LinkedList<Node>();
 
   /// List of children.
   LinkedList<Node> get children => _children;
   /// [LookupResult.offset] is set to relative offset within returned child node
   /// which points at the same character position in the document as the
   /// original [offset].
-  LookupResult lookup(int offset, {bool inclusive: false}) {
+  LookupResult lookup(int offset, {bool inclusive = false}) {
     assert(offset >= 0 && offset <= this.length);
 
     for (Node node in children) {
       final int length = node.length;
       if (offset < length || (inclusive && offset == length && (node.isLast))) {
-        return new LookupResult(node, offset);
+        return LookupResult(node, offset);
       }
       offset -= length;
     }
-    return new LookupResult(null, 0);
+    return LookupResult(null, 0);
   }
 
   //
 abstract class StyledNodeMixin implements StyledNode {
   @override
   NotusStyle get style => _style;
-  NotusStyle _style = new NotusStyle();
+  NotusStyle _style = NotusStyle();
 
   /// Applies style [attribute] to this node.
   void applyAttribute(NotusAttribute attribute) {
 
   /// Clears style of this node.
   void clearStyle() {
-    _style = new NotusStyle();
+    _style = NotusStyle();
   }
 }
 
 /// Root node of document tree.
 class RootNode extends ContainerNode<ContainerNode<Node>> {
   @override
-  ContainerNode<Node> get defaultChild => new LineNode();
+  ContainerNode<Node> get defaultChild => LineNode();
 
   @override
   void optimize() {/* no-op */}
   @override
   Delta toDelta() => children
       .map((child) => child.toDelta())
-      .fold(new Delta(), (a, b) => a.concat(b));
+      .fold(Delta(), (a, b) => a.concat(b));
 }

packages/notus/lib/src/heuristics.dart

       final result = rule.apply(delta, index, insert);
       if (result != null) return result..trim();
     }
-    throw new StateError(
-        'Failed to apply insert heuristic rules: none applied.');
+    throw StateError('Failed to apply insert heuristic rules: none applied.');
   }
 
   /// Applies heuristic rules to specified format operation based on current
       final result = rule.apply(delta, index, length, value);
       if (result != null) return result..trim();
     }
-    throw new StateError(
-        'Failed to apply format heuristic rules: none applied.');
+    throw StateError('Failed to apply format heuristic rules: none applied.');
   }
 
   /// Applies heuristic rules to specified delete operation based on current
       final result = rule.apply(delta, index, length);
       if (result != null) return result..trim();
     }
-    throw new StateError(
-        'Failed to apply delete heuristic rules: none applied.');
+    throw StateError('Failed to apply delete heuristic rules: none applied.');
   }
 }

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

 
   @override
   Delta apply(Delta document, int index, int length) {
-    return new Delta()
+    return Delta()
       ..retain(index)
       ..delete(length);
   }
 
   @override
   Delta apply(Delta document, int index, int length) {
-    DeltaIterator iter = new DeltaIterator(document);
+    DeltaIterator iter = DeltaIterator(document);
     iter.skip(index);
     final target = iter.next(1);
     if (target.data != '\n') return null;
     iter.skip(length - 1);
-    final Delta result = new Delta()
+    final Delta result = Delta()
       ..retain(index)
       ..delete(length);
 
 
   Map<String, dynamic> _unsetAttributes(Map<String, dynamic> attributes) {
     if (attributes == null) return null;
-    return attributes.map<String, dynamic>((String key, dynamic value) =>
-        new MapEntry<String, dynamic>(key, null));
+    return attributes.map<String, dynamic>(
+        (String key, dynamic value) => MapEntry<String, dynamic>(key, null));
   }
 }
 
 
   @override
   Delta apply(Delta document, int index, int length) {
-    DeltaIterator iter = new DeltaIterator(document);
+    DeltaIterator iter = DeltaIterator(document);
 
     // First, check if line-break deleted after an embed.
     Operation op = iter.skip(index);
     }
 
     if (foundEmbed) {
-      return new Delta()
+      return Delta()
         ..retain(index + indexDelta)
         ..delete(length + lengthDelta);
     }

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

   Delta apply(Delta document, int index, int length, NotusAttribute attribute) {
     if (attribute.scope != NotusAttributeScope.line) return null;
 
-    Delta result = new Delta()..retain(index);
-    final iter = new DeltaIterator(document);
+    Delta result = Delta()..retain(index);
+    final iter = DeltaIterator(document);
     iter.skip(index);
 
     // Apply line styles to all line-break characters within range of this
   }
 
   Delta _applyAttribute(String text, NotusAttribute attribute) {
-    final result = new Delta();
+    final result = Delta();
     int offset = 0;
     int lf = text.indexOf('\n');
     while (lf >= 0) {
   Delta apply(Delta document, int index, int length, NotusAttribute attribute) {
     if (attribute.scope != NotusAttributeScope.inline) return null;
 
-    Delta result = new Delta()..retain(index);
-    final iter = new DeltaIterator(document);
+    Delta result = Delta()..retain(index);
+    final iter = DeltaIterator(document);
     iter.skip(index);
 
     // Apply inline styles to all non-line-break characters within range of this
     // edge cases.
     if (length != 0) return null;
 
-    Delta result = new Delta();
-    final iter = new DeltaIterator(document);
+    Delta result = Delta();
+    final iter = DeltaIterator(document);
     final before = iter.skip(index);
     final after = iter.next();
     int startIndex = index;
 
     if (length == 1 && embed.isUnset) {
       // Remove the embed.
-      return new Delta()
+      return Delta()
         ..retain(index)
         ..delete(length);
     } else {
 
   Delta _insertEmbed(
       Delta document, int index, int length, EmbedAttribute embed) {
-    Delta result = new Delta()..retain(index);
-    final iter = new DeltaIterator(document);
+    Delta result = Delta()..retain(index);
+    final iter = DeltaIterator(document);
     final previous = iter.skip(index);
     iter.skip(length); // ignore deleted part.
     final target = iter.next();
 
   Map<String, dynamic> _getLineStyle(
       DeltaIterator iterator, Operation current) {
-    if (current.data.indexOf('\n') >= 0) {
+    if (current.data.contains('\n')) {
       return current.attributes;
     }
     // Continue looking for line-break.

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

 
   @override
   Delta apply(Delta document, int index, String text) {
-    return new Delta()
+    return Delta()
       ..retain(index)
       ..insert(text);
   }
   Delta apply(Delta document, int index, String text) {
     if (text != '\n') return null;
 
-    DeltaIterator iter = new DeltaIterator(document);
+    DeltaIterator iter = DeltaIterator(document);
     final before = iter.skip(index);
     final after = iter.next();
     if (isEdgeLineSplit(before, after)) return null;
-    Delta result = new Delta()..retain(index);
-    if (after.data.indexOf('\n') >= 0) {
+    Delta 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.
       // The only scenario we get such operation is when the text is plain.
   Delta apply(Delta document, int index, String text) {
     if (text != '\n') return null;
 
-    DeltaIterator iter = new DeltaIterator(document);
+    DeltaIterator iter = DeltaIterator(document);
     iter.skip(index);
     final target = iter.next();
 
           target.attributes.containsKey(NotusAttribute.heading.key)) {
         resetStyle = NotusAttribute.heading.unset.toJson();
       }
-      return new Delta()
+      return Delta()
         ..retain(index)
         ..insert('\n', target.attributes)
         ..retain(1, resetStyle)
   Delta apply(Delta document, int index, String text) {
     if (text != '\n') return null;
 
-    DeltaIterator iter = new DeltaIterator(document);
+    DeltaIterator iter = DeltaIterator(document);
     final previous = iter.skip(index);
     final target = iter.next();
     final isInBlock = target.isNotPlain &&
       var attributes =
           target.attributes != null ? target.attributes : <String, dynamic>{};
       attributes.addAll(NotusAttribute.block.unset.toJson());
-      return new Delta()..retain(index)..retain(1, attributes);
+      return Delta()..retain(index)..retain(1, attributes);
     }
     return null;
   }
     // This rule is only applicable to characters other than line-break.
     if (text.contains('\n')) return null;
 
-    DeltaIterator iter = new DeltaIterator(document);
+    DeltaIterator 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
     final hasLink =
         (attributes != null && attributes.containsKey(NotusAttribute.link.key));
     if (!hasLink) {
-      return new Delta()
+      return Delta()
         ..retain(index)
         ..insert(text, attributes);
     }
     // Link style should NOT be preserved on the boundaries.
     var noLinkAttributes = previous.attributes;
     noLinkAttributes.remove(NotusAttribute.link.key);
-    final noLinkResult = new Delta()
+    final noLinkResult = Delta()
       ..retain(index)
       ..insert(text, noLinkAttributes.isEmpty ? null : noLinkAttributes);
     final next = iter.next();
     // We must make sure links are identical in previous and next operations.
     if (attributes[NotusAttribute.link.key] ==
         nextAttributes[NotusAttribute.link.key]) {
-      return new Delta()
+      return Delta()
         ..retain(index)
         ..insert(text, attributes);
     } else {
     // everything else.
     if (text != ' ') return null;
 
-    DeltaIterator iter = new DeltaIterator(document);
+    DeltaIterator iter = DeltaIterator(document);
     final previous = iter.skip(index);
     // No previous operation means no link.
     if (previous == null) return null;
 
       attributes
           .addAll(NotusAttribute.link.fromString(link.toString()).toJson());
-      return new Delta()
+      return Delta()
         ..retain(index - candidate.length)
         ..retain(candidate.length, attributes)
         ..insert(text, previous.attributes);
 
   @override
   Delta apply(Delta document, int index, String text) {
-    DeltaIterator iter = new DeltaIterator(document);
+    DeltaIterator iter = DeltaIterator(document);
     final previous = iter.skip(index);
     final target = iter.next();
     final beforeEmbed = target.data == EmbedNode.kPlainTextPlaceholder;
     final afterEmbed = previous?.data == EmbedNode.kPlainTextPlaceholder;
     if (beforeEmbed || afterEmbed) {
-      final delta = new Delta()..retain(index);
+      final delta = Delta()..retain(index);
       if (beforeEmbed && !text.endsWith('\n')) {
         return delta..insert(text)..insert('\n');
       }
       return null;
     }
 
-    DeltaIterator iter = new DeltaIterator(document);
+    DeltaIterator iter = DeltaIterator(document);
     iter.skip(index);
 
     // Look for next line-break.
     }
 
     final lines = text.split('\n');
-    Delta result = new Delta()..retain(index);
+    Delta result = Delta()..retain(index);
     for (int i = 0; i < lines.length; i++) {
       final line = lines[i];
       if (line.isNotEmpty) {

packages/notus/pubspec.yaml

   quiver_hashcode: ^2.0.0
 
 dev_dependencies:
+  pedantic: ^1.0.0
   test: ^1.0.0
   test_coverage: ^0.2.1

packages/notus/test/convert/markdown_test.dart

 
   group('$NotusMarkdownCodec.encode', () {
     test('split adjacent paragraphs', () {
-      final delta = new Delta()..insert('First line\nSecond line\n');
+      final delta = Delta()..insert('First line\nSecond line\n');
       final result = notusMarkdown.encode(delta);
       expect(result, 'First line\n\nSecond line\n\n');
     });
 
     test('bold italic', () {
       runFor(NotusAttribute<bool> attribute, String expected) {
-        final delta = new Delta()
+        final delta = Delta()
           ..insert('This ')
           ..insert('house', attribute.toJson())
           ..insert(' is a ')
     test('intersecting inline styles', () {
       final b = NotusAttribute.bold.toJson();
       final i = NotusAttribute.italic.toJson();
-      final bi = new Map<String, dynamic>.from(b);
+      final bi = Map<String, dynamic>.from(b);
       bi.addAll(i);
 
-      final delta = new Delta()
+      final delta = Delta()
         ..insert('This ')
         ..insert('house', b)
         ..insert(' is a ', bi)
     test('normalize inline styles', () {
       final b = NotusAttribute.bold.toJson();
       final i = NotusAttribute.italic.toJson();
-      final delta = new Delta()
+      final delta = Delta()
         ..insert('This')
         ..insert(' house ', b)
         ..insert('is a')
     test('links', () {
       final b = NotusAttribute.bold.toJson();
       final link = NotusAttribute.link.fromString('https://github.com');
-      final delta = new Delta()
+      final delta = Delta()
         ..insert('This')
         ..insert(' house ', b)
         ..insert('is a')
 
     test('heading styles', () {
       runFor(NotusAttribute<int> attribute, String source, String expected) {
-        final delta = new Delta()
-          ..insert(source)
-          ..insert('\n', attribute.toJson());
+        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) {
-        final delta = new Delta()
-          ..insert(source)
-          ..insert('\n', attribute.toJson());
+        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) {
-        final delta = new Delta()
+        final delta = Delta()
           ..insert(source)
           ..insert('\n', attribute.toJson())
           ..insert(source)

packages/notus/test/document/block_test.dart

 import 'package:test/test.dart';
 import 'package:quill_delta/quill_delta.dart';
 
-final ulAttrs = new NotusStyle().merge(NotusAttribute.ul);
-final olAttrs = new NotusStyle().merge(NotusAttribute.ol);
-final h1Attrs = new NotusStyle().merge(NotusAttribute.h1);
+final ulAttrs = NotusStyle().merge(NotusAttribute.ul);
+final olAttrs = NotusStyle().merge(NotusAttribute.ol);
+final h1Attrs = NotusStyle().merge(NotusAttribute.h1);
 
 void main() {
   group('$BlockNode', () {
     ContainerNode root;
     setUp(() {
-      root = new RootNode();
+      root = RootNode();
     });
 
     test('empty', () {
-      BlockNode node = new BlockNode();
+      BlockNode node = BlockNode();
       expect(node, isEmpty);
       expect(node.length, 0);
-      expect(node.style, new NotusStyle());
+      expect(node.style, NotusStyle());
     });
 
     test('toString', () {
-      LineNode line = new LineNode();
-      line.add(new TextNode('London "Grammar"'));
-      BlockNode block = new BlockNode();
+      LineNode line = LineNode();
+      line.add(TextNode('London "Grammar"'));
+      BlockNode block = BlockNode();
       block.applyAttribute(NotusAttribute.ul);
       block.add(line);
       final expected = '§ {ul}\n  └ ¶ ⟨London "Grammar"⟩ ⏎';
 
       expect(root.childCount, 1);
       BlockNode block = root.first;
-      expect(block.style.get(NotusAttribute.block),
-          NotusAttribute.ul);
+      expect(block.style.get(NotusAttribute.block), NotusAttribute.ul);
       expect(block.childCount, 1);
       expect(block.first, const TypeMatcher<LineNode>());
 
       LineNode line = block.first;
-      Delta delta = new Delta()
+      Delta delta = Delta()
         ..insert('Hello world')
         ..insert('\n', ulAttrs.toJson());
       expect(line.toDelta(), delta);
 
       expect(root.childCount, 2);
       BlockNode block = root.last;
-      expect(block.style.get(NotusAttribute.block),
-          NotusAttribute.ul);
+      expect(block.style.get(NotusAttribute.block), NotusAttribute.ul);
       expect(block.childCount, 1);
       expect(block.first, const TypeMatcher<LineNode>());
     });
 
       expect(root.childCount, 1);
       BlockNode block = root.first;
-      expect(block.style.get(NotusAttribute.block),
-          NotusAttribute.ul);
+      expect(block.style.get(NotusAttribute.block), NotusAttribute.ul);
       expect(block.childCount, 2);
       expect(block.first, const TypeMatcher<LineNode>());
       expect(block.last, const TypeMatcher<LineNode>());
       expect(root.childCount, 2);
       root.retain(28, 1, olAttrs);
       expect(root.childCount, 3);
-      final expected = new Delta()
+      final expected = Delta()
         ..insert('London Grammar Songs')
         ..insert('\n', NotusAttribute.h1.toJson())
         ..insert('Hey now')
       expect(root.childCount, 2);
       root.retain(47, 1, olAttrs);
       expect(root.childCount, 3);
-      final expected = new Delta()
+      final expected = Delta()
         ..insert('London Grammar Songs')
         ..insert('\n', NotusAttribute.h1.toJson())
         ..insert('Hey now')
       expect(root.childCount, 2);
       root.retain(35, 1, olAttrs);
       expect(root.childCount, 4);
-      final expected = new Delta()
+      final expected = Delta()
         ..insert('London Grammar Songs')
         ..insert('\n', NotusAttribute.h1.toJson())
         ..insert('Hey now')

packages/notus/test/document/line_test.dart

 import 'package:quill_delta/quill_delta.dart';
 import 'package:notus/notus.dart';
 
-final boldStyle = new NotusStyle().merge(NotusAttribute.bold);
-final h1Style = new NotusStyle().merge(NotusAttribute.h1);
-final h2Style = new NotusStyle().merge(NotusAttribute.h2);
-final ulStyle = new NotusStyle().merge(NotusAttribute.ul);
-final bqStyle = new NotusStyle().merge(NotusAttribute.bq);
+final boldStyle = NotusStyle().merge(NotusAttribute.bold);
+final h1Style = NotusStyle().merge(NotusAttribute.h1);
+final h2Style = NotusStyle().merge(NotusAttribute.h2);
+final ulStyle = NotusStyle().merge(NotusAttribute.ul);
+final bqStyle = NotusStyle().merge(NotusAttribute.bq);
 
 void main() {
   group('$LineNode', () {
     ContainerNode root;
     setUp(() {
-      root = new RootNode();
+      root = RootNode();
     });
 
     test('empty', () {
-      LineNode node = new LineNode();
+      LineNode node = LineNode();
       expect(node, isEmpty);
       expect(node.length, 1);
-      expect(node.style, new NotusStyle());
-      expect(node.toDelta().toList(), [new Operation.insert('\n')]);
+      expect(node.style, NotusStyle());
+      expect(node.toDelta().toList(), [Operation.insert('\n')]);
     });
 
     test('hasEmbed', () {
-      LineNode node = new LineNode();
+      LineNode node = LineNode();
       expect(node.hasEmbed, isFalse);
-      node.add(new EmbedNode());
+      node.add(EmbedNode());
       expect(node.hasEmbed, isTrue);
     });
 
     });
 
     test('toString', () {
-      LineNode node = new LineNode();
+      LineNode 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 = new LineNode();
+      LineNode node = LineNode();
       node.insert(0, 'London "Grammar" - Hey Now', null);
       expect(node, hasLength(27));
-      expect(
-          node.toDelta(), new Delta()..insert('London "Grammar" - Hey Now\n'));
+      expect(node.toDelta(), Delta()..insert('London "Grammar" - Hey Now\n'));
     });
 
     test('insert into empty line with styles', () {
-      LineNode node = new LineNode();
+      LineNode node = LineNode();
       node.insert(0, 'London "Grammar" - Hey Now', null);
       node.retain(0, 16, boldStyle);
       node.applyAttribute(NotusAttribute.h1);
       expect(node, hasLength(27));
       expect(node.childCount, 2);
 
-      final delta = new Delta()
+      final delta = Delta()
         ..insert('London "Grammar"', boldStyle.toJson())
         ..insert(' - Hey Now')
         ..insert('\n', NotusAttribute.h1.toJson());
     });
 
     test('insert into non-empty line', () {
-      LineNode node = new LineNode();
+      LineNode node = LineNode();
       node.insert(0, 'Hello world', null);
       node.insert(11, '!!!', null);
       expect(node, hasLength(15));
       expect(node.childCount, 1);
-      expect(node.toDelta(), new Delta()..insert('Hello world!!!\n'));
+      expect(node.toDelta(), Delta()..insert('Hello world!!!\n'));
     });
 
     test('insert text with line-break at the end of line', () {
 
       LineNode line = root.first;
       expect(line, hasLength(15));
-      expect(line.toDelta(), new Delta()..insert('Hello world!!!\n'));
+      expect(line.toDelta(), Delta()..insert('Hello world!!!\n'));
 
       LineNode line2 = root.last;
       expect(line2, hasLength(1));
-      expect(line2.toDelta(), new Delta()..insert('\n'));
+      expect(line2.toDelta(), Delta()..insert('\n'));
     });
 
     test('insert into second text segment', () {
 
       LineNode line = root.first;
       expect(line, hasLength(15));
-      Delta delta = new Delta()
+      Delta delta = Delta()
         ..insert('Hello ')
         ..insert('world', boldStyle.toJson())
         ..insert('!!!\n');
       LineNode line = root.first;
       expect(line, hasLength(12));
 
-      Delta delta = new Delta()
+      Delta delta = Delta()
         ..insert('Hello world')
         ..insert('\n', NotusAttribute.h1.toJson());
       expect(line.toDelta(), delta);
     });
 
     test('format root line to unset block style', () {
-      final unsetBlock = new NotusStyle().put(NotusAttribute.block.unset);
+      final unsetBlock = NotusStyle().put(NotusAttribute.block.unset);
       root.insert(0, 'Hello world', null);
       root.retain(11, 1, unsetBlock);
       expect(root.childCount, 1);
       LineNode line = root.first;
       expect(line, hasLength(8));
       expect(line.childCount, 1);
-      Delta lineDelta = new Delta()..insert('Hellord\n');
+      Delta lineDelta = Delta()..insert('Hellord\n');
       expect(line.toDelta(), lineDelta);
     });
 
       expect(root.childCount, 1);
       LineNode line = root.first;
       expect(line, hasLength(18));
-      Delta lineDelta = new Delta()
+      Delta lineDelta = Delta()
         ..insert('Hello ')
         ..insert('worl', boldStyle.toJson())
         ..insert(' cd ef!\n');
       expect(root.childCount, 1);
       LineNode line = root.first;
       expect(line.childCount, 1);
-      final delta = new Delta()
-        ..insert('delnes')
-        ..insert('\n', h2Style.toJson());
+      final delta = Delta()..insert('delnes')..insert('\n', h2Style.toJson());
       expect(line.toDelta(), delta);
     });
 
       root.delete(37, 1);
       expect(root.childCount, 3);
       LineNode line = root.children.elementAt(1);
-      expect(
-          line.toDelta(), new Delta()..insert('This is my first multilin\n'));
+      expect(line.toDelta(), Delta()..insert('This is my first multilin\n'));
     });
 
     test('collectStyle', () {
 
     test('collectStyle with embed nodes', () {
       root.insert(0, 'Hello world\n\nMore text.\n', null);
-      NotusStyle style = new NotusStyle();
+      NotusStyle style = NotusStyle();
       style = style.put(NotusAttribute.embed.horizontalRule);
       root.insert(12, EmbedNode.kPlainTextPlaceholder, style);
 

packages/notus/test/document/node_test.dart

   group('$Node', () {
     RootNode root;
     setUp(() {
-      root = new RootNode();
+      root = RootNode();
     });
 
     test('mounted', () {
-      LineNode line = new LineNode();
-      TextNode text = new TextNode();
+      LineNode line = LineNode();
+      TextNode text = TextNode();
       expect(text.mounted, isFalse);
       line.add(text);
       expect(text.mounted, isTrue);

packages/notus/test/document/text_test.dart

 import 'package:quill_delta/quill_delta.dart';
 import 'package:notus/notus.dart';
 
-final boldStyle = new NotusStyle().merge(NotusAttribute.bold);
-final boldUnsetStyle = new NotusStyle().put(NotusAttribute.bold.unset);
-final italicStyle = new NotusStyle().merge(NotusAttribute.italic);
+final boldStyle = NotusStyle().merge(NotusAttribute.bold);
+final boldUnsetStyle = NotusStyle().put(NotusAttribute.bold.unset);
+final italicStyle = NotusStyle().merge(NotusAttribute.italic);
 
 void main() {
   group('$TextNode', () {
     TextNode node;
 
     setUp(() {
-      line = new LineNode();
-      node = new TextNode('London "Grammar"');
+      line = LineNode();
+      node = TextNode('London "Grammar"');
       line.add(node);
     });
 
     test('new empty text', () {
-      final node = new TextNode();
+      final node = TextNode();
       expect(node.value, isEmpty);
       expect(node.length, 0);
-      expect(node.style, new NotusStyle());
+      expect(node.style, NotusStyle());
       expect(node.toDelta(), isEmpty);
     });
 
     test('new text with contents', () {
       expect(node.value, isNotEmpty);
       expect(node.length, 16);
-      expect(
-          node.toDelta().toList(), [new Operation.insert('London "Grammar"')]);
+      expect(node.toDelta().toList(), [Operation.insert('London "Grammar"')]);
     });
 
     test('insert at the end', () {
       final b = boldStyle.toJson();
       expect(
         line.children.elementAt(0).toDelta(),
-        new Delta()..insert('Lon', b),
+        Delta()..insert('Lon', b),
       );
       expect(
         line.children.elementAt(1).toDelta(),
-        new Delta()..insert('don'),
+        Delta()..insert('don'),
       );
       expect(
         line.children.elementAt(2).toDelta(),
-        new Delta()..insert('don', b),
+        Delta()..insert('don', b),
       );
     });
   });

packages/notus/test/document_test.dart

 import 'matchers.dart';
 
 NotusDocument dartconfDoc() {
-  Delta delta = new Delta()..insert('DartConf\nLos Angeles\n');
-  return new NotusDocument.fromDelta(delta);
+  Delta delta = Delta()..insert('DartConf\nLos Angeles\n');
+  return NotusDocument.fromDelta(delta);
 }
 
 NotusDocument dartconfEmbedDoc() {
   final hr = NotusAttribute.embed.horizontalRule.toJson();
-  Delta delta = new Delta()
+  Delta delta = Delta()
     ..insert('DartConf\n')
     ..insert(kZeroWidthSpace, hr)
     ..insert('\n')
     ..insert('Los Angeles\n');
-  return new NotusDocument.fromDelta(delta);
+  return NotusDocument.fromDelta(delta);
 }
 
 final ul = NotusAttribute.ul.toJson();
 void main() {
   group('$NotusDocument', () {
     test('validates for doc delta', () {
-      var badDelta = new Delta()
+      var badDelta = Delta()
         ..insert('Text')
         ..retain(5)
         ..insert('\n');
       expect(() {
-        new NotusDocument.fromDelta(badDelta);
+        NotusDocument.fromDelta(badDelta);
       }, throwsArgumentError);
     });
 
     test('empty document contains single empty line', () {
-      NotusDocument doc = new NotusDocument();
+      NotusDocument doc = NotusDocument();
       expect(doc.toPlainText(), '\n');
     });
 
     });
 
     test('document delta must end with line-break character', () {
-      Delta delta = new Delta()..insert('DartConf\nLos Angeles');
+      Delta delta = Delta()..insert('DartConf\nLos Angeles');
       expect(() {
-        new NotusDocument.fromDelta(delta);
+        NotusDocument.fromDelta(delta);
       }, throwsA(const TypeMatcher<AssertionError>()));
     });
 
     test('format returns actual change delta', () {
       NotusDocument doc = dartconfDoc();
       final change = doc.format(0, 15, NotusAttribute.ul);
-      final expectedChange = new Delta()
+      final expectedChange = Delta()
         ..retain(8)
         ..retain(1, ul)
         ..retain(11)
     test('format updates document delta', () {
       NotusDocument doc = dartconfDoc();
       doc.format(0, 15, NotusAttribute.ul);
-      final expectedDoc = new Delta()
+      final expectedDoc = Delta()
         ..insert('DartConf')
         ..insert('\n', ul)
         ..insert('Los Angeles')
     test('format allows zero-length updates', () {
       NotusDocument doc = dartconfDoc();
       doc.format(0, 0, NotusAttribute.ul);
-      final expectedDoc = new Delta()
+      final expectedDoc = Delta()
         ..insert('DartConf')
         ..insert('\n', ul)
         ..insert('Los Angeles')
       NotusDocument doc = dartconfDoc();
       doc.format(0, 15, NotusAttribute.ul);
       final change = doc.insert(8, '\n');
-      final expectedChange = new Delta()
+      final expectedChange = Delta()
         ..retain(8)
         ..insert('\n', ul);
       expect(change, expectedChange);
       NotusDocument doc = dartconfDoc();
       doc.format(0, 15, NotusAttribute.ul);
       doc.insert(8, '\n');
-      final expectedDoc = new Delta()
+      final expectedDoc = Delta()
         ..insert('DartConf')
         ..insert('\n\n', ul)
         ..insert('Los Angeles')
     test('compose throws assert error if change is empty', () {
       NotusDocument doc = dartconfDoc();
       expect(() {
-        doc.compose(new Delta()..retain(1), ChangeSource.local);
+        doc.compose(Delta()..retain(1), ChangeSource.local);
       }, throwsA(const TypeMatcher<AssertionError>()));
     });
 
       doc.close();
       expect(doc.isClosed, isTrue);
       expect(() {
-        doc.compose(new Delta()..insert('a'), ChangeSource.local);
+        doc.compose(Delta()..insert('a'), ChangeSource.local);
       }, throwsAssertionError);
       expect(() {
         doc.insert(0, 'a');
       LineNode line = doc.root.children.elementAt(1);
       EmbedNode embed = line.first;
       expect(embed.toPlainText(), EmbedNode.kPlainTextPlaceholder);
-      final style = new NotusStyle().merge(NotusAttribute.embed.horizontalRule);
+      final style = NotusStyle().merge(NotusAttribute.embed.horizontalRule);
       expect(embed.style, style);
     });
 
       LineNode line = doc.root.children.elementAt(1);
       EmbedNode embed = line.first;
       expect(embed.toPlainText(), EmbedNode.kPlainTextPlaceholder);
-      final style = new NotusStyle().merge(NotusAttribute.embed.horizontalRule);
+      final style = NotusStyle().merge(NotusAttribute.embed.horizontalRule);
       expect(embed.style, style);
     });
 
       LineNode line = doc.root.children.elementAt(1);
       EmbedNode embed = line.first;
       expect(embed.toPlainText(), EmbedNode.kPlainTextPlaceholder);
-      final style = new NotusStyle().merge(NotusAttribute.embed.horizontalRule);
+      final style = NotusStyle().merge(NotusAttribute.embed.horizontalRule);
       expect(embed.style, style);
     });
 

packages/notus/test/heuristics/delete_rules_test.dart

 
 void main() {
   group('$PreserveLineStyleOnMergeRule', () {
-    final rule = new PreserveLineStyleOnMergeRule();
+    final rule = PreserveLineStyleOnMergeRule();
     test('preserves block style', () {
       final ul = NotusAttribute.ul.toJson();
-      final doc = new Delta()
+      final doc = Delta()
         ..insert('Title\nOne')
         ..insert('\n', ul)
         ..insert('Two\n');
       final actual = rule.apply(doc, 9, 1);
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(9)
         ..delete(1)
         ..retain(3)
 
     test('resets block style', () {
       final unsetUl = NotusAttribute.block.unset.toJson();
-      final doc = new Delta()
+      final doc = Delta()
         ..insert('Title\nOne')
         ..insert('\n', NotusAttribute.ul.toJson())
         ..insert('Two\n');
       final actual = rule.apply(doc, 5, 1);
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(5)
         ..delete(1)
         ..retain(3)
   });
 
   group('$CatchAllDeleteRule', () {
-    final rule = new CatchAllDeleteRule();
+    final rule = CatchAllDeleteRule();
 
     test('applies change as-is', () {
-      final doc = new Delta()..insert('Document\n');
+      final doc = Delta()..insert('Document\n');
       final actual = rule.apply(doc, 3, 5);
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(3)
         ..delete(5);
       expect(actual, expected);
   });
 
   group('$EnsureEmbedLineRule', () {
-    final rule = new EnsureEmbedLineRule();
+    final rule = EnsureEmbedLineRule();
 
     test('ensures line-break before embed', () {
       final hr = NotusAttribute.embed.horizontalRule;
-      final doc = new Delta()
+      final doc = Delta()
         ..insert('Document\n')
         ..insert(kZeroWidthSpace, hr.toJson())
         ..insert('\n');
       final actual = rule.apply(doc, 8, 1);
-      final expected = new Delta()..retain(8);
+      final expected = Delta()..retain(8);
       expect(actual, expected);
     });
 
     test('ensures line-break after embed', () {
       final hr = NotusAttribute.embed.horizontalRule;
-      final doc = new Delta()
+      final doc = Delta()
         ..insert('Document\n')
         ..insert(kZeroWidthSpace, hr.toJson())
         ..insert('\n');
       final actual = rule.apply(doc, 10, 1);
-      final expected = new Delta()..retain(11);
+      final expected = Delta()..retain(11);
       expect(actual, expected);
     });
 
     test('still deletes everything between embeds', () {
       final hr = NotusAttribute.embed.horizontalRule;
-      final doc = new Delta()
+      final doc = Delta()
         ..insert('Document\n')
         ..insert(kZeroWidthSpace, hr.toJson())
         ..insert('\nSome text\n')
         ..insert(kZeroWidthSpace, hr.toJson())
         ..insert('\n');
       final actual = rule.apply(doc, 10, 11);
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(11)
         ..delete(9);
       expect(actual, expected);
 
     test('allows deleting empty line after embed', () {
       final hr = NotusAttribute.embed.horizontalRule;
-      final doc = new Delta()
+      final doc = Delta()
         ..insert('Document\n')
         ..insert(kZeroWidthSpace, hr.toJson())
         ..insert('\n')
         ..insert('Text')
         ..insert('\n');
       final actual = rule.apply(doc, 10, 1);
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(11)
         ..delete(1);
       expect(actual, expected);
 
     test('allows deleting empty line(s) before embed', () {
       final hr = NotusAttribute.embed.horizontalRule;
-      final doc = new Delta()
+      final doc = Delta()
         ..insert('Document\n')
         ..insert('\n')
         ..insert('\n')

packages/notus/test/heuristics/format_rules_test.dart

 
 void main() {
   group('$ResolveLineFormatRule', () {
-    final rule = new ResolveLineFormatRule();
+    final rule = ResolveLineFormatRule();
 
     test('apply', () {
-      final doc = new Delta()..insert('Correct\nLine\nStyle\nRule\n');
+      final doc = Delta()..insert('Correct\nLine\nStyle\nRule\n');
 
       final actual = rule.apply(doc, 0, 20, NotusAttribute.ul);
       expect(actual, isNotNull);
       final ul = NotusAttribute.ul.toJson();
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(7)
         ..retain(1, ul)
         ..retain(4)
     });
 
     test('apply with zero length (collapsed selection)', () {
-      final doc = new Delta()..insert('Correct\nLine\nStyle\nRule\n');
+      final doc = Delta()..insert('Correct\nLine\nStyle\nRule\n');
       final actual = rule.apply(doc, 0, 0, NotusAttribute.ul);
       expect(actual, isNotNull);
       final ul = NotusAttribute.ul.toJson();
-      final expected = new Delta()..retain(7)..retain(1, ul);
+      final expected = Delta()..retain(7)..retain(1, ul);
       expect(actual, expected);
     });
 
     test('apply with zero length in the middle of a line', () {
       final ul = NotusAttribute.ul.toJson();
-      final doc = new Delta()
+      final doc = Delta()
         ..insert('Title\nOne')
         ..insert('\n', ul)
         ..insert('Two')
         ..insert('\n', ul)
         ..insert('Three!\n');
       final actual = rule.apply(doc, 7, 0, NotusAttribute.ul);
-      final expected = new Delta()..retain(9)..retain(1, ul);
+      final expected = Delta()..retain(9)..retain(1, ul);
       expect(actual, expected);
     });
   });
 
   group('$ResolveInlineFormatRule', () {
-    final rule = new ResolveInlineFormatRule();
+    final rule = ResolveInlineFormatRule();
 
     test('apply', () {
-      final doc = new Delta()..insert('Correct\nLine\nStyle\nRule\n');
+      final doc = Delta()..insert('Correct\nLine\nStyle\nRule\n');
 
       final actual = rule.apply(doc, 0, 20, NotusAttribute.bold);
       expect(actual, isNotNull);
       final b = NotusAttribute.bold.toJson();
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(7, b)
         ..retain(1)
         ..retain(4, b)
   });
 
   group('$FormatLinkAtCaretPositionRule', () {
-    final rule = new FormatLinkAtCaretPositionRule();
+    final rule = FormatLinkAtCaretPositionRule();
 
     test('apply', () {
       final link =
           NotusAttribute.link.fromString('https://github.com/memspace/bold');
       final newLink =
           NotusAttribute.link.fromString('https://github.com/memspace/zefyr');
-      final doc = new Delta()
+      final doc = Delta()
         ..insert('Visit our ')
         ..insert('website', link.toJson())
         ..insert(' for more details.\n');
 
       final actual = rule.apply(doc, 13, 0, newLink);
       expect(actual, isNotNull);
-      final expected = new Delta()..retain(10)..retain(7, newLink.toJson());
+      final expected = Delta()..retain(10)..retain(7, newLink.toJson());
       expect(actual, expected);
     });
   });

packages/notus/test/heuristics/insert_rules_test.dart

 
 void main() {
   group('$CatchAllInsertRule', () {
-    final rule = new CatchAllInsertRule();
+    final rule = CatchAllInsertRule();
 
     test('applies change as-is', () {
-      final doc = new Delta()..insert('Document\n');
+      final doc = Delta()..insert('Document\n');
       final actual = rule.apply(doc, 8, '!');
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(8)
         ..insert('!');
       expect(actual, expected);
   });
 
   group('$PreserveLineStyleOnSplitRule', () {
-    final rule = new PreserveLineStyleOnSplitRule();
+    final rule = PreserveLineStyleOnSplitRule();
 
     test('skips at the beginning of a document', () {
-      final doc = new Delta()..insert('One\n');
+      final doc = Delta()..insert('One\n');
       final actual = rule.apply(doc, 0, '\n');
       expect(actual, isNull);
     });
 
     test('applies in a block', () {
-      final doc = new Delta()
+      final doc = Delta()
         ..insert('One and two')
         ..insert('\n', ul)
         ..insert('Three')
         ..insert('\n', ul);
       final actual = rule.apply(doc, 8, '\n');
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(8)
         ..insert('\n', ul);
       expect(actual, isNotNull);
     final rule = const ResetLineFormatOnNewLineRule();
 
     test('applies when line-break is inserted at the end of line', () {
-      final doc = new Delta()
+      final doc = Delta()
         ..insert('Hello world')
         ..insert('\n', NotusAttribute.h1.toJson());
       final actual = rule.apply(doc, 11, '\n');
       expect(actual, isNotNull);
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(11)
         ..insert('\n', NotusAttribute.h1.toJson())
         ..retain(1, NotusAttribute.heading.unset.toJson());
     });
 
     test('applies without style reset if not needed', () {
-      final doc = new Delta()..insert('Hello world\n');
+      final doc = Delta()..insert('Hello world\n');
       final actual = rule.apply(doc, 11, '\n');
       expect(actual, isNotNull);
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(11)
         ..insert('\n');
       expect(actual, expected);
     });
 
     test('applies at the beginning of a document', () {
-      final doc = new Delta()..insert('\n', NotusAttribute.h1.toJson());
+      final doc = Delta()..insert('\n', NotusAttribute.h1.toJson());
       final actual = rule.apply(doc, 0, '\n');
       expect(actual, isNotNull);
-      final expected = new Delta()
+      final expected = Delta()
         ..insert('\n', NotusAttribute.h1.toJson())
         ..retain(1, NotusAttribute.heading.unset.toJson());
       expect(actual, expected);
     test('applies and keeps block style', () {
       final style = NotusAttribute.ul.toJson();
       style.addAll(NotusAttribute.h1.toJson());
-      final doc = new Delta()..insert('Hello world')..insert('\n', style);
+      final doc = Delta()..insert('Hello world')..insert('\n', style);
       final actual = rule.apply(doc, 11, '\n');
       expect(actual, isNotNull);
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(11)
         ..insert('\n', style)
         ..retain(1, NotusAttribute.heading.unset.toJson());
     });
 
     test('applies to a line in the middle of a document', () {
-      final doc = new Delta()
+      final doc = Delta()
         ..insert('Hello \nworld!\nMore lines here.')
         ..insert('\n', NotusAttribute.h2.toJson());
       final actual = rule.apply(doc, 30, '\n');
       expect(actual, isNotNull);
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(30)
         ..insert('\n', NotusAttribute.h2.toJson())
         ..retain(1, NotusAttribute.heading.unset.toJson());
   });
 
   group('$AutoExitBlockRule', () {
-    final rule = new AutoExitBlockRule();
+    final rule = AutoExitBlockRule();
 
     test('applies when line-break is inserted on empty line in a block', () {
       final ul = NotusAttribute.ul.toJson();
-      final doc = new Delta()
+      final doc = Delta()
         ..insert('Item 1')
         ..insert('\n', ul)
         ..insert('Item 2')
         ..insert('\n\n', ul);
       final actual = rule.apply(doc, 14, '\n');
       expect(actual, isNotNull);
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(14)
         ..retain(1, NotusAttribute.block.unset.toJson());
       expect(actual, expected);
 
     test('applies only on empty line', () {
       final ul = NotusAttribute.ul.toJson();
-      final doc = new Delta()..insert('Item 1')..insert('\n', ul);
+      final doc = Delta()..insert('Item 1')..insert('\n', ul);
       final actual = rule.apply(doc, 6, '\n');
       expect(actual, isNull);
     });
 
     test('applies at the beginning of a document', () {
       final ul = NotusAttribute.ul.toJson();
-      final doc = new Delta()..insert('\n', ul);
+      final doc = Delta()..insert('\n', ul);
       final actual = rule.apply(doc, 0, '\n');
       expect(actual, isNotNull);
-      final expected = new Delta()
-        ..retain(1, NotusAttribute.block.unset.toJson());
+      final expected = Delta()..retain(1, NotusAttribute.block.unset.toJson());
       expect(actual, expected);
     });
 
     test('ignores non-empty line at the beginning of a document', () {
       final ul = NotusAttribute.ul.toJson();
-      final doc = new Delta()..insert('Text\n', ul);
+      final doc = Delta()..insert('Text\n', ul);
       final actual = rule.apply(doc, 0, '\n');
       expect(actual, isNull);
     });
   });
 
   group('$PreserveInlineStylesRule', () {
-    final rule = new PreserveInlineStylesRule();
+    final rule = PreserveInlineStylesRule();
     test('apply', () {
-      final doc = new Delta()
+      final doc = Delta()
         ..insert('Doc with ')
         ..insert('bold', bold)
         ..insert(' text');
       final actual = rule.apply(doc, 13, 'er');
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(13)
         ..insert('er', bold);
       expect(expected, actual);
     });
 
     test('apply at the beginning of a document', () {
-      final doc = new Delta()..insert('Doc with ');
+      final doc = Delta()..insert('Doc with ');
       final actual = rule.apply(doc, 0, 'A ');
       expect(actual, isNull);
     });
   });
 
   group('$AutoFormatLinksRule', () {
-    final rule = new AutoFormatLinksRule();
+    final rule = AutoFormatLinksRule();
     final link = NotusAttribute.link.fromString('https://example.com').toJson();
 
     test('apply simple', () {
-      final doc = new Delta()..insert('Doc with link https://example.com');
+      final doc = Delta()..insert('Doc with link https://example.com');
       final actual = rule.apply(doc, 33, ' ');
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(14)
         ..retain(19, link)
         ..insert(' ');
     });
 
     test('applies only to insert of single space', () {
-      final doc = new Delta()..insert('Doc with link https://example.com');
+      final doc = Delta()..insert('Doc with link https://example.com');
       final actual = rule.apply(doc, 33, '/');
       expect(actual, isNull);
     });
 
     test('applies for links at the beginning of line', () {
-      final doc = new Delta()..insert('Doc with link\nhttps://example.com');
+      final doc = Delta()..insert('Doc with link\nhttps://example.com');
       final actual = rule.apply(doc, 33, ' ');
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(14)
         ..retain(19, link)
         ..insert(' ');
     });
 
     test('ignores if already formatted as link', () {
-      final doc = new Delta()
+      final doc = Delta()
         ..insert('Doc with link\n')
         ..insert('https://example.com', link);
       final actual = rule.apply(doc, 33, ' ');
   });
 
   group('$PreserveBlockStyleOnPasteRule', () {
-    final rule = new PreserveBlockStyleOnPasteRule();
+    final rule = PreserveBlockStyleOnPasteRule();
 
     test('applies in a block', () {
-      final doc = new Delta()
+      final doc = Delta()
         ..insert('One and two')
         ..insert('\n', ul)
         ..insert('Three')
         ..insert('\n', ul);
       final actual = rule.apply(doc, 8, 'also \n');
-      final expected = new Delta()
+      final expected = Delta()
         ..retain(8)
         ..insert('also ')
         ..insert('\n', ul);

packages/notus/test/heuristics_test.dart

 import 'package:test/test.dart';
 
 NotusDocument dartconfDoc() {
-  Delta delta = new Delta()..insert('DartConf\nLos Angeles\n');
-  return new NotusDocument.fromDelta(delta);
+  Delta delta = Delta()..insert('DartConf\nLos Angeles\n');
+  return NotusDocument.fromDelta(delta);
 }
 
 final ul = NotusAttribute.ul.toJson();
   group('$NotusHeuristics', () {
     test('ensures heuristics are applied', () {
       final doc = dartconfDoc();
-      final heuristics = new NotusHeuristics(
+      final heuristics = NotusHeuristics(
         formatRules: [],
         insertRules: [],
         deleteRules: [],

packages/notus/test/matchers.dart

 
 import 'package:test/test.dart';
 
-const isAssertionError = const TypeMatcher<AssertionError>();
+const isAssertionError = TypeMatcher<AssertionError>();
 
-const Matcher throwsAssertionError =
-    // ignore: deprecated_member_use
-    const Throws(isAssertionError);
+// ignore: deprecated_member_use
+const Matcher throwsAssertionError = Throws(isAssertionError);