Initial import of notus package

packages/notus/.gitignore

@@ -0,0 +1,12 @@
+.DS_Store
+.atom/
+.idea
+.vscode/
+.packages
+.dart_tool/
+packages
+pubspec.lock
+coverage/
+doc/api/
+test/.test_coverage.dart
+coverage/

packages/notus/.travis.yml

@@ -0,0 +1,15 @@
+language: dart
+
+dart:
+- dev
+
+before_script:
+- pub global activate coverage
+- pub global activate test_coverage
+
+script:
+- pub run test -r expanded
+- dartfmt -n --set-exit-if-changed lib/
+- dartanalyzer --fatal-infos --fatal-warnings .
+- pub global run test_coverage
+- bash <(curl -s https://codecov.io/bash)

packages/notus/AUTHORS

@@ -0,0 +1,6 @@
+# Below is a list of people and organizations that have contributed
+# to the Zefyr project. Names should be added to the list like so:
+#
+#   Name/Organization <email address>
+
+Memspace <hello@memspace.app>

packages/notus/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0
+
+*  Initial release.

packages/notus/LICENSE

@@ -0,0 +1,23 @@
+Copyright 2018, the Zefyr project authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the <organization> nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

packages/notus/README.md

@@ -0,0 +1,16 @@
+# [![Build Status](https://travis-ci.com/memspace/notus.svg?branch=master)](https://travis-ci.com/memspace/notus) [![codecov](https://codecov.io/gh/memspace/notus/branch/master/graph/badge.svg)](https://codecov.io/gh/memspace/notus)
+
+**Notus** is a rich text document model for [Zefyr][] project.
+
+Zefyr provides a lightweight and user friendly rich text editor for
+Flutter framework.
+
+For documentation, please see the main [Zefyr][] repository.
+
+> Zefyr is a Flutter package which means it can only be used inside of
+> Flutter projects. Notus is a **generic Dart package** and does not
+> depend on Flutter in any way. It can be used on any platform supported
+> by the Dart language: web, server (mac, linux, windows) and,
+> of course, mobile (android and ios).
+
+[Zefyr]: https://github.com/memspace/zefyr

packages/notus/analysis_options.yaml

@@ -0,0 +1,20 @@
+analyzer:
+  strong-mode: true
+  language:
+    enableSuperMixins: true
+
+# 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

packages/notus/lib/convert.dart

@@ -0,0 +1,13 @@
+// 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.
+
+/// Provides codecs to convert Notus documents to other formats.
+library notus.convert;
+
+import 'src/convert/markdown.dart';
+
+export 'src/convert/markdown.dart';
+
+/// Markdown codec for Notus documents.
+const NotusMarkdownCodec notusMarkdown = const NotusMarkdownCodec();

packages/notus/lib/notus.dart

@@ -0,0 +1,18 @@
+// 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.
+
+/// Rich text document model for Zefyr editor.
+library notus;
+
+export 'src/document.dart';
+export 'src/document/attributes.dart';
+export 'src/document/block.dart';
+export 'src/document/leaf.dart';
+export 'src/document/line.dart';
+export 'src/document/node.dart';
+export 'src/embed.dart';
+export 'src/heuristics.dart';
+export 'src/heuristics/delete_rules.dart';
+export 'src/heuristics/format_rules.dart';
+export 'src/heuristics/insert_rules.dart';

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

@@ -0,0 +1,213 @@
+// 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 'dart:convert';
+
+import 'package:quill_delta/quill_delta.dart';
+import 'package:notus/notus.dart';
+
+class NotusMarkdownCodec extends Codec<Delta, String> {
+  const NotusMarkdownCodec();
+
+  @override
+  Converter<String, Delta> get decoder =>
+      throw new UnimplementedError('Decoding is not implemented yet.');
+
+  @override
+  Converter<Delta, String> get encoder => new _NotusMarkdownEncoder();
+}
+
+class _NotusMarkdownEncoder extends Converter<Delta, String> {
+  static const kBold = '**';
+  static const kItalic = '_';
+  static final kSimpleBlocks = <NotusAttribute, String>{
+    NotusAttribute.bq: '> ',
+    NotusAttribute.ul: '* ',
+    NotusAttribute.ol: '1. ',
+  };
+
+  @override
+  String convert(Delta input) {
+    final iterator = new DeltaIterator(input);
+    final buffer = new StringBuffer();
+    final lineBuffer = new StringBuffer();
+    NotusAttribute<String> currentBlockStyle;
+    NotusStyle currentInlineStyle = new NotusStyle();
+    List<String> currentBlockLines = [];
+
+    void _handleBlock(NotusAttribute<String> blockStyle) {
+      if (currentBlockLines.isEmpty) {
+        return; // Empty block
+      }
+
+      if (blockStyle == null) {
+        buffer.write(currentBlockLines.join('\n\n'));
+        buffer.writeln();
+      } else if (blockStyle == NotusAttribute.code) {
+        _writeAttribute(buffer, blockStyle);
+        buffer.write(currentBlockLines.join('\n'));
+        _writeAttribute(buffer, blockStyle, close: true);
+        buffer.writeln();
+      } else {
+        for (var line in currentBlockLines) {
+          _writeBlockTag(buffer, blockStyle);
+          buffer.write(line);
+          buffer.writeln();
+        }
+      }
+      buffer.writeln();
+    }
+
+    void _handleSpan(String text, Map<String, dynamic> attributes) {
+      final style = NotusStyle.fromJson(attributes);
+      currentInlineStyle =
+          _writeInline(lineBuffer, text, style, currentInlineStyle);
+    }
+
+    void _handleLine(Map<String, dynamic> attributes) {
+      final style = NotusStyle.fromJson(attributes);
+      final lineBlock = style.get(NotusAttribute.block);
+      if (lineBlock == currentBlockStyle) {
+        currentBlockLines.add(_writeLine(lineBuffer.toString(), style));
+      } else {
+        _handleBlock(currentBlockStyle);
+        currentBlockLines.clear();
+        currentBlockLines.add(_writeLine(lineBuffer.toString(), style));
+
+        currentBlockStyle = lineBlock;
+      }
+      lineBuffer.clear();
+    }
+
+    while (iterator.hasNext) {
+      final op = iterator.next();
+      final lf = op.data.indexOf('\n');
+      if (lf == -1) {
+        _handleSpan(op.data, op.attributes);
+      } else {
+        StringBuffer span = new StringBuffer();
+        for (var i = 0; i < op.data.length; i++) {
+          if (op.data.codeUnitAt(i) == 0x0A) {
+            if (span.isNotEmpty) {
+              // Write the span if it's not empty.
+              _handleSpan(span.toString(), op.attributes);
+            }
+            // Close any open inline styles.
+            _handleSpan('', null);
+            _handleLine(op.attributes);
+            span.clear();
+          } else {
+            span.writeCharCode(op.data.codeUnitAt(i));
+          }
+        }
+        // Remaining span
+        if (span.isNotEmpty) {
+          _handleSpan(span.toString(), op.attributes);
+        }
+      }
+    }
+    _handleBlock(currentBlockStyle); // Close the last block
+    return buffer.toString();
+  }
+
+  String _writeLine(String text, NotusStyle style) {
+    StringBuffer buffer = new StringBuffer();
+    if (style.contains(NotusAttribute.heading)) {
+      _writeAttribute(buffer, style.get(NotusAttribute.heading));
+    }
+
+    // Write the text itself
+    buffer.write(text);
+    return buffer.toString();
+  }
+
+  String _trimRight(StringBuffer buffer) {
+    String text = buffer.toString();
+    if (!text.endsWith(' ')) return '';
+    final result = text.trimRight();
+    buffer.clear();
+    buffer.write(result);
+    return ' ' * (text.length - result.length);
+  }
+
+  NotusStyle _writeInline(StringBuffer buffer, String text, NotusStyle style,
+      NotusStyle currentStyle) {
+    // First close any current styles if needed
+    for (var value in currentStyle.values) {
+      if (value.scope == NotusAttributeScope.line) continue;
+      if (style.containsSame(value)) continue;
+      final padding = _trimRight(buffer);
+      _writeAttribute(buffer, value, close: true);
+      if (padding.isNotEmpty) buffer.write(padding);
+    }
+    // Now open any new styles.
+    for (var value in style.values) {
+      if (value.scope == NotusAttributeScope.line) continue;
+      if (currentStyle.containsSame(value)) continue;
+      final originalText = text;
+      text = text.trimLeft();
+      final padding = ' ' * (originalText.length - text.length);
+      if (padding.isNotEmpty) buffer.write(padding);
+      _writeAttribute(buffer, value);
+    }
+    // Write the text itself
+    buffer.write(text);
+    return style;
+  }
+
+  void _writeAttribute(StringBuffer buffer, NotusAttribute attribute,
+      {bool close: false}) {
+    if (attribute == NotusAttribute.bold) {
+      _writeBoldTag(buffer);
+    } else if (attribute == NotusAttribute.italic) {
+      _writeItalicTag(buffer);
+    } else if (attribute.key == NotusAttribute.link.key) {
+      _writeLinkTag(buffer, attribute, close: close);
+    } else if (attribute.key == NotusAttribute.heading.key) {
+      _writeHeadingTag(buffer, attribute);
+    } else if (attribute.key == NotusAttribute.block.key) {
+      _writeBlockTag(buffer, attribute, close: close);
+    } else {
+      throw new ArgumentError('Cannot handle $attribute');
+    }
+  }
+
+  void _writeBoldTag(StringBuffer buffer) {
+    buffer.write(kBold);
+  }
+
+  void _writeItalicTag(StringBuffer buffer) {
+    buffer.write(kItalic);
+  }
+
+  void _writeLinkTag(StringBuffer buffer, NotusAttribute<String> link,
+      {bool close: false}) {
+    if (close) {
+      buffer.write('](${link.value})');
+    } else {
+      buffer.write('[');
+    }
+  }
+
+  void _writeHeadingTag(StringBuffer buffer, NotusAttribute<int> heading) {
+    var level = heading.value;
+    buffer.write('#' * level + ' ');
+  }
+
+  void _writeBlockTag(StringBuffer buffer, NotusAttribute<String> block,
+      {bool close: false}) {
+    if (block == NotusAttribute.code) {
+      if (close) {
+        buffer.write('\n```');
+      } else {
+        buffer.write('```\n');
+      }
+    } else {
+      if (close) return; // no close tag needed for simple blocks.
+
+      final tag = kSimpleBlocks[block];
+      buffer.write(tag);
+    }
+  }
+}

packages/notus/lib/src/document.dart

@@ -0,0 +1,303 @@
+// 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 'dart:async';
+
+import 'package:quill_delta/quill_delta.dart';
+
+import 'document/attributes.dart';
+import 'document/block.dart';
+import 'document/leaf.dart';
+import 'document/line.dart';
+import 'document/node.dart';
+import 'embed.dart';
+import 'heuristics.dart';
+
+/// Source of a [NotusChange].
+enum ChangeSource {
+  /// Change originated from a local action. Typically triggered by user.
+  local,
+
+  /// Change originated from a remote action.
+  remote,
+}
+
+/// Represents a change in a [NotusDocument].
+class NotusChange {
+  NotusChange(this.before, this.change, this.source);
+
+  /// Document state before [change].
+  final Delta before;
+
+  /// Change delta applied to the document.
+  final Delta change;
+
+  /// The source of this change.
+  final ChangeSource source;
+}
+
+/// A rich text document.
+class NotusDocument {
+  /// Creates new empty Notus document.
+  NotusDocument()
+      : _heuristics = NotusHeuristics.fallback,
+        _delta = new Delta()..insert('\n') {
+    _loadDocument(_delta);
+  }
+
+  NotusDocument.fromJson(dynamic data)
+      : _heuristics = NotusHeuristics.fallback,
+        _delta = Delta.fromJson(data) {
+    _loadDocument(_delta);
+  }
+
+  NotusDocument.fromDelta(Delta delta)
+      : assert(delta != null),
+        _heuristics = NotusHeuristics.fallback,
+        _delta = delta {
+    _loadDocument(_delta);
+  }
+
+  final NotusHeuristics _heuristics;
+
+  /// The root node of this document tree.
+  RootNode get root => _root;
+  final RootNode _root = new RootNode();
+
+  /// Length of this document.
+  int get length => _root.length;
+
+  /// Stream of [NotusChange]s applied to this document.
+  Stream<NotusChange> get changes => _controller.stream;
+
+  final StreamController<NotusChange> _controller =
+      new StreamController.broadcast();
+
+  /// Returns contents of this document as [Delta].
+  Delta toDelta() => new Delta.from(_delta);
+  Delta _delta;
+
+  /// Returns plain text representation of this document.
+  String toPlainText() => _delta.toList().map((op) => op.data).join();
+
+  dynamic toJson() {
+    return _delta.toJson();
+  }
+
+  /// Returns `true` if this document and associated stream of [changes]
+  /// is closed.
+  ///
+  /// Modifying a closed document is not allowed.
+  bool get isClosed => _controller.isClosed;
+
+  /// Closes [changes] stream.
+  void close() {
+    _controller.close();
+  }
+
+  /// Inserts [value] in this document at specified [index]. Value must be a
+  /// [String] or an instance of [NotusEmbed].
+  ///
+  /// This method applies heuristic rules before modifying this document and
+  /// produces a [NotusChange] with source set to [ChangeSource.local].
+  ///
+  /// Returns an instance of [Delta] actually composed into this document.
+  Delta insert(int index, dynamic value) {
+    assert(index >= 0);
+    assert(value is String || value is NotusEmbed,
+        'Value must be a string or a NotusEmbed.');
+    Delta change;
+    if (value is String) {
+      assert(value.isNotEmpty);
+      value = _sanitizeString(value);
+      if (value.isEmpty) return new Delta();
+      change = _heuristics.applyInsertRules(this, index, value);
+    } else {
+      NotusEmbed embed = value;
+      change = _heuristics.applyEmbedRules(this, index, embed.attribute);
+    }
+    compose(change, ChangeSource.local);
+    return change;
+  }
+
+  /// Deletes [length] of characters from this document starting at [index].
+  ///
+  /// This method applies heuristic rules before modifying this document and
+  /// produces a [NotusChange] with source set to [ChangeSource.local].
+  ///
+  /// Returns an instance of [Delta] actually composed into this document.
+  Delta delete(int index, int length) {
+    assert(index >= 0 && length > 0);
+    // TODO: need a heuristic rule to ensure last line-break.
+    final change = _heuristics.applyDeleteRules(this, index, length);
+    compose(change, ChangeSource.local);
+    return change;
+  }
+
+  /// Replaces [length] of characters starting at [index] with [value]. Value
+  /// must be a [String] or an instance of [NotusEmbed].
+  ///
+  /// This method applies heuristic rules before modifying this document and
+  /// produces a [NotusChange] with source set to [ChangeSource.local].
+  ///
+  /// Returns an instance of [Delta] actually composed into this document.
+  Delta replace(int index, int length, dynamic value) {
+    assert(index >= 0 && (value.isNotEmpty || length > 0),
+        'With index $index, length $length and text "$value"');
+    assert(value is String || value is NotusEmbed,
+        'Value must be a string or a NotusEmbed.');
+
+    final hasInsert =
+        (value is NotusEmbed || (value is String && value.isNotEmpty));
+    Delta delta = new Delta();
+
+    // We have to compose before applying delete rules
+    // Otherwise delete would be operating on stale document snapshot.
+    if (hasInsert) {
+      delta = insert(index, value);
+      index = delta.transformPosition(index);
+    }
+
+    if (length > 0) {
+      final deleteDelta = delete(index, length);
+      delta = delta.compose(deleteDelta);
+    }
+    return delta;
+  }
+
+  /// Formats portion of this document with specified [attribute].
+  ///
+  /// Applies heuristic rules before modifying this document and
+  /// produces a [NotusChange] with source set to [ChangeSource.local].
+  ///
+  /// Returns an instance of [Delta] actually composed into this document.
+  /// The returned [Delta] may be empty in which case this document remains
+  /// unchanged and no [NotusChange] is published to [changes] stream.
+  Delta format(int index, int length, NotusAttribute attribute) {
+    assert(index >= 0 && length >= 0 && attribute != null);
+    Delta change;
+    if (attribute is EmbedAttribute) {
+      assert(length == 1);
+      change = _heuristics.applyEmbedRules(this, index, attribute);
+    } else {
+      change = _heuristics.applyFormatRules(this, index, length, attribute);
+    }
+    if (change.isNotEmpty) {
+      compose(change, ChangeSource.local);
+    }
+    return change;
+  }
+
+  /// Returns style of specified text range.
+  ///
+  /// Only attributes applied to all characters within this range are
+  /// included in the result. Inline and block level attributes are
+  /// handled separately, e.g.:
+  ///
+  /// - block attribute X is included in the result only if it exists for
+  ///   every line within this range (partially included lines are counted).
+  /// - 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 index, int length) {
+    var result = lookupLine(index);
+    LineNode line = result.node;
+    return line.collectStyle(result.offset, length);
+  }
+
+  /// Returns [LineNode] located at specified character [offset].
+  LookupResult lookupLine(int offset) {
+    // TODO: prevent user from moving caret after last line-break.
+    var result = _root.lookup(offset, inclusive: true);
+    if (result.node is LineNode) return result;
+    BlockNode block = result.node;
+    return block.lookup(result.offset, inclusive: true);
+  }
+
+  /// Composes [change] into this document.
+  ///
+  /// Use this method with caution as it does not apply heuristic rules to the
+  /// [change].
+  ///
+  /// It is callers responsibility to ensure that the [change] conforms to
+  /// the document model semantics and can be composed with the current state
+  /// of this document.
+  ///
+  /// In case the [change] is invalid, behavior of this method is unspecified.
+  void compose(Delta change, ChangeSource source) {
+    _checkMutable();
+    change.trim();
+    assert(change.isNotEmpty);
+
+    int offset = 0;
+    final before = toDelta();
+    for (final Operation op in change.toList()) {
+      final attributes =
+          op.attributes != null ? NotusStyle.fromJson(op.attributes) : null;
+      if (op.isInsert) {
+        _root.insert(offset, op.data, attributes);
+      } else if (op.isDelete) {
+        _root.delete(offset, op.length);
+      } else if (op.attributes != null) {
+        _root.retain(offset, op.length, attributes);
+      }
+      if (!op.isDelete) offset += op.length;
+    }
+    _delta = _delta.compose(change);
+
+    if (_delta != _root.toDelta()) {
+      throw new StateError('Compose produced inconsistent results. '
+          'This is likely due to a bug in the library.');
+    }
+    _controller.add(new NotusChange(before, change, source));
+  }
+
+  //
+  // Overridden members
+  //
+  @override
+  String toString() => _root.toString();
+
+  //
+  // Private members
+  //
+
+  void _checkMutable() {
+    assert(!_controller.isClosed,
+        'Cannot modify Notus document after it was closed.');
+  }
+
+  String _sanitizeString(String value) {
+    if (value.contains(EmbedNode.kPlainTextPlaceholder)) {
+      return value.replaceAll(EmbedNode.kPlainTextPlaceholder, '');
+    } else {
+      return value;
+    }
+  }
+
+  /// Loads [document] delta into this document.
+  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()) {
+      final style =
+          op.attributes != null ? NotusStyle.fromJson(op.attributes) : null;
+      if (op.isInsert) {
+        _root.insert(offset, op.data, style);
+      } else {
+        throw new ArgumentError.value(doc,
+            "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;
+    if (node is LineNode &&
+        node.parent is! BlockNode &&
+        node.style.isEmpty &&
+        _root.childCount > 1) {
+      _root.remove(node);
+    }
+  }
+}

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

@@ -0,0 +1,451 @@
+// 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:collection/collection.dart';
+import 'package:quiver_hashcode/hashcode.dart';
+
+/// Scope of a style attribute, defines context in which an attribute can be
+/// applied.
+enum NotusAttributeScope {
+  /// Inline-scoped attributes are applicable to all characters within a line.
+  ///
+  /// Inline attributes cannot be applied to the line itself.
+  inline,
+
+  /// Line-scoped attributes are only applicable to a line of text as a whole.
+  ///
+  /// Line attributes do not have any effect on any character within the line.
+  line,
+}
+
+/// Interface for objects which provide access to an attribute key.
+///
+/// Implemented by [NotusAttribute] and [NotusAttributeBuilder].
+abstract class NotusAttributeKey<T> {
+  /// Unique key of this attribute.
+  String get key;
+}
+
+/// Builder for style attributes.
+///
+/// Useful in scenarios when an attribute value is not known upfront, for
+/// instance, link attribute.
+///
+/// See also:
+///   * [LinkAttributeBuilder]
+///   * [BlockAttributeBuilder]
+///   * [HeadingAttributeBuilder]
+abstract class NotusAttributeBuilder<T> implements NotusAttributeKey<T> {
+  const NotusAttributeBuilder._(this.key, this.scope);
+
+  final String key;
+  final NotusAttributeScope scope;
+  NotusAttribute<T> get unset => new NotusAttribute<T>._(key, scope, null);
+  NotusAttribute<T> withValue(T value) =>
+      new NotusAttribute<T>._(key, scope, value);
+}
+
+/// Style attribute applicable to a segment of a Notus document.
+///
+/// All supported attributes are available via static fields on this class.
+/// Here is an example of applying styles to a document:
+///
+///     void makeItPretty(Notus document) {
+///       // Format 5 characters at position 0 as bold
+///       document.format(0, 5, NotusAttribute.bold);
+///       // Similarly for italic
+///       document.format(0, 5, NotusAttribute.italic);
+///       // Format first line as a heading (h1)
+///       // Note that there is no need to specify character range of the whole
+///       // line. Simply set index position to anywhere within the line and
+///       // length to 0.
+///       document.format(0, 0, NotusAttribute.h1);
+///     }
+///
+/// List of supported attributes:
+///
+///   * [NotusAttribute.bold]
+///   * [NotusAttribute.italic]
+///   * [NotusAttribute.link]
+///   * [NotusAttribute.heading]
+///   * [NotusAttribute.block]
+class NotusAttribute<T> implements NotusAttributeBuilder<T> {
+  static final Map<String, NotusAttributeBuilder> _registry = {
+    NotusAttribute.bold.key: NotusAttribute.bold,
+    NotusAttribute.italic.key: NotusAttribute.italic,
+    NotusAttribute.link.key: NotusAttribute.link,
+    NotusAttribute.heading.key: NotusAttribute.heading,
+    NotusAttribute.block.key: NotusAttribute.block,
+    NotusAttribute.embed.key: NotusAttribute.embed,
+  };
+
+  // Inline attributes
+
+  /// Bold style attribute.
+  static const bold = const _BoldAttribute();
+
+  /// Italic style attribute.
+  static const italic = const _ItalicAttribute();
+
+  /// Link style attribute.
+  static const link = const LinkAttributeBuilder._();
+
+  // Line attributes
+
+  /// Heading style attribute.
+  static const heading = const HeadingAttributeBuilder._();
+
+  /// Alias for [NotusAttribute.heading.level1].
+  static NotusAttribute<int> get h1 => heading.level1;
+
+  /// Alias for [NotusAttribute.heading.level2].
+  static NotusAttribute<int> get h2 => heading.level2;
+
+  /// Alias for [NotusAttribute.heading.level3].
+  static NotusAttribute<int> get h3 => heading.level3;
+
+  /// Block attribute
+  static const block = const BlockAttributeBuilder._();
+
+  /// Alias for [NotusAttribute.block.bulletList].
+  static NotusAttribute<String> get ul => block.bulletList;
+
+  /// Alias for [NotusAttribute.block.numberList].
+  static NotusAttribute<String> get ol => block.numberList;
+
+  /// Alias for [NotusAttribute.block.quote].
+  static NotusAttribute<String> get bq => block.quote;
+
+  /// Alias for [NotusAttribute.block.code].
+  static NotusAttribute<String> get code => block.code;
+
+  /// Embed style attribute.
+  static const embed = const EmbedAttributeBuilder._();
+
+  factory NotusAttribute._fromKeyValue(String key, T value) {
+    if (!_registry.containsKey(key))
+      throw new ArgumentError.value(
+          key, 'No attribute with key "$key" registered.');
+    final builder = _registry[key];
+    return builder.withValue(value);
+  }
+
+  const NotusAttribute._(this.key, this.scope, this.value);
+
+  /// Unique key of this attribute.
+  final String key;
+
+  /// Scope of this attribute.
+  final NotusAttributeScope scope;
+
+  /// Value of this attribute.
+  ///
+  /// If value is `null` then this attribute represents a transient action
+  /// of removing associated style and is never persisted in a resulting
+  /// document.
+  ///
+  /// See also [unset], [NotusStyle.merge] and [NotusStyle.put]
+  /// for details.
+  final T value;
+
+  /// Returns special "unset" version of this attribute.
+  ///
+  /// Unset attribute's [value] is always `null`.
+  ///
+  /// When composed into a rich text document, unset attributes remove
+  /// associated style.
+  NotusAttribute<T> get unset => new NotusAttribute<T>._(key, scope, null);
+
+  /// Returns `true` if this attribute is an unset attribute.
+  bool get isUnset => value == null;
+
+  /// Returns `true` if this is an inline-scoped attribute.
+  bool get isInline => scope == NotusAttributeScope.inline;
+
+  NotusAttribute<T> withValue(T value) =>
+      new NotusAttribute<T>._(key, scope, value);
+
+  @override
+  bool operator ==(other) {
+    if (identical(this, other)) return true;
+    if (other is! NotusAttribute<T>) return false;
+    NotusAttribute<T> typedOther = other;
+    return key == typedOther.key &&
+        scope == typedOther.scope &&
+        value == typedOther.value;
+  }
+
+  @override
+  int get hashCode => hash3(key, scope, value);
+
+  @override
+  String toString() => '$key: $value';
+
+  Map<String, dynamic> toJson() => <String, dynamic>{key: value};
+}
+
+/// Collection of style attributes.
+class NotusStyle {
+  NotusStyle._(this._data);
+
+  final Map<String, NotusAttribute> _data;
+
+  static NotusStyle fromJson(Map data) {
+    if (data == null) return new NotusStyle();
+
+    final result = data.map((key, value) {
+      var attr = new NotusAttribute._fromKeyValue(key, value);
+      return new MapEntry<String, NotusAttribute>(key, attr);
+    });
+    return new NotusStyle._(result);
+  }
+
+  NotusStyle() : _data = new Map<String, NotusAttribute>();
+
+  /// Returns `true` if this attribute set is empty.
+  bool get isEmpty => _data.isEmpty;
+
+  /// Returns `true` if this attribute set is note empty.
+  bool get isNotEmpty => _data.isNotEmpty;
+
+  /// Returns `true` if this style is not empty and contains only inline-scoped
+  /// attributes and is not empty.
+  bool get isInline => isNotEmpty && values.every((item) => item.isInline);
+
+  /// Checks that this style has only one attribute, and returns that attribute.
+  NotusAttribute get single => _data.values.single;
+
+  /// Returns `true` if attribute with [key] is present in this set.
+  ///
+  /// Only checks for presence of specified [key] regardless of the associated
+  /// value.
+  ///
+  /// To test if this set contains an attribute with specific value consider
+  /// using [containsSame].
+  bool contains(NotusAttributeKey key) => _data.containsKey(key.key);
+
+  /// Returns `true` if this set contains attribute with the same value as
+  /// [attribute].
+  bool containsSame(NotusAttribute attribute) {
+    assert(attribute != null);
+    return get(attribute) == attribute;
+  }
+
+  /// Returns value of specified attribute [key] in this set.
+  T value<T>(NotusAttributeKey<T> key) => get(key).value;
+
+  /// Returns [NotusAttribute] from this set by specified [key].
+  NotusAttribute<T> get<T>(NotusAttributeKey<T> key) =>
+      _data[key.key] as NotusAttribute<T>;
+
+  /// Returns collection of all attribute keys in this set.
+  Iterable<String> get keys => _data.keys;
+
+  /// Returns collection of all attributes in this set.
+  Iterable<NotusAttribute> get values => _data.values;
+
+  /// 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);
+    result[attribute.key] = attribute;
+    return new NotusStyle._(result);
+  }
+
+  /// Merges this attribute set with [attribute] and returns result as a new
+  /// attribute set.
+  ///
+  /// Performs compaction if [attribute] is an "unset" value, e.g. removes
+  /// corresponding attribute from this set completely.
+  ///
+  /// 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);
+    if (attribute.isUnset) {
+      merged.remove(attribute.key);
+    } else {
+      merged[attribute.key] = attribute;
+    }
+    return new 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);
+    for (var value in other.values) {
+      result = result.merge(value);
+    }
+    return result;
+  }
+
+  /// 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);
+    attributes.map((item) => item.key).forEach(merged.remove);
+    return new NotusStyle._(merged);
+  }
+
+  /// Returns JSON-serializable representation of this style.
+  Map<String, dynamic> toJson() => _data.isEmpty
+      ? null
+      : _data.map(
+          (_, value) => new MapEntry<String, dynamic>(value.key, value.value));
+
+  @override
+  bool operator ==(other) {
+    if (identical(this, other)) return true;
+    if (other is! NotusStyle) return false;
+    NotusStyle typedOther = other;
+    final eq = const MapEquality<String, NotusAttribute>();
+    return eq.equals(_data, typedOther._data);
+  }
+
+  @override
+  int get hashCode {
+    final hashes = _data.entries.map((entry) => hash2(entry.key, entry.value));
+    return hashObjects(hashes);
+  }
+
+  @override
+  String toString() => "{${_data.values.join(', ')}}";
+}
+
+/// Applies bold style to a text segment.
+class _BoldAttribute extends NotusAttribute<bool> {
+  const _BoldAttribute() : super._('b', NotusAttributeScope.inline, true);
+}
+
+/// Applies italic style to a text segment.
+class _ItalicAttribute extends NotusAttribute<bool> {
+  const _ItalicAttribute() : super._('i', NotusAttributeScope.inline, true);
+}
+
+/// Builder for link attribute values.
+///
+/// There is no need to use this class directly, consider using
+/// [NotusAttribute.link] instead.
+class LinkAttributeBuilder extends NotusAttributeBuilder<String> {
+  static const _kLink = 'a';
+  const LinkAttributeBuilder._() : super._(_kLink, NotusAttributeScope.inline);
+
+  /// Creates a link attribute with specified link [value].
+  NotusAttribute<String> fromString(String value) =>
+      new NotusAttribute<String>._(key, scope, value);
+}
+
+/// Builder for heading attribute styles.
+///
+/// There is no need to use this class directly, consider using
+/// [NotusAttribute.heading] instead.
+class HeadingAttributeBuilder extends NotusAttributeBuilder<int> {
+  static const _kHeading = 'heading';
+  const HeadingAttributeBuilder._()
+      : super._(_kHeading, NotusAttributeScope.line);
+
+  /// Level 1 heading, equivalent of `H1` in HTML.
+  NotusAttribute<int> get level1 => new NotusAttribute<int>._(key, scope, 1);
+
+  /// Level 2 heading, equivalent of `H2` in HTML.
+  NotusAttribute<int> get level2 => new NotusAttribute<int>._(key, scope, 2);
+
+  /// Level 3 heading, equivalent of `H3` in HTML.
+  NotusAttribute<int> get level3 => new NotusAttribute<int>._(key, scope, 3);
+}
+
+/// Builder for block attribute styles (number/bullet lists, code and quote).
+///
+/// There is no need to use this class directly, consider using
+/// [NotusAttribute.block] instead.
+class BlockAttributeBuilder extends NotusAttributeBuilder<String> {
+  static const _kBlock = 'block';
+  const BlockAttributeBuilder._() : super._(_kBlock, NotusAttributeScope.line);
+
+  /// Formats a block of lines as a bullet list.
+  NotusAttribute<String> get bulletList =>
+      new NotusAttribute<String>._(key, scope, 'ul');
+
+  /// Formats a block of lines as a number list.
+  NotusAttribute<String> get numberList =>
+      new 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');
+
+  /// Formats a block of lines as a quote.
+  NotusAttribute<String> get quote =>
+      new NotusAttribute<String>._(key, scope, 'quote');
+}
+
+class EmbedAttributeBuilder
+    extends NotusAttributeBuilder<Map<String, dynamic>> {
+  const EmbedAttributeBuilder._()
+      : super._(EmbedAttribute._kEmbed, NotusAttributeScope.inline);
+
+  NotusAttribute<Map<String, dynamic>> get horizontalRule =>
+      EmbedAttribute.horizontalRule();
+
+  NotusAttribute<Map<String, dynamic>> image(String source) =>
+      EmbedAttribute.image(source);
+
+  @override
+  NotusAttribute<Map<String, dynamic>> get unset => EmbedAttribute._(null);
+
+  NotusAttribute<Map<String, dynamic>> withValue(Map<String, dynamic> value) =>
+      EmbedAttribute._(value);
+}
+
+/// Type of embedded content.
+enum EmbedType { horizontalRule, image }
+
+class EmbedAttribute extends NotusAttribute<Map<String, dynamic>> {
+  static const _kValueEquality = const MapEquality<String, dynamic>();
+  static const _kEmbed = 'embed';
+  static const _kHorizontalRuleEmbed = 'hr';
+  static const _kImageEmbed = 'image';
+
+  EmbedAttribute._(Map<String, dynamic> value)
+      : super._(_kEmbed, NotusAttributeScope.inline, value);
+
+  EmbedAttribute.horizontalRule()
+      : this._(<String, dynamic>{'type': _kHorizontalRuleEmbed});
+
+  EmbedAttribute.image(String source)
+      : this._(<String, dynamic>{'type': _kImageEmbed, 'source': source});
+
+  /// Type of this embed.
+  EmbedType get type {
+    if (value['type'] == _kHorizontalRuleEmbed) return EmbedType.horizontalRule;
+    if (value['type'] == _kImageEmbed) return EmbedType.image;
+    assert(false, 'Unknown embed attribute value $value.');
+    return null;
+  }
+
+  @override
+  NotusAttribute<Map<String, dynamic>> get unset => new EmbedAttribute._(null);
+
+  @override
+  bool operator ==(other) {
+    if (identical(this, other)) return true;
+    if (other is! EmbedAttribute) return false;
+    EmbedAttribute typedOther = other;
+    return key == typedOther.key &&
+        scope == typedOther.scope &&
+        _kValueEquality.equals(value, typedOther.value);
+  }
+
+  @override
+  int get hashCode {
+    final objects = [key, scope];
+    if (value != null) {
+      final valueHashes =
+          value.entries.map((entry) => hash2(entry.key, entry.value));
+      objects.addAll(valueHashes);
+    } else {
+      objects.add(value);
+    }
+    return hashObjects(objects);
+  }
+}

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

@@ -0,0 +1,100 @@
+// 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:quill_delta/quill_delta.dart';
+
+import 'attributes.dart';
+import 'line.dart';
+import 'node.dart';
+
+/// A block represents a group of adjacent [LineNode]s with the same block
+/// style.
+///
+/// Block examples: lists, quotes, code snippets.
+class BlockNode extends ContainerNode<LineNode>
+    with StyledNodeMixin
+    implements StyledNode {
+  /// Creates new unmounted [BlockNode] with the same attributes.
+  BlockNode clone() {
+    final node = new BlockNode();
+    node.applyStyle(style);
+    return node;
+  }
+
+  /// Unwraps [line] from this block.
+  void unwrapLine(LineNode line) {
+    assert(children.contains(line));
+
+    if (line.isFirst) {
+      line.unlink();
+      insertBefore(line);
+    } else if (line.isLast) {
+      line.unlink();
+      insertAfter(line);
+    } else {
+      /// need to split this block into two as [line] is in the middle.
+      BlockNode before = clone();
+      insertBefore(before);
+
+      LineNode child = this.first;
+      while (child != line) {
+        child.unlink();
+        before.add(child);
+        child = this.first;
+      }
+      line.unlink();
+      insertBefore(line);
+    }
+    optimize();
+  }
+
+  @override
+  LineNode get defaultChild => new 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));
+  }
+
+  @override
+  String toString() {
+    final block = style.value(NotusAttribute.block);
+    final buffer = new StringBuffer('§ {$block}\n');
+    for (var child in children) {
+      final tree = child.isLast ? '└' : '├';
+      buffer.write('  $tree $child');
+      if (!child.isLast) buffer.writeln();
+    }
+    return buffer.toString();
+  }
+
+  @override
+  void optimize() {
+    if (isEmpty) {
+      Node sibling = this.previous;
+      unlink();
+      if (sibling != null) sibling.optimize();
+      return;
+    }
+
+    var block = this;
+    if (!block.isFirst && block.previous is BlockNode) {
+      BlockNode prev = block.previous;
+      if (prev.style == block.style) {
+        block.moveChildren(prev);
+        block.unlink();
+        block = prev;
+      }
+    }
+    if (!block.isLast && block.next is BlockNode) {
+      BlockNode nextBlock = block.next;
+      if (nextBlock.style == block.style) {
+        nextBlock.moveChildren(block);
+        nextBlock.unlink();
+      }
+    }
+  }
+}

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

@@ -0,0 +1,254 @@
+// 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 'dart:math' as math;
+
+import 'package:quill_delta/quill_delta.dart';
+
+import 'attributes.dart';
+import 'line.dart';
+import 'node.dart';
+
+/// A leaf node in Notus document tree.
+abstract class LeafNode extends Node
+    with StyledNodeMixin
+    implements StyledNode {
+  /// Creates a new [LeafNode] with specified [value].
+  LeafNode._([String value = ''])
+      : assert(value != null && !value.contains('\n')),
+        _value = value;
+
+  factory LeafNode([String value = '']) {
+    LeafNode node;
+    if (value == kZeroWidthSpace) {
+      // Zero-width space is reserved for embed nodes.
+      node = new 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);
+    }
+    return node;
+  }
+
+  /// Plain-text value of this node.
+  String get value => _value;
+  String _value;
+
+  /// Splits this leaf node at [index] and returns new node.
+  ///
+  /// If this is the last node in its list and [index] equals this node's
+  /// length then this method returns `null` as there is nothing left to split.
+  /// If there is another leaf node after this one and [index] equals this
+  /// node's length then the next leaf node is returned.
+  ///
+  /// If [index] equals to `0` then this node itself is returned unchanged.
+  ///
+  /// In case a new node is actually split from this one, it inherits this
+  /// node's style.
+  LeafNode splitAt(int index) {
+    assert(index >= 0 && index <= length);
+    if (index == 0) return this;
+    if (index == length && isLast) return null;
+    if (index == length && !isLast) return next;
+
+    String text = _value;
+    _value = text.substring(0, index);
+    final split = new LeafNode(text.substring(index));
+    split.applyStyle(style);
+    insertAfter(split);
+    return split;
+  }
+
+  /// Cuts a leaf node from [index] to the end of this node and returns new node
+  /// in detached state (e.g. [mounted] returns `false`).
+  ///
+  /// Splitting logic is identical to one described in [splitAt], meaning this
+  /// method may return `null`.
+  LeafNode cutAt(int index) {
+    assert(index >= 0 && index <= length);
+    LeafNode cut = splitAt(index);
+    cut?.unlink();
+    return cut;
+  }
+
+  /// Isolates a new leaf node starting at [index] with specified [length].
+  ///
+  /// Splitting logic is identical to one described in [splitAt], with one
+  /// exception that it is required for [index] to always be less than this
+  /// node's length. As a result this method always returns a [LeafNode]
+  /// instance. Note that returned node may still be the same as this node
+  /// if provided [index] is `0`.
+  LeafNode isolate(int index, int length) {
+    assert(
+        index >= 0 && index < this.length && (index + length <= this.length),
+        'Index or length is out of bounds. Index: $index, length: $length. '
+        'Actual node length: ${this.length}.');
+    // Since `index < this.length` (guarded by assert) below line
+    // always returns a new node.
+    LeafNode target = splitAt(index);
+    target.splitAt(length);
+    return target;
+  }
+
+  /// Formats this node and optimizes it with adjacent leaf nodes if needed.
+  void formatAndOptimize(NotusStyle style) {
+    if (style != null && style.isNotEmpty) {
+      applyStyle(style);
+    }
+    optimize();
+  }
+
+  @override
+  void applyStyle(NotusStyle value) {
+    assert(value != null && (value.isInline || value.isEmpty),
+        "Style cannot be applied to this leaf node: $value");
+    assert(() {
+      if (value.contains(NotusAttribute.embed)) {
+        if (value.get(NotusAttribute.embed) == NotusAttribute.embed.unset) {
+          throw 'Unsetting embed attribute is not allowed. '
+              'This operation means that the embed itself must be deleted from the document. '
+              'Make sure there is FormatEmbedsRule in your heuristics registry, '
+              'which is responsible for handling this scenario.';
+        }
+        if (this is! EmbedNode) {
+          throw 'Embed style can only be applied to an EmbedNode.';
+        }
+      }
+      return true;
+    }());
+
+    super.applyStyle(value);
+  }
+
+  @override
+  LineNode get parent => super.parent;
+
+  @override
+  int get length => _value.length;
+
+  @override
+  Delta toDelta() {
+    return new Delta()..insert(_value, style.toJson());
+  }
+
+  @override
+  String toPlainText() => _value;
+
+  @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);
+    if (index == length) {
+      insertAfter(node);
+    } else {
+      splitAt(index).insertBefore(node);
+    }
+    node.formatAndOptimize(style);
+  }
+
+  @override
+  void retain(int index, int length, NotusStyle style) {
+    if (style == null) return;
+
+    final local = math.min(this.length - index, length);
+    final node = isolate(index, local);
+
+    int remaining = length - local;
+    if (remaining > 0) {
+      assert(node.next != null);
+      node.next.retain(0, remaining, style);
+    }
+    // Optimize at the very end
+    node.formatAndOptimize(style);
+  }
+
+  @override
+  void delete(int index, int length) {
+    assert(index < this.length);
+
+    final local = math.min(this.length - index, length);
+    final target = isolate(index, local);
+    // Memorize siblings before un-linking.
+    final needsOptimize = target.previous;
+    final actualNext = target.next;
+    target.unlink();
+
+    int remaining = length - local;
+    if (remaining > 0) {
+      assert(actualNext != null);
+      actualNext.delete(0, remaining);
+    }
+
+    if (needsOptimize != null) needsOptimize.optimize();
+  }
+
+  @override
+  String toString() {
+    final keys = style.keys.toList(growable: false)..sort();
+    String 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;
+    if (!node.isFirst) {
+      LeafNode mergeWith = node.previous;
+      if (mergeWith.style == node.style) {
+        mergeWith._value += node.value;
+        node.unlink();
+        node = mergeWith;
+      }
+    }
+    if (!node.isLast) {
+      LeafNode mergeWith = node.next;
+      if (mergeWith.style == node.style) {
+        node._value += mergeWith._value;
+        mergeWith.unlink();
+      }
+    }
+  }
+}
+
+/// A span of formatted text within a line in a Notus document.
+///
+/// TextNode is a leaf node of a document tree.
+///
+/// Parent of a text node is always a [LineNode], and as a consequence text
+/// node's [value] cannot contain any line-break characters.
+///
+/// See also:
+///
+///   * [LineNode], a node representing a line of text.
+///   * [BlockNode], a node representing a group of lines.
+class TextNode extends LeafNode {
+  TextNode([String content = '']) : super._(content);
+}
+
+final kZeroWidthSpace = new String.fromCharCode(0x200b);
+
+/// An embed node inside of a line in a Notus document.
+///
+/// Embed node is a leaf node similar to [TextNode]. It represents an
+/// arbitrary piece of non-text content embedded into a document, such as,
+/// image, horizontal rule, video, or any other object with defined structure,
+/// like tweet, for instance.
+///
+/// Embed node's length is always `1` character and it is represented with
+/// zero-width space in the document text.
+///
+/// Any inline style can be applied to an embed, however this does not
+/// necessarily mean the embed will look according to that style. For instance,
+/// 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);
+
+  EmbedNode() : super._(kPlainTextPlaceholder);
+}

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

@@ -0,0 +1,320 @@
+// 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 'dart:math' as math;
+
+import 'package:quill_delta/quill_delta.dart';
+
+import 'attributes.dart';
+import 'block.dart';
+import 'leaf.dart';
+import 'node.dart';
+
+/// A line of text in a Notus document.
+///
+/// LineNode serves as a container for [LeafNode]s, like [TextNode] and
+/// [ImageNode].
+class LineNode extends ContainerNode<LeafNode>
+    with StyledNodeMixin
+    implements StyledNode {
+  /// Returns next [LineNode] or `null` if this is the last line in the document.
+  LineNode get nextLine {
+    if (isLast) {
+      if (parent is BlockNode) {
+        if (parent.isLast) return null;
+        return (parent.next is BlockNode)
+            ? (parent.next as BlockNode).first
+            : parent.next;
+      } else
+        return null;
+    } else {
+      return (next is BlockNode) ? (next as BlockNode).first : next;
+    }
+  }
+
+  /// Creates new empty [LineNode] with the same style.
+  LineNode clone() {
+    final node = new LineNode();
+    node.applyStyle(style);
+    return node;
+  }
+
+  /// Splits this line into two at specified character [index].
+  ///
+  /// 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}.');
+
+    LineNode line = clone();
+    insertAfter(line);
+    if (index == length - 1) return line;
+
+    final split = lookup(index);
+    while (!split.node.isLast) {
+      LeafNode child = this.last;
+      child.unlink();
+      line.addFirst(child);
+    }
+    LeafNode child = split.node;
+    line.addFirst(child.cutAt(split.offset));
+    return line;
+  }
+
+  /// Unwraps this line from it's parent [BlockNode].
+  ///
+  /// This method asserts if current [parent] of this line is not a [BlockNode].
+  void unwrap() {
+    assert(parent is BlockNode);
+    BlockNode block = parent;
+    block.unwrapLine(this);
+  }
+
+  /// Wraps this line with new parent [block].
+  ///
+  /// This line can not be in a [BlockNode] when this method is called.
+  void wrap(BlockNode block) {
+    assert(parent != null && parent is! BlockNode);
+    insertAfter(block);
+    unlink();
+    block.add(this);
+  }
+
+  /// Returns style for specified text range.
+  ///
+  /// Only attributes applied to all characters within this range are
+  /// included in the result. Inline and line level attributes are
+  /// handled separately, e.g.:
+  ///
+  /// - line attribute X is included in the result only if it exists for
+  ///   every line within this range (partially included lines are counted).
+  /// - 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);
+
+    NotusStyle result = new NotusStyle();
+    Set<NotusAttribute> excluded = new Set();
+
+    void _handle(NotusStyle style) {
+      if (result.isEmpty) {
+        excluded.addAll(style.values);
+      } else {
+        for (var attr in result.values) {
+          if (!style.contains(attr)) {
+            excluded.add(attr);
+          }
+        }
+      }
+      final remaining = style.removeAll(excluded);
+      result = result.removeAll(excluded);
+      result = result.mergeAll(remaining);
+    }
+
+    final data = lookup(offset, inclusive: true);
+    TextNode node = data.node;
+    if (node != null) {
+      result = result.mergeAll(node.style);
+      int pos = node.length - data.offset;
+      while (!node.isLast && pos < local) {
+        node = node.next;
+        _handle(node.style);
+        pos += node.length;
+      }
+    }
+
+    result = result.mergeAll(this.style);
+    if (parent is BlockNode) {
+      BlockNode block = parent;
+      result = result.mergeAll(block.style);
+    }
+
+    int remaining = length - local;
+    if (remaining > 0) {
+      final rest = nextLine.collectStyle(0, remaining);
+      _handle(rest);
+    }
+
+    return result;
+  }
+
+  @override
+  LeafNode get defaultChild => new TextNode();
+
+  // TODO: should be able to cache length and invalidate on any child-related operation
+  @override
+  int get length => super.length + 1;
+
+  @override
+  Delta toDelta() {
+    final Delta delta = children
+        .map((text) => text.toDelta())
+        .fold(new Delta(), (a, b) => a.concat(b));
+    var attributes = style;
+    if (parent is BlockNode) {
+      BlockNode block = parent;
+      attributes = attributes.mergeAll(block.style);
+    }
+    delta.insert('\n', attributes.toJson());
+    return delta;
+  }
+
+  @override
+  String toPlainText() => super.toPlainText() + '\n';
+
+  @override
+  String toString() {
+    final body = children.join(' → ');
+    final styleString = style.isNotEmpty ? ' $style' : '';
+    return '¶ $body ⏎$styleString';
+  }
+
+  @override
+  void optimize() {
+    // No-op, line merging is done in insert/delete operations
+  }
+
+  @override
+  void insert(int index, String text, NotusStyle style) {
+    final lf = text.indexOf('\n');
+    if (lf == -1) {
+      _insertSafe(index, text, style);
+      // No need to update line or block format since those attributes can only
+      // be attached to `\n` character and we already know it's not present.
+      return;
+    }
+
+    final substring = text.substring(0, lf);
+    _insertSafe(index, substring, style);
+    if (substring.isNotEmpty) index += substring.length;
+
+    final nextLine = splitAt(index); // Next line inherits our format.
+
+    // Reset our format and unwrap from a block if needed.
+    clearStyle();
+    if (parent is BlockNode) unwrap();
+
+    // Now we can apply new format and re-layout.
+    _formatAndOptimize(style);
+
+    // Continue with remaining part.
+    final remaining = text.substring(lf + 1);
+    nextLine.insert(0, remaining, style);
+  }
+
+  @override
+  void retain(int index, int length, NotusStyle style) {
+    if (style == null) return;
+    int 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;
+
+    if (isLineFormat) {
+      assert(
+          style.values.every((attr) => attr.scope == NotusAttributeScope.line),
+          'It is not allowed to apply inline attributes to line itself.');
+      _formatAndOptimize(style);
+    } else {
+      // otherwise forward to children as it's inline format update.
+      assert(index + local != thisLength,
+          'It is not allowed to apply inline attributes to line itself.');
+      assert(style.values
+          .every((attr) => attr.scope == NotusAttributeScope.inline));
+      super.retain(index, local, style);
+    }
+
+    int 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);
+    if (isLFDeleted) {
+      // Our line-break deleted with all style information.
+      clearStyle();
+      if (local > 1) {
+        // Exclude line-break from delete range for children.
+        super.delete(index, local - 1);
+      }
+    } else {
+      super.delete(index, local);
+    }
+
+    int remaining = length - local;
+    if (remaining > 0) {
+      assert(nextLine != null);
+      nextLine.delete(0, remaining);
+    }
+    if (isLFDeleted && isNotEmpty) {
+      // Since we lost our line-break and still have child text nodes those must
+      // migrate to the next line.
+
+      // nextLine might have been unmounted since last assert so we need to
+      // check again we still have a line after us.
+      assert(nextLine != null);
+
+      // Move remaining stuff in this line to next line so that all attributes
+      // of nextLine are preserved.
+      nextLine.moveChildren(this); // TODO: avoid double move
+      moveChildren(nextLine);
+    }
+
+    if (isLFDeleted) {
+      // Now we can remove this line.
+      final block = parent; // remember reference before un-linking.
+      unlink();
+      block.optimize();
+    }
+  }
+
+  /// Formats this line and optimizes layout afterwards.
+  void _formatAndOptimize(NotusStyle newStyle) {
+    if (newStyle == null || newStyle.isEmpty) return;
+
+    applyStyle(newStyle);
+    if (!newStyle.contains(NotusAttribute.block))
+      return; // no block-level changes
+
+    final blockStyle = newStyle.get(NotusAttribute.block);
+    if (parent is BlockNode) {
+      final parentStyle = (parent as BlockNode).style.get(NotusAttribute.block);
+      if (blockStyle == NotusAttribute.block.unset) {
+        unwrap();
+      } else if (blockStyle != parentStyle) {
+        unwrap();
+        BlockNode block = new 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();
+      block.applyAttribute(blockStyle);
+      wrap(block);
+      block.optimize();
+    }
+  }
+
+  void _insertSafe(int index, String text, NotusStyle style) {
+    assert(index == 0 || (index > 0 && index < length));
+    assert(text.contains('\n') == false);
+    if (text.isEmpty) return;
+
+    if (isEmpty) {
+      final child = new LeafNode(text);
+      add(child);
+      child.formatAndOptimize(style);
+    } else {
+      final LookupResult result = lookup(index, inclusive: true);
+      result.node.insert(result.offset, text, style);
+    }
+  }
+}

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

@@ -0,0 +1,310 @@
+// 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 'dart:collection';
+
+import 'package:meta/meta.dart';
+import 'package:quill_delta/quill_delta.dart';
+
+import 'attributes.dart';
+import 'line.dart';
+
+/// An abstract node in a document tree.
+///
+/// Represents a segment of a Notus document with specified [offset]
+/// and [length].
+///
+/// The [offset] property is relative to [parent]. See also [documentOffset]
+/// which provides absolute offset of this node within the document.
+///
+/// The current parent node is exposed by the [parent] property. A node is
+/// considered [mounted] when the [parent] property is not `null`.
+abstract class Node extends LinkedListEntry<Node> {
+  /// Current parent of this node. May be null if this node is not mounted.
+  ContainerNode get parent => _parent;
+  ContainerNode _parent;
+
+  /// Returns `true` if this node is the first node in the [parent] list.
+  bool get isFirst => list.first == this;
+
+  /// Returns `true` if this node is the last node in the [parent] list.
+  bool get isLast => list.last == this;
+
+  /// Length of this node in characters.
+  int get length;
+
+  /// Returns `true` if this node is currently mounted, e.g. [parent] is not
+  /// `null`.
+  bool get mounted => _parent != null;
+
+  /// Offset in characters of this node relative to [parent] node.
+  ///
+  /// To get offset of this node in the document see [documentOffset].
+  int get offset {
+    if (isFirst) return 0;
+    int offset = 0;
+    Node node = this;
+    do {
+      node = node.previous;
+      offset += node.length;
+    } while (!node.isFirst);
+    return offset;
+  }
+
+  /// Offset in characters of this node in the document.
+  int get documentOffset {
+    int parentOffset = (_parent is! RootNode) ? _parent.documentOffset : 0;
+    return parentOffset + this.offset;
+  }
+
+  /// Returns `true` if this node contains character at specified [offset] in
+  /// the document.
+  bool containsOffset(int offset) {
+    int o = documentOffset;
+    return o <= offset && offset < o + length;
+  }
+
+  /// Optimize this node within [parent].
+  ///
+  /// Subclasses should override this method to perform necessary optimizations.
+  @protected
+  void optimize();
+
+  /// Returns [Delta] representation of this node.
+  Delta toDelta();
+
+  /// Returns plain-text representation of this node.
+  String toPlainText();
+
+  /// Insert [text] at specified character [index] with style [style].
+  void insert(int index, String text, NotusStyle style);
+
+  /// Format [length] characters of this node starting from [index] with
+  /// specified style [style].
+  void retain(int index, int length, NotusStyle style);
+
+  /// Delete [length] characters of this node starting from [index].
+  void delete(int index, int length);
+
+  @override
+  void insertBefore(Node entry) {
+    assert(entry._parent == null && _parent != null);
+    entry._parent = _parent;
+    super.insertBefore(entry);
+  }
+
+  @override
+  void insertAfter(Node entry) {
+    assert(entry._parent == null && _parent != null);
+    entry._parent = _parent;
+    super.insertAfter(entry);
+  }
+
+  @override
+  void unlink() {
+    assert(_parent != null);
+    _parent = null;
+    super.unlink();
+  }
+}
+
+/// Result of a child lookup in a [ContainerNode].
+class LookupResult {
+  /// The child node if found, otherwise `null`.
+  final Node node;
+
+  /// Starting offset within the child [node] which points at the same
+  /// character in the document as the original offset passed to
+  /// [ContainerNode.lookup] method.
+  final int offset;
+
+  LookupResult(this.node, this.offset);
+
+  /// Returns `true` if there is no child node found, e.g. [node] is `null`.
+  bool get isEmpty => node == null;
+
+  /// Returns `true` [node] is not `null`.
+  bool get isNotEmpty => node != null;
+}
+
+/// Container node can accommodate other nodes.
+///
+/// Delegates insert, retain and delete operations to children nodes. For each
+/// operation container looks for a child at specified index position and
+/// forwards operation to that child.
+///
+/// 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>();
+
+  /// List of children.
+  LinkedList<Node> get children => _children;
+
+  /// Returns total number of child nodes in this container.
+  ///
+  /// To get text length of this container see [length].
+  int get childCount => _children.length;
+
+  /// Returns the first child [Node].
+  Node get first => _children.first;
+
+  /// Returns the last child [Node].
+  Node get last => _children.last;
+
+  /// Returns an instance of default child for this container node.
+  ///
+  /// Always returns fresh instance.
+  T get defaultChild;
+
+  /// Returns `true` if this container has no child nodes.
+  bool get isEmpty => _children.isEmpty;
+
+  /// Returns `true` if this container has at least 1 child.
+  bool get isNotEmpty => _children.isNotEmpty;
+
+  /// Adds [node] to the end of this container children list.
+  void add(T node) {
+    assert(node._parent == null);
+    node._parent = this;
+    _children.add(node);
+  }
+
+  /// Adds [node] to the beginning of this container children list.
+  void addFirst(T node) {
+    assert(node._parent == null);
+    node._parent = this;
+    _children.addFirst(node);
+  }
+
+  /// Removes [node] from this container.
+  void remove(T node) {
+    assert(node._parent == this);
+    node._parent = null;
+    _children.remove(node);
+  }
+
+  /// Moves children of this node to [newParent].
+  void moveChildren(ContainerNode newParent) {
+    if (isEmpty) return;
+    T toBeOptimized = newParent.isEmpty ? null : newParent.last;
+    while (isNotEmpty) {
+      T child = first;
+      child.unlink();
+      newParent.add(child);
+    }
+
+    /// In case [newParent] already had children we need to make sure
+    /// combined list is optimized.
+    if (toBeOptimized != null) toBeOptimized.optimize();
+  }
+
+  /// Looks up a child [Node] at specified character [offset] in this container.
+  ///
+  /// Returns [LookupResult]. The result may contain found node or `null` if
+  /// no node is found at specified offset.
+  ///
+  /// [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}) {
+    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);
+      }
+      offset -= length;
+    }
+    return new LookupResult(null, 0);
+  }
+
+  //
+  // Overridden members
+  //
+
+  @override
+  String toPlainText() => children.map((child) => child.toPlainText()).join();
+
+  /// Content length of this node's children. To get number of children in this
+  /// node use [childCount].
+  @override
+  int get length => _children.fold(0, (current, node) => current + node.length);
+
+  @override
+  void insert(int index, String value, NotusStyle style) {
+    assert(index == 0 || (index > 0 && index < length));
+
+    if (isEmpty) {
+      assert(index == 0);
+      Node node = defaultChild;
+      add(node);
+      node.insert(index, value, style);
+    } else {
+      LookupResult result = lookup(index);
+      result.node.insert(result.offset, value, style);
+    }
+  }
+
+  @override
+  void retain(int index, int length, NotusStyle attributes) {
+    assert(isNotEmpty);
+    final res = lookup(index);
+    res.node.retain(res.offset, length, attributes);
+  }
+
+  @override
+  void delete(int index, int length) {
+    assert(isNotEmpty);
+    final res = lookup(index);
+    res.node.delete(res.offset, length);
+  }
+
+  @override
+  String toString() => _children.join('\n');
+}
+
+/// An interface for document nodes with style.
+abstract class StyledNode implements Node {
+  /// Style of this node.
+  NotusStyle get style;
+}
+
+/// Mixin used by nodes that wish to implement [StyledNode] interface.
+abstract class StyledNodeMixin implements StyledNode {
+  @override
+  NotusStyle get style => _style;
+  NotusStyle _style = new NotusStyle();
+
+  /// Applies style [attribute] to this node.
+  void applyAttribute(NotusAttribute attribute) {
+    _style = _style.merge(attribute);
+  }
+
+  /// Applies new style [value] to this node. Provided [value] is merged
+  /// into current style.
+  void applyStyle(NotusStyle value) {
+    assert(value != null);
+    _style = _style.mergeAll(value);
+  }
+
+  /// Clears style of this node.
+  void clearStyle() {
+    _style = new NotusStyle();
+  }
+}
+
+/// Root node of document tree.
+class RootNode extends ContainerNode<ContainerNode<Node>> {
+  @override
+  ContainerNode<Node> get defaultChild => new LineNode();
+
+  @override
+  void optimize() {/* no-op */}
+
+  @override
+  Delta toDelta() => children
+      .map((child) => child.toDelta())
+      .fold(new Delta(), (a, b) => a.concat(b));
+}

packages/notus/lib/src/embed.dart

@@ -0,0 +1,21 @@
+import 'document/attributes.dart';
+
+abstract class NotusEmbed {
+  NotusAttribute get attribute;
+}
+
+class HorizontalRuleEmbed implements NotusEmbed {
+  const HorizontalRuleEmbed();
+
+  @override
+  NotusAttribute<Map<String, dynamic>> get attribute =>
+      NotusAttribute.embed.horizontalRule;
+}
+
+class ImageEmbed implements NotusEmbed {
+  const ImageEmbed(this.source) : assert(source != null);
+  final String source;
+
+  @override
+  NotusAttribute get attribute => NotusAttribute.embed.image(source);
+}

packages/notus/lib/src/heuristics.dart

@@ -0,0 +1,111 @@
+// 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:notus/notus.dart';
+import 'package:quill_delta/quill_delta.dart';
+
+import 'heuristics/delete_rules.dart';
+import 'heuristics/embed_rules.dart';
+import 'heuristics/format_rules.dart';
+import 'heuristics/insert_rules.dart';
+
+/// Registry for insert, format and delete heuristic rules used by
+/// [NotusDocument] documents.
+class NotusHeuristics {
+  /// Default set of heuristic rules.
+  static const NotusHeuristics fallback = NotusHeuristics(
+    formatRules: [
+      FormatLinkAtCaretPositionRule(),
+      ResolveLineFormatRule(),
+      ResolveInlineFormatRule(),
+      // No need in catch-all rule here since the above rules cover all
+      // attributes.
+    ],
+    insertRules: [
+      ForceNewlineForInsertsAroundEmbedRule(),
+      PreserveLineStyleOnSplitRule(),
+      AutoExitBlockRule(),
+      ResetLineFormatOnNewLineRule(),
+      AutoFormatLinksRule(),
+      PreserveInlineStylesRule(),
+      CatchAllInsertRule(),
+    ],
+    deleteRules: [
+      PreserveLineStyleOnMergeRule(),
+      CatchAllDeleteRule(),
+    ],
+    embedRules: [
+      FormatEmbedsRule(),
+    ],
+  );
+
+  const NotusHeuristics({
+    this.formatRules,
+    this.insertRules,
+    this.deleteRules,
+    this.embedRules,
+  });
+
+  /// List of format rules in this registry.
+  final List<FormatRule> formatRules;
+
+  /// List of insert rules in this registry.
+  final List<InsertRule> insertRules;
+
+  /// List of delete rules in this registry.
+  final List<DeleteRule> deleteRules;
+
+  /// List of embed rules in this registry.
+  final List<EmbedRule> embedRules;
+
+  /// Applies heuristic rules to specified insert operation based on current
+  /// state of Notus [document].
+  Delta applyInsertRules(NotusDocument document, int index, String insert) {
+    final delta = document.toDelta();
+    for (var rule in insertRules) {
+      final result = rule.apply(delta, index, insert);
+      if (result != null) return result..trim();
+    }
+    throw new StateError(
+        'Failed to apply insert heuristic rules: none applied.');
+  }
+
+  /// Applies heuristic rules to specified format operation based on current
+  /// state of Notus [document].
+  Delta applyFormatRules(
+      NotusDocument document, int index, int length, NotusAttribute value) {
+    final delta = document.toDelta();
+    for (var rule in formatRules) {
+      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.');
+  }
+
+  /// Applies heuristic rules to specified delete operation based on current
+  /// state of Notus [document].
+  Delta applyDeleteRules(NotusDocument document, int index, int length) {
+    final delta = document.toDelta();
+    for (var rule in deleteRules) {
+      final result = rule.apply(delta, index, length);
+      if (result != null) return result..trim();
+    }
+    throw new StateError(
+        'Failed to apply delete heuristic rules: none applied.');
+  }
+
+  /// Applies heuristic rules to specified embed operation based on current
+  /// state of [document].
+  Delta applyEmbedRules(
+      NotusDocument document, int index, EmbedAttribute embed) {
+    final delta = document.toDelta();
+    for (var rule in embedRules) {
+      final result = rule.apply(delta, index, embed);
+      if (result != null) return result..trim();
+    }
+    throw new StateError(
+        'Failed to apply embed heuristic rules: none applied.');
+  }
+}

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

@@ -0,0 +1,73 @@
+// 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:quill_delta/quill_delta.dart';
+
+/// A heuristic rule for delete operations.
+abstract class DeleteRule {
+  /// Constant constructor allows subclasses to declare constant constructors.
+  const DeleteRule();
+
+  /// Applies heuristic rule to a delete operation on a [document] and returns
+  /// resulting [Delta].
+  Delta apply(Delta document, int index, int length);
+}
+
+/// Fallback rule for delete operations which simply deletes specified text
+/// range without any special handling.
+class CatchAllDeleteRule extends DeleteRule {
+  const CatchAllDeleteRule();
+
+  @override
+  Delta apply(Delta document, int index, int length) {
+    return new Delta()
+      ..retain(index)
+      ..delete(length);
+  }
+}
+
+/// Preserves line format when user deletes the line's line-break character
+/// effectively merging it with the next line.
+///
+/// This rule makes sure to apply all style attributes of deleted line-break
+/// to the next available line-break, which may reset any style attributes
+/// already present there.
+class PreserveLineStyleOnMergeRule extends DeleteRule {
+  const PreserveLineStyleOnMergeRule();
+
+  @override
+  Delta apply(Delta document, int index, int length) {
+    DeltaIterator iter = new 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()
+      ..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');
+      if (lf == -1) {
+        result..retain(op.length);
+        continue;
+      }
+      var attributes = _unsetAttributes(op.attributes);
+      if (target.isNotPlain) {
+        attributes ??= <String, dynamic>{};
+        attributes.addAll(target.attributes);
+      }
+      result..retain(lf)..retain(1, attributes);
+      break;
+    }
+    return result;
+  }
+
+  Map<String, dynamic> _unsetAttributes(Map<String, dynamic> attributes) {
+    if (attributes == null) return null;
+    return attributes.map((key, value) => new MapEntry(key, null));
+  }
+}

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

@@ -0,0 +1,86 @@
+// 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:quill_delta/quill_delta.dart';
+import 'package:notus/notus.dart';
+
+/// A heuristic rule for embed operations.
+abstract class EmbedRule {
+  /// Constant constructor allows subclasses to declare constant constructors.
+  const EmbedRule();
+
+  /// Applies heuristic rule to an embed operation on a [document] and returns
+  /// resulting [Delta].
+  Delta apply(Delta document, int index, EmbedAttribute embed);
+}
+
+/// Handles all operations which manipulate embeds.
+class FormatEmbedsRule extends EmbedRule {
+  const FormatEmbedsRule();
+
+  @override
+  Delta apply(Delta document, int index, EmbedAttribute embed) {
+    final iter = new DeltaIterator(document);
+    final previous = iter.skip(index);
+
+    final target = iter.next();
+    Delta result = new Delta()..retain(index);
+    if (target.length == 1 && target.data == EmbedNode.kPlainTextPlaceholder) {
+      assert(() {
+        final style = NotusStyle.fromJson(target.attributes);
+        return style.single.key == NotusAttribute.embed.key;
+      }());
+
+      // There is already embed here, simply update its style.
+      return result..retain(1, embed.toJson());
+    } else {
+      // Target is not an embed, need to insert.
+      // Embeds can be inserted only into an empty line.
+
+      // Check if [index] is on an empty line already.
+      final isNewlineBefore = previous == null || previous.data.endsWith('\n');
+      final isNewlineAfter = target.data.startsWith('\n');
+      final isOnEmptyLine = isNewlineBefore && isNewlineAfter;
+      if (isOnEmptyLine) {
+        return result..insert(EmbedNode.kPlainTextPlaceholder, embed.toJson());
+      }
+      // We are on a non-empty line, split it (preserving style if needed)
+      // and insert our embed.
+      final lineStyle = _getLineStyle(iter, target);
+      if (!isNewlineBefore) {
+        result..insert('\n', lineStyle);
+      }
+      result..insert(EmbedNode.kPlainTextPlaceholder, embed.toJson());
+      if (!isNewlineAfter) {
+        result..insert('\n');
+      }
+      return result;
+    }
+//
+//    if (embed == NotusAttribute.embed.unset) {
+//      // Convert into a delete operation.
+//      return result..delete(1);
+//    } else {
+//      return result..retain(1, embed.toJson());
+//    }
+  }
+
+  Map<String, dynamic> _getLineStyle(
+      DeltaIterator iterator, Operation current) {
+    if (current.data.indexOf('\n') >= 0) {
+      return current.attributes;
+    }
+    // Continue looking for line-break.
+    Map<String, dynamic> attributes;
+    while (iterator.hasNext) {
+      final op = iterator.next();
+      int lf = op.data.indexOf('\n');
+      if (lf >= 0) {
+        attributes = op.attributes;
+        break;
+      }
+    }
+    return attributes;
+  }
+}

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

@@ -0,0 +1,147 @@
+// 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:quill_delta/quill_delta.dart';
+import 'package:notus/notus.dart';
+
+/// A heuristic rule for format (retain) operations.
+abstract class FormatRule {
+  /// Constant constructor allows subclasses to declare constant constructors.
+  const FormatRule();
+
+  /// Applies heuristic rule to a retain (format) operation on a [document] and
+  /// returns resulting [Delta].
+  Delta apply(Delta document, int index, int length, NotusAttribute attribute);
+}
+
+/// Produces Delta with line-level attributes applied strictly to
+/// line-break characters.
+class ResolveLineFormatRule extends FormatRule {
+  const ResolveLineFormatRule() : super();
+
+  @override
+  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);
+    iter.skip(index);
+
+    // Apply line styles to all line-break characters within range of this
+    // retain operation.
+    int current = 0;
+    while (current < length && iter.hasNext) {
+      final op = iter.next(length - current);
+      if (op.data.contains('\n')) {
+        final delta = _applyAttribute(op.data, attribute);
+        result = result.concat(delta);
+      } else {
+        result.retain(op.length);
+      }
+      current += op.length;
+    }
+    // And include extra line-break after retain
+    while (iter.hasNext) {
+      final op = iter.next();
+      int lf = op.data.indexOf('\n');
+      if (lf == -1) {
+        result..retain(op.length);
+        continue;
+      }
+      result..retain(lf)..retain(1, attribute.toJson());
+      break;
+    }
+    return result;
+  }
+
+  Delta _applyAttribute(String text, NotusAttribute attribute) {
+    final result = new Delta();
+    int offset = 0;
+    int lf = text.indexOf('\n');
+    while (lf >= 0) {
+      result..retain(lf - offset)..retain(1, attribute.toJson());
+      offset = lf + 1;
+      lf = text.indexOf('\n', offset);
+    }
+    // Retain any remaining characters in text
+    result.retain(text.length - offset);
+    return result;
+  }
+}
+
+/// Produces Delta with inline-level attributes applied too all characters
+/// except line-breaks.
+class ResolveInlineFormatRule extends FormatRule {
+  const ResolveInlineFormatRule();
+
+  @override
+  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);
+    iter.skip(index);
+
+    // Apply inline styles to all non-line-break characters within range of this
+    // retain operation.
+    int current = 0;
+    while (current < length && iter.hasNext) {
+      final op = iter.next(length - current);
+      int lf = op.data.indexOf('\n');
+      if (lf != -1) {
+        int pos = 0;
+        while (lf != -1) {
+          result..retain(lf - pos, attribute.toJson())..retain(1);
+          pos = lf + 1;
+          lf = op.data.indexOf('\n', pos);
+        }
+        if (pos < op.length) result.retain(op.length - pos, attribute.toJson());
+      } else {
+        result.retain(op.length, attribute.toJson());
+      }
+      current += op.length;
+    }
+
+    return result;
+  }
+}
+
+/// Allows updating link format with collapsed selection.
+class FormatLinkAtCaretPositionRule extends FormatRule {
+  const FormatLinkAtCaretPositionRule();
+
+  @override
+  Delta apply(Delta document, int index, int length, NotusAttribute attribute) {
+    if (attribute.key != NotusAttribute.link.key) return null;
+    // If user selection is not collapsed we let it fallback to default rule
+    // which simply applies the attribute to selected range.
+    // This may still not be a bulletproof approach as selection can span
+    // multiple lines or be a subset of existing link-formatted text.
+    // So certain improvements can be made in the future to account for such
+    // edge cases.
+    if (length != 0) return null;
+
+    Delta result = new Delta();
+    final iter = new DeltaIterator(document);
+    final before = iter.skip(index);
+    final after = iter.next();
+    int startIndex = index;
+    int retain = 0;
+    if (before != null && before.hasAttribute(attribute.key)) {
+      startIndex -= before.length;
+      retain = before.length;
+    }
+    if (after != null && after.hasAttribute(attribute.key)) {
+      retain += after.length;
+    }
+    // There is no link-styled text around `index` position so it becomes a
+    // no-op action.
+    if (retain == 0) return null;
+
+    result..retain(startIndex)..retain(retain, attribute.toJson());
+
+    return result;
+  }
+}
+

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

@@ -0,0 +1,258 @@
+// 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:quill_delta/quill_delta.dart';
+import 'package:notus/notus.dart';
+
+/// A heuristic rule for insert operations.
+abstract class InsertRule {
+  /// Constant constructor allows subclasses to declare constant constructors.
+  const InsertRule();
+
+  /// Applies heuristic rule to an insert operation on a [document] and returns
+  /// resulting [Delta].
+  Delta apply(Delta document, int index, String text);
+}
+
+/// Fallback rule which simply inserts text as-is without any special handling.
+class CatchAllInsertRule extends InsertRule {
+  const CatchAllInsertRule();
+
+  @override
+  Delta apply(Delta document, int index, String text) {
+    return new Delta()
+      ..retain(index)
+      ..insert(text);
+  }
+}
+
+/// Preserves line format when user splits the line into two.
+///
+/// This rule ignores scenarios when the line is split on its edge, meaning
+/// a line-break is inserted at the beginning or the end of the line.
+class PreserveLineStyleOnSplitRule extends InsertRule {
+  const PreserveLineStyleOnSplitRule();
+
+  bool isEdgeLineSplit(Operation before, Operation after) {
+    if (before == null) return true; // split at the beginning of a doc
+    return before.data.endsWith('\n') || after.data.startsWith('\n');
+  }
+
+  @override
+  Delta apply(Delta document, int index, String text) {
+    if (text != '\n') return null;
+
+    DeltaIterator iter = new 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) {
+      // 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.
+      assert(after.isPlain);
+      // No attributes to apply so we simply create a new line.
+      result.insert('\n');
+      return result;
+    }
+    // Continue looking for line-break.
+    Map<String, dynamic> attributes;
+    while (iter.hasNext) {
+      final op = iter.next();
+      int lf = op.data.indexOf('\n');
+      if (lf >= 0) {
+        attributes = op.attributes;
+        break;
+      }
+    }
+    result.insert('\n', attributes);
+    return result;
+  }
+}
+
+/// Resets format for a newly inserted line when insert occurred at the end
+/// of a line (right before a line-break).
+class ResetLineFormatOnNewLineRule extends InsertRule {
+  const ResetLineFormatOnNewLineRule();
+
+  @override
+  Delta apply(Delta document, int index, String text) {
+    if (text != '\n') return null;
+
+    DeltaIterator iter = new DeltaIterator(document);
+    iter.skip(index);
+    final target = iter.next();
+
+    if (target.data.startsWith('\n')) {
+      Map<String, dynamic> resetStyle = null;
+      if (target.attributes != null &&
+          target.attributes.containsKey(NotusAttribute.heading.key)) {
+        resetStyle = NotusAttribute.heading.unset.toJson();
+      }
+      return new Delta()
+        ..retain(index)
+        ..insert('\n', target.attributes)
+        ..retain(1, resetStyle)
+        ..trim();
+    }
+    return null;
+  }
+}
+
+/// Heuristic rule to exit current block when user inserts two consecutive
+/// line-breaks.
+// TODO: update this rule to handle code blocks differently, at least allow 3 consecutive line-breaks before exiting.
+class AutoExitBlockRule extends InsertRule {
+  const AutoExitBlockRule();
+
+  bool isEmptyLine(Operation previous, Operation target) {
+    return (previous == null || previous.data.endsWith('\n')) &&
+        target.data.startsWith('\n');
+  }
+
+  @override
+  Delta apply(Delta document, int index, String text) {
+    if (text != '\n') return null;
+
+    DeltaIterator iter = new DeltaIterator(document);
+    final previous = iter.skip(index);
+    final target = iter.next();
+    final isInBlock = target.isNotPlain &&
+        target.attributes.containsKey(NotusAttribute.block.key);
+    if (isEmptyLine(previous, target) && isInBlock) {
+      // 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>{};
+      attributes.addAll(NotusAttribute.block.unset.toJson());
+      return new Delta()..retain(index)..retain(1, attributes);
+    }
+    return null;
+  }
+}
+
+/// Preserves inline styles when user inserts text inside formatted segment.
+class PreserveInlineStylesRule extends InsertRule {
+  const PreserveInlineStylesRule();
+
+  @override
+  Delta apply(Delta document, int index, String text) {
+    // This rule is only applicable to characters other than line-break.
+    if (text.contains('\n')) return null;
+
+    DeltaIterator iter = new 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
+    // of the document so no styles to inherit from.
+    if (previous == null || previous.data.contains('\n')) return null;
+
+    final attributes = previous.attributes;
+    final hasLink =
+        (attributes != null && attributes.containsKey(NotusAttribute.link.key));
+    if (!hasLink) {
+      return new Delta()
+        ..retain(index)
+        ..insert(text, attributes);
+    }
+    // Special handling needed for inserts inside fragments with link attribute.
+    // Link style should only be preserved if insert occurs inside the fragment.
+    // Link style should NOT be preserved on the boundaries.
+    var noLinkAttributes = previous.attributes;
+    noLinkAttributes.remove(NotusAttribute.link.key);
+    final noLinkResult = new Delta()
+      ..retain(index)
+      ..insert(text, noLinkAttributes.isEmpty ? null : noLinkAttributes);
+    final next = iter.next();
+    if (next == null) {
+      // Nothing after us, we are not inside link-styled fragment.
+      return noLinkResult;
+    }
+    final nextAttributes = next.attributes ?? <String, dynamic>{};
+    if (!nextAttributes.containsKey(NotusAttribute.link.key)) {
+      // Next fragment is not styled as link.
+      return noLinkResult;
+    }
+    // We must make sure links are identical in previous and next operations.
+    if (attributes[NotusAttribute.link.key] ==
+        nextAttributes[NotusAttribute.link.key]) {
+      return new Delta()
+        ..retain(index)
+        ..insert(text, attributes);
+    } else {
+      return noLinkResult;
+    }
+  }
+}
+
+/// Applies link format to text segment (which looks like a link) when user
+/// inserts space character after it.
+class AutoFormatLinksRule extends InsertRule {
+  const AutoFormatLinksRule();
+
+  @override
+  Delta apply(Delta document, int index, String text) {
+    // This rule applies to a space inserted after a link, so we can ignore
+    // everything else.
+    if (text != ' ') return null;
+
+    DeltaIterator iter = new DeltaIterator(document);
+    final previous = iter.skip(index);
+    // No previous operation means no link.
+    if (previous == null) return null;
+
+    // Split text of previous operation in lines and words and take last word to test.
+    final candidate = previous.data.split('\n').last.split(' ').last;
+    try {
+      final link = Uri.parse(candidate);
+      if (!['https', 'http'].contains(link.scheme)) {
+        // TODO: might need a more robust way of validating links here.
+        return null;
+      }
+      final attributes = previous.attributes ?? <String, dynamic>{};
+
+      // Do nothing if already formatted as link.
+      if (attributes.containsKey(NotusAttribute.link.key)) return null;
+
+      attributes
+          .addAll(NotusAttribute.link.fromString(link.toString()).toJson());
+      return new Delta()
+        ..retain(index - candidate.length)
+        ..retain(candidate.length, attributes)
+        ..insert(text, previous.attributes);
+    } on FormatException {
+      return null; // Our candidate is not a link.
+    }
+  }
+}
+
+/// Forces text inserted on the same line with an embed (before or after it)
+/// to be moved to a new line adjacent to the original line.
+///
+/// This rule assumes that a line is only allowed to have single embed child.
+class ForceNewlineForInsertsAroundEmbedRule extends InsertRule {
+  const ForceNewlineForInsertsAroundEmbedRule();
+
+  @override
+  Delta apply(Delta document, int index, String text) {
+    DeltaIterator iter = new 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);
+      if (beforeEmbed && !text.endsWith('\n')) {
+        return delta..insert(text)..insert('\n');
+      }
+      if (afterEmbed && !text.startsWith('\n')) {
+        return delta..insert('\n')..insert(text);
+      }
+      return delta..insert(text);
+    }
+    return null;
+  }
+}

packages/notus/pubspec.yaml

@@ -0,0 +1,17 @@
+name: notus
+description: Rich text document model for Zefyr editor.
+version: 0.1.0
+author: Memspace <hello@memspace.app>
+homepage: https://github.com/memspace/notus
+
+environment:
+  sdk: '>=2.0.0-dev.64.0 <2.0.0'
+
+dependencies:
+  collection: ^1.14.6
+  quill_delta: ^1.0.0-dev
+  quiver_hashcode: ^1.0.0
+
+dev_dependencies:
+  test: ^1.0.0
+  test_coverage: ^0.2.0

packages/notus/test/convert/markdown_test.dart

@@ -0,0 +1,173 @@
+// 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 'dart:convert';
+
+import 'package:test/test.dart';
+import 'package:quill_delta/quill_delta.dart';
+import 'package:notus/notus.dart';
+import 'package:notus/convert.dart';
+
+void main() {
+  group('$NotusMarkdownCodec.encode', () {
+    test('unimplemented', () {
+      expect(() {
+        notusMarkdown.decode('test');
+      }, throwsUnimplementedError);
+    });
+  });
+
+  group('$NotusMarkdownCodec.encode', () {
+    test('split adjacent paragraphs', () {
+      final delta = new 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()
+          ..insert('This ')
+          ..insert('house', attribute.toJson())
+          ..insert(' is a ')
+          ..insert('circus', attribute.toJson())
+          ..insert('\n');
+
+        final result = notusMarkdown.encode(delta);
+        expect(result, expected);
+      }
+
+      runFor(NotusAttribute.bold, 'This **house** is a **circus**\n\n');
+      runFor(NotusAttribute.italic, 'This _house_ is a _circus_\n\n');
+    });
+
+    test('intersecting inline styles', () {
+      final b = NotusAttribute.bold.toJson();
+      final i = NotusAttribute.italic.toJson();
+      final bi = new Map<String, dynamic>.from(b);
+      bi.addAll(i);
+
+      final delta = new Delta()
+        ..insert('This ')
+        ..insert('house', b)
+        ..insert(' is a ', bi)
+        ..insert('circus', b)
+        ..insert('\n');
+
+      final result = notusMarkdown.encode(delta);
+      expect(result, 'This **house _is a_ circus**\n\n');
+    });
+
+    test('normalize inline styles', () {
+      final b = NotusAttribute.bold.toJson();
+      final i = NotusAttribute.italic.toJson();
+      final delta = new Delta()
+        ..insert('This')
+        ..insert(' house ', b)
+        ..insert('is a')
+        ..insert(' circus ', i)
+        ..insert('\n');
+
+      final result = notusMarkdown.encode(delta);
+      expect(result, 'This **house** is a _circus_ \n\n');
+    });
+
+    test('links', () {
+      final b = NotusAttribute.bold.toJson();
+      final link = NotusAttribute.link.fromString('https://github.com');
+      final delta = new Delta()
+        ..insert('This')
+        ..insert(' house ', b)
+        ..insert('is a')
+        ..insert(' circus ', link.toJson())
+        ..insert('\n');
+
+      final result = notusMarkdown.encode(delta);
+      expect(result, 'This **house** is a [circus](https://github.com) \n\n');
+    });
+
+    test('heading styles', () {
+      runFor(NotusAttribute<int> attribute, String source, String expected) {
+        final delta = new Delta()
+          ..insert(source)
+          ..insert('\n', attribute.toJson());
+        final result = notusMarkdown.encode(delta);
+        expect(result, expected);
+      }
+
+      runFor(NotusAttribute.h1, 'Title', '# Title\n\n');
+      runFor(NotusAttribute.h2, 'Title', '## Title\n\n');
+      runFor(NotusAttribute.h3, 'Title', '### Title\n\n');
+    });
+
+    test('block styles', () {
+      runFor(NotusAttribute<String> attribute, String source, String expected) {
+        final delta = new Delta()
+          ..insert(source)
+          ..insert('\n', attribute.toJson());
+        final result = notusMarkdown.encode(delta);
+        expect(result, expected);
+      }
+
+      runFor(NotusAttribute.ul, 'List item', '* List item\n\n');
+      runFor(NotusAttribute.ol, 'List item', '1. List item\n\n');
+      runFor(NotusAttribute.bq, 'List item', '> List item\n\n');
+      runFor(NotusAttribute.code, 'List item', '```\nList item\n```\n\n');
+    });
+
+    test('multiline blocks', () {
+      runFor(NotusAttribute<String> attribute, String source, String expected) {
+        final delta = new Delta()
+          ..insert(source)
+          ..insert('\n', attribute.toJson())
+          ..insert(source)
+          ..insert('\n', attribute.toJson());
+        final result = notusMarkdown.encode(delta);
+        expect(result, expected);
+      }
+
+      runFor(NotusAttribute.ul, 'text', '* text\n* text\n\n');
+      runFor(NotusAttribute.ol, 'text', '1. text\n1. text\n\n');
+      runFor(NotusAttribute.bq, 'text', '> text\n> text\n\n');
+      runFor(NotusAttribute.code, 'text', '```\ntext\ntext\n```\n\n');
+    });
+
+    test('multiple styles', () {
+      final result = notusMarkdown.encode(delta);
+      expect(result, expectedMarkdown);
+    });
+  });
+}
+
+final doc =
+    r'[{"insert":"Zefyr"},{"insert":"\n","attributes":{"heading":1}},{"insert":"Soft and gentle rich text editing for Flutter applications.","attributes":{"i":true}},{"insert":"\nZefyr is an "},{"insert":"early preview","attributes":{"b":true}},{"insert":" open source library.\nDocumentation"},{"insert":"\n","attributes":{"heading":3}},{"insert":"Quick Start"},{"insert":"\n","attributes":{"block":"ul"}},{"insert":"Data format and Document Model"},{"insert":"\n","attributes":{"block":"ul"}},{"insert":"Style attributes"},{"insert":"\n","attributes":{"block":"ul"}},{"insert":"Heuristic rules"},{"insert":"\n","attributes":{"block":"ul"}},{"insert":"Clean and modern look"},{"insert":"\n","attributes":{"heading":2}},{"insert":"Zefyr’s rich text editor is built with simplicity and flexibility in mind. It provides clean interface for distraction-free editing. Think Medium.com-like experience.\nimport ‘package:flutter/material.dart’;"},{"insert":"\n","attributes":{"block":"code"}},{"insert":"import ‘package:notus/notus.dart’;"},{"insert":"\n\n","attributes":{"block":"code"}},{"insert":"void main() {"},{"insert":"\n","attributes":{"block":"code"}},{"insert":" print(“Hello world!”);"},{"insert":"\n","attributes":{"block":"code"}},{"insert":"}"},{"insert":"\n","attributes":{"block":"code"}}]';
+final delta = Delta.fromJson(json.decode(doc));
+
+final expectedMarkdown = '''
+# Zefyr
+
+_Soft and gentle rich text editing for Flutter applications._
+
+Zefyr is an **early preview** open source library.
+
+### Documentation
+
+* Quick Start
+* Data format and Document Model
+* Style attributes
+* Heuristic rules
+
+## Clean and modern look
+
+Zefyr’s rich text editor is built with simplicity and flexibility in mind. It provides clean interface for distraction-free editing. Think Medium.com-like experience.
+
+```
+import ‘package:flutter/material.dart’;
+import ‘package:notus/notus.dart’;
+
+void main() {
+ print(“Hello world!”);
+}
+```
+
+''';

packages/notus/test/document/attributes_test.dart

@@ -0,0 +1,15 @@
+// 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';
+
+void main() {
+  group('$NotusStyle', () {
+    test('get', () {
+      var attrs = NotusStyle.fromJson({'block': 'ul'});
+      var attr = attrs.get(NotusAttribute.block);
+      expect(attr, NotusAttribute.ul);
+    });
+  });
+}

packages/notus/test/document/block_test.dart

@@ -0,0 +1,173 @@
+// 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:notus/notus.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);
+
+void main() {
+  group('$BlockNode', () {
+    ContainerNode root;
+    setUp(() {
+      root = new RootNode();
+    });
+
+    test('empty', () {
+      BlockNode node = new BlockNode();
+      expect(node, isEmpty);
+      expect(node.length, 0);
+      expect(node.style, new NotusStyle());
+    });
+
+    test('toString', () {
+      LineNode line = new LineNode();
+      line.add(new TextNode('London "Grammar"'));
+      BlockNode block = new BlockNode();
+      block.applyAttribute(NotusAttribute.ul);
+      block.add(line);
+      final expected = '§ {ul}\n  └ ¶ ⟨London "Grammar"⟩ ⏎';
+      expect('$block', expected);
+    });
+
+    test('unwrapLine from first block', () {
+      root.insert(0, 'One\nTwo\nThree', null);
+      root.retain(3, 1, ulAttrs);
+      root.retain(7, 1, ulAttrs);
+      root.retain(13, 1, ulAttrs);
+      expect(root.childCount, 1);
+      BlockNode block = root.first;
+      LineNode line = block.children.elementAt(1);
+      block.unwrapLine(line);
+      expect(root.children, hasLength(3));
+      expect(root.children.elementAt(0), const TypeMatcher<BlockNode>());
+      expect(root.children.elementAt(1), line);
+      expect(root.children.elementAt(2), block);
+    });
+
+    test('format first line as list', () {
+      root.insert(0, 'Hello world', null);
+      root.retain(11, 1, ulAttrs);
+
+      expect(root.childCount, 1);
+      BlockNode block = root.first;
+      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()
+        ..insert('Hello world')
+        ..insert('\n', ulAttrs.toJson());
+      expect(line.toDelta(), delta);
+    });
+
+    test('format second line as list', () {
+      root.insert(0, 'Hello world\nAb cd ef!', null);
+      root.retain(21, 1, ulAttrs);
+
+      expect(root.childCount, 2);
+      BlockNode block = root.last;
+      expect(block.style.get(NotusAttribute.block),
+          NotusAttribute.ul);
+      expect(block.childCount, 1);
+      expect(block.first, const TypeMatcher<LineNode>());
+    });
+
+    test('format two sibling lines as list', () {
+      root.insert(0, 'Hello world\nAb cd ef!', null);
+      root.retain(11, 1, ulAttrs);
+      root.retain(21, 1, ulAttrs);
+
+      expect(root.childCount, 1);
+      BlockNode block = root.first;
+      expect(block.style.get(NotusAttribute.block),
+          NotusAttribute.ul);
+      expect(block.childCount, 2);
+      expect(block.first, const TypeMatcher<LineNode>());
+      expect(block.last, const TypeMatcher<LineNode>());
+    });
+
+    test('format to split first line from block', () {
+      root.insert(
+          0, 'London Grammar Songs\nHey now\nStrong\nIf You Wait', null);
+      root.retain(20, 1, h1Attrs);
+      root.retain(28, 1, ulAttrs);
+      root.retain(35, 1, ulAttrs);
+      root.retain(47, 1, ulAttrs);
+      expect(root.childCount, 2);
+      root.retain(28, 1, olAttrs);
+      expect(root.childCount, 3);
+      final expected = new Delta()
+        ..insert('London Grammar Songs')
+        ..insert('\n', NotusAttribute.h1.toJson())
+        ..insert('Hey now')
+        ..insert('\n', NotusAttribute.ol.toJson())
+        ..insert('Strong')
+        ..insert('\n', ulAttrs.toJson())
+        ..insert('If You Wait')
+        ..insert('\n', ulAttrs.toJson());
+      expect(root.toDelta(), expected);
+    });
+
+    test('format to split last line from block', () {
+      root.insert(
+          0, 'London Grammar Songs\nHey now\nStrong\nIf You Wait', null);
+      root.retain(20, 1, h1Attrs);
+      root.retain(28, 1, ulAttrs);
+      root.retain(35, 1, ulAttrs);
+      root.retain(47, 1, ulAttrs);
+      expect(root.childCount, 2);
+      root.retain(47, 1, olAttrs);
+      expect(root.childCount, 3);
+      final expected = new Delta()
+        ..insert('London Grammar Songs')
+        ..insert('\n', NotusAttribute.h1.toJson())
+        ..insert('Hey now')
+        ..insert('\n', ulAttrs.toJson())
+        ..insert('Strong')
+        ..insert('\n', ulAttrs.toJson())
+        ..insert('If You Wait')
+        ..insert('\n', NotusAttribute.ol.toJson());
+      expect(root.toDelta(), expected);
+    });
+
+    test('format to split middle line from block', () {
+      root.insert(
+          0, 'London Grammar Songs\nHey now\nStrong\nIf You Wait', null);
+      root.retain(20, 1, h1Attrs);
+      root.retain(28, 1, ulAttrs);
+      root.retain(35, 1, ulAttrs);
+      root.retain(47, 1, ulAttrs);
+      expect(root.childCount, 2);
+      root.retain(35, 1, olAttrs);
+      expect(root.childCount, 4);
+      final expected = new Delta()
+        ..insert('London Grammar Songs')
+        ..insert('\n', NotusAttribute.h1.toJson())
+        ..insert('Hey now')
+        ..insert('\n', ulAttrs.toJson())
+        ..insert('Strong')
+        ..insert('\n', NotusAttribute.ol.toJson())
+        ..insert('If You Wait')
+        ..insert('\n', ulAttrs.toJson());
+      expect(root.toDelta(), expected);
+    });
+
+    test('insert line-break at the begining of the document', () {
+      root.insert(
+          0, 'London Grammar Songs\nHey now\nStrong\nIf You Wait', null);
+      root.retain(20, 1, ulAttrs);
+      root.retain(28, 1, ulAttrs);
+      root.retain(35, 1, ulAttrs);
+      root.retain(47, 1, ulAttrs);
+      expect(root.childCount, 1);
+      root.insert(0, '\n', null);
+      expect(root.childCount, 2);
+    });
+  });
+}

packages/notus/test/document/line_test.dart

@@ -0,0 +1,264 @@
+// 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';
+
+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);
+
+void main() {
+  group('$LineNode', () {
+    ContainerNode root;
+    setUp(() {
+      root = new RootNode();
+    });
+
+    test('empty', () {
+      LineNode node = new LineNode();
+      expect(node, isEmpty);
+      expect(node.length, 1);
+      expect(node.style, new NotusStyle());
+      expect(node.toDelta().toList(), [new Operation.insert('\n')]);
+    });
+
+    test('nextLine', () {
+      root.insert(
+          0, 'Hello world\nThis is my first multiline\nItem\ndocument.', null);
+      root.retain(38, 1, ulStyle);
+      root.retain(43, 1, bqStyle);
+      LineNode line = root.first;
+      expect(line.toPlainText(), 'Hello world\n');
+      var next = line.nextLine;
+      expect(next.toPlainText(), 'This is my first multiline\n');
+      next = next.nextLine;
+      expect(next.toPlainText(), 'Item\n');
+      next = next.nextLine;
+      expect(next.toPlainText(), 'document.\n');
+      expect(next.nextLine, isNull);
+    });
+
+    test('toString', () {
+      LineNode node = new LineNode();
+      node.insert(0, 'London "Grammar" - Hey Now', null);
+      node.retain(0, 16, boldStyle);
+      node.applyAttribute(NotusAttribute.h1);
+      expect('$node', '¶ ⟨London "Grammar"⟩b → ⟨ - Hey Now⟩ ⏎ {heading: 1}');
+    });
+
+    test('splitAt with multiple text segments', (){
+      root.insert(0, 'This house is a circus', null);
+      root.retain(0, 4, boldStyle);
+      root.retain(16, 6, boldStyle);
+      LineNode line = root.first;
+      final newLine = line.splitAt(10);
+      expect(line.toPlainText(), 'This house\n');
+      expect(newLine.toPlainText(), ' is a circus\n');
+    });
+
+    test('insert into empty line', () {
+      LineNode node = new LineNode();
+      node.insert(0, 'London "Grammar" - Hey Now', null);
+      expect(node, hasLength(27));
+      expect(
+          node.toDelta(), new Delta()..insert('London "Grammar" - Hey Now\n'));
+    });
+
+    test('insert into empty line with styles', () {
+      LineNode node = new 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()
+        ..insert('London "Grammar"', boldStyle.toJson())
+        ..insert(' - Hey Now')
+        ..insert('\n', NotusAttribute.h1.toJson());
+      expect(node.toDelta(), delta);
+    });
+
+    test('insert into non-empty line', () {
+      LineNode node = new 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'));
+    });
+
+    test('insert text with a line-break at the end of line', () {
+      root.insert(0, 'Hello world', null);
+      root.insert(11, '!!!\n', null);
+      expect(root.childCount, 2);
+
+      LineNode line = root.first;
+      expect(line, hasLength(15));
+      expect(line.toDelta(), new Delta()..insert('Hello world!!!\n'));
+
+      LineNode line2 = root.last;
+      expect(line2, hasLength(1));
+      expect(line2.toDelta(), new Delta()..insert('\n'));
+    });
+
+    test('insert into second text segment', () {
+      root.insert(0, 'Hello world', null);
+      root.retain(6, 5, boldStyle);
+      root.insert(11, '!!!', null);
+
+      LineNode line = root.first;
+      expect(line, hasLength(15));
+      Delta delta = new Delta()
+        ..insert('Hello ')
+        ..insert('world', boldStyle.toJson())
+        ..insert('!!!\n');
+      expect(line.toDelta(), delta);
+    });
+
+    test('format line', () {
+      root.insert(0, 'Hello world', null);
+      root.retain(11, 1, h1Style);
+
+      LineNode line = root.first;
+      expect(line, hasLength(12));
+
+      Delta delta = new Delta()
+        ..insert('Hello world')
+        ..insert('\n', NotusAttribute.h1.toJson());
+      expect(line.toDelta(), delta);
+    });
+
+    test('format line with inline attributes', () {
+      root.insert(0, 'Hello world', null);
+      expect(() {
+        root.retain(11, 1, boldStyle);
+      }, throwsA(const TypeMatcher<AssertionError>()));
+    });
+
+    test('format text inside line with block/line attributes', () {
+      root.insert(0, 'Hello world', null);
+      expect(() {
+        root.retain(10, 2, h1Style);
+      }, throwsA(const TypeMatcher<AssertionError>()));
+    });
+
+    test('format root line to unset block style', () {
+      final unsetBlock = new NotusStyle().put(NotusAttribute.block.unset);
+      root.insert(0, 'Hello world', null);
+      root.retain(11, 1, unsetBlock);
+      expect(root.childCount, 1);
+      expect(root.first, const TypeMatcher<LineNode>());
+      LineNode line = root.first;
+      expect(line.style.contains(NotusAttribute.block), isFalse);
+    });
+
+    test('format multiple empty lines', () {
+      root.insert(0, 'Hello world\n\n\n', null);
+      root.retain(11, 3, ulStyle);
+      expect(root.children, hasLength(2));
+      BlockNode block = root.first;
+      expect(block.children, hasLength(3));
+      expect(block.toPlainText(), 'Hello world\n\n\n');
+    });
+
+    test('delete a line', () {
+      root.insert(0, 'Hello world', null);
+      root.delete(0, 12);
+      expect(root, isEmpty);
+      // TODO: this should really enforce at least one empty line.
+    });
+
+    test('delete from the middle of a line', () {
+      root.insert(0, 'Hello world', null);
+      root.delete(4, 3);
+      root.delete(6, 1);
+      expect(root.childCount, 1);
+      LineNode line = root.first;
+      expect(line, hasLength(8));
+      expect(line.childCount, 1);
+      Delta lineDelta = new Delta()..insert('Hellord\n');
+      expect(line.toDelta(), lineDelta);
+    });
+
+    test('delete from non-first segment in line', () {
+      root.insert(0, 'Hello world, Ab cd ef!', null);
+      root.retain(6, 5, boldStyle);
+      root.delete(10, 5);
+      expect(root.childCount, 1);
+      LineNode line = root.first;
+      expect(line, hasLength(18));
+      Delta lineDelta = new Delta()
+        ..insert('Hello ')
+        ..insert('worl', boldStyle.toJson())
+        ..insert(' cd ef!\n');
+      expect(line.toDelta(), lineDelta);
+    });
+
+    test('delete on multiple lines', () {
+      root.insert(0, 'delete\nmultiple\nlines', null);
+      root.retain(21, 1, h2Style);
+      root.delete(3, 15);
+      expect(root.childCount, 1);
+      LineNode line = root.first;
+      expect(line.childCount, 1);
+      final delta = new Delta()
+        ..insert('delnes')
+        ..insert('\n', h2Style.toJson());
+      expect(line.toDelta(), delta);
+    });
+
+    test('delete empty line', () {
+      root.insert(
+          0, 'Hello world\nThis is my first multiline\n\ndocument.', null);
+      expect(root.childCount, 4);
+      root.delete(39, 1);
+      expect(root.childCount, 3);
+    });
+
+    test('delete line-break of non-empty line', () {
+      root.insert(
+          0, 'Hello world\nThis is my first multiline\n\ndocument.', null);
+      root.retain(39, 1, h2Style);
+      expect(root.childCount, 4);
+      root.delete(38, 1);
+      expect(root.childCount, 3);
+      LineNode line = root.children.elementAt(1);
+      expect(line.style.get(NotusAttribute.heading), NotusAttribute.h2);
+    });
+
+    test('insert at the beginning of a line', () {
+      root.insert(
+          0, 'Hello world\nThis is my first multiline\ndocument.', null);
+      root.insert(12, 'Boom! ', null);
+      expect(root.childCount, 3);
+      expect(root.children.elementAt(1), hasLength(33));
+    });
+
+    test('delete last character of a line', () {
+      root.insert(
+          0, 'Hello world\nThis is my first multiline\ndocument.', null);
+      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'));
+    });
+
+    test('collectStyle', () {
+      // TODO: need more test cases for collectStyle
+      root.insert(
+          0, 'Hello world\nThis is my first multiline\n\ndocument.', null);
+      root.retain(38, 1, h2Style);
+      root.retain(23, 5, boldStyle);
+      var result = root.lookup(20);
+      LineNode line = result.node;
+      var attrs = line.collectStyle(result.offset, 5);
+      expect(attrs, h2Style);
+    });
+  });
+}

packages/notus/test/document/node_test.dart

@@ -0,0 +1,46 @@
+// 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';
+
+void main() {
+  group('$Node', () {
+    RootNode root;
+    setUp(() {
+      root = new RootNode();
+    });
+
+    test('mounted', () {
+      LineNode line = new LineNode();
+      TextNode text = new TextNode();
+      expect(text.mounted, isFalse);
+      line.add(text);
+      expect(text.mounted, isTrue);
+    });
+
+    test('offset', () {
+      root.insert(0, 'First line\nSecond line', null);
+      expect(root.children.first.offset, 0);
+      expect(root.children.elementAt(1).offset, 11);
+    });
+
+    test('documentOffset', () {
+      root.insert(0, 'First line\nSecond line', null);
+      LineNode line = root.children.last;
+      TextNode text = line.first;
+      expect(line.documentOffset, 11);
+      expect(text.documentOffset, 11);
+    });
+
+    test('containsOffset', () {
+      root.insert(0, 'First line\nSecond line', null);
+      LineNode line = root.children.last;
+      TextNode text = line.first;
+      expect(line.containsOffset(10), isFalse);
+      expect(line.containsOffset(12), isTrue);
+      expect(text.containsOffset(10), isFalse);
+      expect(text.containsOffset(12), isTrue);
+    });
+  });
+}

packages/notus/test/document/text_test.dart

@@ -0,0 +1,114 @@
+// 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';
+
+final boldStyle = new NotusStyle().merge(NotusAttribute.bold);
+final boldUnsetStyle = new NotusStyle().put(NotusAttribute.bold.unset);
+final italicStyle = new NotusStyle().merge(NotusAttribute.italic);
+
+void main() {
+  group('$TextNode', () {
+    LineNode line;
+    TextNode node;
+
+    setUp(() {
+      line = new LineNode();
+      node = new TextNode('London "Grammar"');
+      line.add(node);
+    });
+
+    test('new empty text', () {
+      final node = new TextNode();
+      expect(node.value, isEmpty);
+      expect(node.length, 0);
+      expect(node.style, new NotusStyle());
+      expect(node.toDelta(), isEmpty);
+    });
+
+    test('toString', () {
+      node.applyAttribute(NotusAttribute.bold);
+      node.applyAttribute(NotusAttribute.link.fromString('link'));
+      expect('$node', '⟨London "Grammar"⟩ab');
+    });
+
+    test('new text with contents', () {
+      expect(node.value, isNotEmpty);
+      expect(node.length, 16);
+      expect(
+          node.toDelta().toList(), [new Operation.insert('London "Grammar"')]);
+    });
+
+    test('insert at the end', () {
+      node.insert(16, '!!!', null);
+      expect(node.value, 'London "Grammar"!!!');
+    });
+
+    test('delete tail', () {
+      node.delete(6, 10);
+      expect(node.value, 'London');
+    });
+
+    test('format substring', () {
+      node.retain(8, 7, boldStyle);
+      expect(line.children, hasLength(3));
+      expect(line.children.elementAt(0), hasLength(8));
+      expect(line.children.elementAt(1), hasLength(7));
+      expect(line.children.elementAt(2), hasLength(1));
+    });
+
+    test('format full segment', () {
+      node.retain(0, 16, boldStyle);
+      expect(line.childCount, 1);
+      expect(node.value, 'London "Grammar"');
+      expect(node.style.values, [NotusAttribute.bold]);
+    });
+
+    test('format with multiple styles', () {
+      line.retain(0, 6, boldStyle);
+      line.retain(0, 6, italicStyle);
+      expect(line.childCount, 2);
+    });
+
+    test('format to remove attribute', () {
+      line.retain(0, 6, boldStyle);
+      line.retain(0, 6, boldUnsetStyle);
+      expect(line.childCount, 1);
+
+      expect(node.value, 'London "Grammar"');
+      expect(node.style, isEmpty);
+    });
+
+    test('format intersecting nodes', () {
+      line.retain(0, 6, boldStyle);
+      line.retain(3, 10, italicStyle);
+      expect(line.childCount, 4);
+      expect(line.children.elementAt(0), hasLength(3));
+      expect(line.children.elementAt(1), hasLength(3));
+      expect(line.children.elementAt(2), hasLength(7));
+      expect(line.children.elementAt(3), hasLength(3));
+    });
+
+    test('insert in formatted node', () {
+      line.retain(0, 6, boldStyle);
+      expect(line.childCount, 2);
+      line.insert(3, 'don', null);
+      expect(line.childCount, 4);
+      final b = boldStyle.toJson();
+      expect(
+        line.children.elementAt(0).toDelta(),
+        new Delta()..insert('Lon', b),
+      );
+      expect(
+        line.children.elementAt(1).toDelta(),
+        new Delta()..insert('don'),
+      );
+      expect(
+        line.children.elementAt(2).toDelta(),
+        new Delta()..insert('don', b),
+      );
+    });
+  });
+}

packages/notus/test/document_test.dart

@@ -0,0 +1,304 @@
+// 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 'dart:convert';
+
+import 'package:test/test.dart';
+import 'package:quill_delta/quill_delta.dart';
+import 'package:notus/notus.dart';
+import 'matchers.dart';
+
+NotusDocument dartconfDoc() {
+  Delta delta = new Delta()..insert('DartConf\nLos Angeles\n');
+  return new NotusDocument.fromDelta(delta);
+}
+
+final ul = NotusAttribute.ul.toJson();
+final h1 = NotusAttribute.h1.toJson();
+
+void main() {
+  group('$NotusDocument', () {
+    test('validates for doc delta', () {
+      var badDelta = new Delta()
+        ..insert('Text')
+        ..retain(5)
+        ..insert('\n');
+      expect(() {
+        new NotusDocument.fromDelta(badDelta);
+      }, throwsArgumentError);
+    });
+
+    test('empty document contains single empty line', () {
+      NotusDocument doc = new NotusDocument();
+      expect(doc.toPlainText(), '\n');
+    });
+
+    test('json serialization', () {
+      final original = dartconfDoc();
+      final jsonData = json.encode(original);
+      final doc = NotusDocument.fromJson(json.decode(jsonData));
+      expect(doc.toDelta(), original.toDelta());
+      expect(json.encode(doc), jsonData);
+    });
+
+    test('length', () {
+      final doc = dartconfDoc();
+      expect(doc.length, 21);
+    });
+
+    test('toString', () {
+      NotusDocument doc = dartconfDoc();
+      expect(doc.toString(), doc.toString());
+    });
+
+    test('load non-empty document', () {
+      NotusDocument doc = dartconfDoc();
+      expect(doc.toPlainText(), 'DartConf\nLos Angeles\n');
+    });
+
+    test('document delta must end with line-break', () {
+      Delta delta = new Delta()..insert('DartConf\nLos Angeles');
+      expect(() {
+        new NotusDocument.fromDelta(delta);
+      }, throwsA(const TypeMatcher<AssertionError>()));
+    });
+
+    test('lookupLine', () {
+      final doc = dartconfDoc();
+      doc.format(20, 1, NotusAttribute.bq);
+      var line1 = doc.lookupLine(3);
+      var line2 = doc.lookupLine(13);
+
+      expect(line1.node, const TypeMatcher<LineNode>());
+      expect(line1.node.toPlainText(), 'DartConf\n');
+      expect(line2.node, const TypeMatcher<LineNode>());
+      expect(line2.node.toPlainText(), 'Los Angeles\n');
+    });
+
+    test('format applies heuristics', () {
+      NotusDocument 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();
+      var changeList = doc.changes.toList();
+      var change = doc.format(1, 0, NotusAttribute.bold);
+      doc.close();
+      var changes = await changeList;
+      expect(change, isEmpty);
+      expect(changes, isEmpty);
+    });
+
+    test('format returns actual change delta', () {
+      NotusDocument doc = dartconfDoc();
+      final change = doc.format(0, 15, NotusAttribute.ul);
+      final expectedChange = new Delta()
+        ..retain(8)
+        ..retain(1, ul)
+        ..retain(11)
+        ..retain(1, ul);
+      expect(change, expectedChange);
+    });
+
+    test('format updates document delta', () {
+      NotusDocument doc = dartconfDoc();
+      doc.format(0, 15, NotusAttribute.ul);
+      final expectedDoc = new Delta()
+        ..insert('DartConf')
+        ..insert('\n', ul)
+        ..insert('Los Angeles')
+        ..insert('\n', ul);
+      expect(doc.toDelta(), expectedDoc);
+    });
+
+    test('format allows zero-length updates', () {
+      NotusDocument doc = dartconfDoc();
+      doc.format(0, 0, NotusAttribute.ul);
+      final expectedDoc = new Delta()
+        ..insert('DartConf')
+        ..insert('\n', ul)
+        ..insert('Los Angeles')
+        ..insert('\n');
+      expect(doc.toDelta(), expectedDoc);
+    });
+
+    test('insert applies heuristics', () {
+      NotusDocument doc = dartconfDoc();
+      doc.format(0, 15, NotusAttribute.ul);
+      doc.insert(8, '\n');
+      expect(doc.root.children, hasLength(1));
+      expect(doc.root.children.first, const TypeMatcher<BlockNode>());
+    });
+
+    test('insert returns actual change delta', () {
+      NotusDocument doc = dartconfDoc();
+      doc.format(0, 15, NotusAttribute.ul);
+      final change = doc.insert(8, '\n');
+      final expectedChange = new Delta()
+        ..retain(8)
+        ..insert('\n', ul);
+      expect(change, expectedChange);
+    });
+
+    test('insert updates document delta', () {
+      NotusDocument doc = dartconfDoc();
+      doc.format(0, 15, NotusAttribute.ul);
+      doc.insert(8, '\n');
+      final expectedDoc = new Delta()
+        ..insert('DartConf')
+        ..insert('\n\n', ul)
+        ..insert('Los Angeles')
+        ..insert('\n', ul);
+      expect(doc.toDelta(), expectedDoc);
+    });
+
+    test('insert throws assert error if change is empty', () {
+      NotusDocument doc = dartconfDoc();
+      expect(() {
+        doc.insert(8, '');
+      }, throwsA(const TypeMatcher<AssertionError>()));
+    });
+
+    test('replace throws assert error if change is empty', () {
+      NotusDocument doc = dartconfDoc();
+      expect(() {
+        doc.replace(8, 0, '');
+      }, throwsA(const TypeMatcher<AssertionError>()));
+    });
+
+    test('compose throws assert error if change is empty', () {
+      NotusDocument doc = dartconfDoc();
+      expect(() {
+        doc.compose(new Delta()..retain(1), ChangeSource.local);
+      }, throwsA(const TypeMatcher<AssertionError>()));
+    });
+
+    test('replace applies heuristic rules', () {
+      NotusDocument doc = dartconfDoc();
+      doc.format(0, 0, NotusAttribute.h1);
+      doc.replace(8, 1, ' ');
+      expect(doc.root.children, hasLength(1));
+      LineNode line = doc.root.children.first;
+      expect(line.style.get(NotusAttribute.heading), NotusAttribute.h1);
+      expect(line.toPlainText(), 'DartConf Los Angeles\n');
+    });
+
+    test('delete applies heuristic rules', () {
+      NotusDocument doc = dartconfDoc();
+      doc.format(0, 0, NotusAttribute.h1);
+      doc.delete(8, 1);
+      expect(doc.root.children, hasLength(1));
+      LineNode line = doc.root.children.first;
+      expect(line.style.get(NotusAttribute.heading), NotusAttribute.h1);
+    });
+
+    test('checks for closed state', () {
+      final doc = dartconfDoc();
+      expect(doc.isClosed, isFalse);
+      doc.close();
+      expect(doc.isClosed, isTrue);
+      expect(() {
+        doc.compose(new Delta()..insert('a'), ChangeSource.local);
+      }, throwsAssertionError);
+      expect(() {
+        doc.insert(0, 'a');
+      }, throwsAssertionError);
+      expect(() {
+        doc.format(0, 1, NotusAttribute.bold);
+      }, throwsAssertionError);
+      expect(() {
+        doc.delete(0, 1);
+      }, throwsAssertionError);
+    });
+
+    test('collectStyle', () {
+      final doc = dartconfDoc();
+      final style = doc.collectStyle(0, 10);
+      expect(style, isNotNull);
+    });
+
+    test('insert embed after newline', () {
+      final doc = dartconfDoc();
+      doc.insert(9, const HorizontalRuleEmbed());
+      expect(doc.root.children, hasLength(3));
+      expect(doc.root.first.toPlainText(), 'DartConf\n');
+      expect(doc.root.last.toPlainText(), 'Los Angeles\n');
+      LineNode line = doc.root.children.elementAt(1);
+      EmbedNode embed = line.first;
+      expect(embed.toPlainText(), EmbedNode.kPlainTextPlaceholder);
+      final style = new NotusStyle().merge(NotusAttribute.embed.horizontalRule);
+      expect(embed.style, style);
+    });
+
+    test('insert embed before newline', () {
+      final doc = dartconfDoc();
+      doc.insert(8, const HorizontalRuleEmbed());
+      expect(doc.root.children, hasLength(3));
+      expect(doc.root.first.toPlainText(), 'DartConf\n');
+      expect(doc.root.last.toPlainText(), 'Los Angeles\n');
+      LineNode line = doc.root.children.elementAt(1);
+      EmbedNode embed = line.first;
+      expect(embed.toPlainText(), EmbedNode.kPlainTextPlaceholder);
+      final style = new NotusStyle().merge(NotusAttribute.embed.horizontalRule);
+      expect(embed.style, style);
+    });
+
+    test('insert embed in the middle of a line', () {
+      final doc = dartconfDoc();
+      doc.insert(4, const HorizontalRuleEmbed());
+      expect(doc.root.children, hasLength(4));
+      expect(doc.root.children.elementAt(0).toPlainText(), 'Dart\n');
+      expect(doc.root.children.elementAt(1).toPlainText(),
+          '${EmbedNode.kPlainTextPlaceholder}\n');
+      expect(doc.root.children.elementAt(2).toPlainText(), 'Conf\n');
+      expect(doc.root.children.elementAt(3).toPlainText(), 'Los Angeles\n');
+      LineNode line = doc.root.children.elementAt(1);
+      EmbedNode embed = line.first;
+      expect(embed.toPlainText(), EmbedNode.kPlainTextPlaceholder);
+      final style = new NotusStyle().merge(NotusAttribute.embed.horizontalRule);
+      expect(embed.style, style);
+    });
+
+    test('delete embed', () {
+      final doc = dartconfDoc();
+      doc.insert(8, const HorizontalRuleEmbed());
+      expect(doc.root.children, hasLength(3));
+      doc.delete(9, 1);
+      expect(doc.root.children, hasLength(3));
+      LineNode line = doc.root.children.elementAt(1);
+      expect(line, isEmpty);
+    });
+
+    test('insert text containing zero-width space', () {
+      final doc = dartconfDoc();
+      final change = doc.insert(0, EmbedNode.kPlainTextPlaceholder);
+      expect(change, isEmpty);
+      expect(doc.length, 21);
+    });
+
+    test('insert text before embed', () {
+      final doc = dartconfDoc();
+      doc.insert(8, const HorizontalRuleEmbed());
+      expect(doc.root.children, hasLength(3));
+      doc.insert(9, 'text');
+      expect(doc.root.children, hasLength(4));
+      expect(doc.root.children.elementAt(1).toPlainText(), 'text\n');
+      expect(doc.root.children.elementAt(2).toPlainText(),
+          '${EmbedNode.kPlainTextPlaceholder}\n');
+    });
+
+    test('insert text after embed', () {
+      final doc = dartconfDoc();
+      doc.insert(8, const HorizontalRuleEmbed());
+      expect(doc.root.children, hasLength(3));
+      doc.insert(10, 'text');
+      expect(doc.root.children, hasLength(4));
+      expect(doc.root.children.elementAt(1).toPlainText(),
+          '${EmbedNode.kPlainTextPlaceholder}\n');
+      expect(doc.root.children.elementAt(2).toPlainText(), 'text\n');
+    });
+  });
+}

packages/notus/test/heuristics/delete_rules_test.dart

@@ -0,0 +1,57 @@
+// 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';
+
+final ul = NotusAttribute.ul.toJson();
+final bold = NotusAttribute.bold.toJson();
+
+void main() {
+  group('$PreserveLineStyleOnMergeRule', () {
+    final rule = new PreserveLineStyleOnMergeRule();
+    test('preserves block style', () {
+      final ul = NotusAttribute.ul.toJson();
+      final doc = new Delta()
+        ..insert('Title\nOne')
+        ..insert('\n', ul)
+        ..insert('Two\n');
+      final actual = rule.apply(doc, 9, 1);
+      final expected = new Delta()
+        ..retain(9)
+        ..delete(1)
+        ..retain(3)
+        ..retain(1, ul);
+      expect(actual, expected);
+    });
+
+    test('resets block style', () {
+      final unsetUl = NotusAttribute.block.unset.toJson();
+      final doc = new Delta()
+        ..insert('Title\nOne')
+        ..insert('\n', NotusAttribute.ul.toJson())
+        ..insert('Two\n');
+      final actual = rule.apply(doc, 5, 1);
+      final expected = new Delta()
+        ..retain(5)
+        ..delete(1)
+        ..retain(3)
+        ..retain(1, unsetUl);
+      expect(actual, expected);
+    });
+  });
+
+  group('$CatchAllDeleteRule', () {
+    final rule = new CatchAllDeleteRule();
+
+    test('applies change as-is', () {
+      final doc = new Delta()..insert('Document\n');
+      final actual = rule.apply(doc, 3, 5);
+      final expected = new Delta()
+        ..retain(3)
+        ..delete(5);
+      expect(actual, expected);
+    });
+  });
+}

packages/notus/test/heuristics/format_rules_test.dart

@@ -0,0 +1,96 @@
+// 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';
+
+final ul = NotusAttribute.ul.toJson();
+final bold = NotusAttribute.bold.toJson();
+
+void main() {
+  group('$ResolveLineFormatRule', () {
+    final rule = new ResolveLineFormatRule();
+
+    test('apply', () {
+      final doc = new 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()
+        ..retain(7)
+        ..retain(1, ul)
+        ..retain(4)
+        ..retain(1, ul)
+        ..retain(5)
+        ..retain(1, ul)
+        ..retain(4)
+        ..retain(1, ul);
+      expect(actual, expected);
+    });
+
+    test('apply with zero length (collapsed selection)', () {
+      final doc = new 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);
+      expect(actual, expected);
+    });
+
+    test('apply with zero length in the middle of a line', () {
+      final ul = NotusAttribute.ul.toJson();
+      final doc = new 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);
+      expect(actual, expected);
+    });
+  });
+
+  group('$ResolveInlineFormatRule', () {
+    final rule = new ResolveInlineFormatRule();
+
+    test('apply', () {
+      final doc = new 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()
+        ..retain(7, b)
+        ..retain(1)
+        ..retain(4, b)
+        ..retain(1)
+        ..retain(5, b)
+        ..retain(1)
+        ..retain(1, b);
+      expect(actual, expected);
+    });
+  });
+
+  group('$FormatLinkAtCaretPositionRule', () {
+    final rule = new 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()
+        ..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());
+      expect(actual, expected);
+    });
+  });
+}

packages/notus/test/heuristics/insert_rules_test.dart

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

packages/notus/test/heuristics_test.dart

@@ -0,0 +1,40 @@
+// 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:notus/notus.dart';
+import 'package:quill_delta/quill_delta.dart';
+import 'package:test/test.dart';
+
+NotusDocument dartconfDoc() {
+  Delta delta = new Delta()..insert('DartConf\nLos Angeles\n');
+  return new NotusDocument.fromDelta(delta);
+}
+
+final ul = NotusAttribute.ul.toJson();
+final h1 = NotusAttribute.h1.toJson();
+
+void main() {
+  group('$NotusHeuristics', () {
+    test('ensures heuristics are applied', () {
+      final doc = dartconfDoc();
+      final heuristics = new NotusHeuristics(
+        formatRules: [],
+        insertRules: [],
+        deleteRules: [],
+      );
+
+      expect(() {
+        heuristics.applyInsertRules(doc, 0, 'a');
+      }, throwsStateError);
+
+      expect(() {
+        heuristics.applyDeleteRules(doc, 0, 1);
+      }, throwsStateError);
+
+      expect(() {
+        heuristics.applyFormatRules(doc, 0, 1, NotusAttribute.bold);
+      }, throwsStateError);
+    });
+  });
+}

packages/notus/test/matchers.dart

@@ -0,0 +1,11 @@
+// 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';
+
+const isAssertionError = const TypeMatcher<AssertionError>();
+
+const Matcher throwsAssertionError =
+    // ignore: deprecated_member_use
+    const Throws(isAssertionError);