Fixes for embed-related rules

packages/notus/lib/src/document.dart

     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);
+    if (change.isNotEmpty) compose(change, ChangeSource.local);
     return change;
   }
 

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

 import 'leaf.dart';
 import 'node.dart';
 
-/// A line of text in a Notus document.
+/// A line of rich text in a Notus document.
 ///
 /// LineNode serves as a container for [LeafNode]s, like [TextNode] and
-/// [ImageNode].
+/// [EmbedNode].
+///
+/// When a line contains an embed, it fully occupies the line, no other embeds
+/// or text nodes are allowed.
 class LineNode extends ContainerNode<LeafNode>
     with StyledNodeMixin
     implements StyledNode {
+  /// Returns `true` if this line contains an embed.
+  bool get hasEmbed {
+    if (childCount == 1) {
+      return children.single is EmbedNode;
+    }
+    assert(children.every((child) => child is TextNode));
+    return false;
+  }
+
   /// Returns next [LineNode] or `null` if this is the last line in the document.
   LineNode get nextLine {
     if (isLast) {
     }
 
     final data = lookup(offset, inclusive: true);
-    TextNode node = data.node;
+    LeafNode node = data.node;
     if (node != null) {
       result = result.mergeAll(node.style);
       int pos = node.length - data.offset;

packages/notus/lib/src/heuristics.dart

       CatchAllInsertRule(),
     ],
     deleteRules: [
+      EnsureEmbedLineRule(),
       PreserveLineStyleOnMergeRule(),
       CatchAllDeleteRule(),
     ],

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

 // 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 delete operations.
 abstract class DeleteRule {
     return attributes.map((key, value) => new MapEntry(key, null));
   }
 }
+
+/// Prevents user from merging line containing an embed with other lines.
+class EnsureEmbedLineRule extends DeleteRule {
+  const EnsureEmbedLineRule();
+
+  @override
+  Delta apply(Delta document, int index, int length) {
+    DeltaIterator iter = new DeltaIterator(document);
+    // First, check if line-break deleted after an embed.
+    Operation op = iter.skip(index);
+    int indexDelta = 0;
+    int lengthDelta = 0;
+    int remaining = length;
+    bool foundEmbed = false;
+    if (op != null && op.data.endsWith(kZeroWidthSpace)) {
+      foundEmbed = true;
+      Operation candidate = iter.next(1);
+      remaining--;
+      if (candidate.data == '\n') {
+        indexDelta += 1;
+        lengthDelta -= 1;
+
+        /// Check if it's an empty line
+        candidate = iter.next(1);
+        remaining--;
+        if (candidate.data == '\n') {
+          // Allow deleting empty line after an embed.
+          lengthDelta += 1;
+        }
+      }
+    }
+
+    // Second, check if line-break deleted before an embed.
+    op = iter.skip(remaining);
+    if (op != null && op.data.endsWith('\n')) {
+      final candidate = iter.next(1);
+      if (candidate.data == kZeroWidthSpace) {
+        foundEmbed = true;
+        lengthDelta -= 1;
+      }
+    }
+    if (foundEmbed) {
+      return new Delta()
+        ..retain(index + indexDelta)
+        ..delete(length + lengthDelta);
+    }
+
+    return null; // fallback
+  }
+}

packages/notus/pubspec.yaml

 homepage: https://github.com/memspace/notus
 
 environment:
-  sdk: '>=2.0.0-dev.64.0 <2.0.0'
+  sdk: '>=2.0.0-dev.63.0 <2.0.0'
 
 dependencies:
   collection: ^1.14.6

packages/notus/test/document/line_test.dart

       expect(node.toDelta().toList(), [new Operation.insert('\n')]);
     });
 
+    test('hasEmbed', () {
+      LineNode node = new LineNode();
+      expect(node.hasEmbed, isFalse);
+      node.add(new EmbedNode());
+      expect(node.hasEmbed, isTrue);
+    });
+
     test('nextLine', () {
       root.insert(
           0, 'Hello world\nThis is my first multiline\nItem\ndocument.', null);
       expect('$node', '¶ ⟨London "Grammar"⟩b → ⟨ - Hey Now⟩ ⏎ {heading: 1}');
     });
 
-    test('splitAt with multiple text segments', (){
+    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);
       expect(node.toDelta(), new Delta()..insert('Hello world!!!\n'));
     });
 
-    test('insert text with a line-break at the end of line', () {
+    test('insert text with line-break at the end of line', () {
       root.insert(0, 'Hello world', null);
       root.insert(11, '!!!\n', null);
       expect(root.childCount, 2);
       var attrs = line.collectStyle(result.offset, 5);
       expect(attrs, h2Style);
     });
+
+    test('collectStyle with embed nodes', () {
+      root.insert(0, 'Hello world\n\nMore text.\n', null);
+      NotusStyle style = new NotusStyle();
+      style = style.put(NotusAttribute.embed.horizontalRule);
+      root.insert(12, EmbedNode.kPlainTextPlaceholder, style);
+
+      var lookup = root.lookup(0);
+      LineNode line = lookup.node;
+      var result = line.collectStyle(lookup.offset, 15);
+      expect(result, isEmpty);
+    });
   });
 }

packages/notus/test/document_test.dart

   return new NotusDocument.fromDelta(delta);
 }
 
+NotusDocument dartconfEmbedDoc() {
+  final hr = NotusAttribute.embed.horizontalRule.toJson();
+  Delta delta = new Delta()
+    ..insert('DartConf\n')
+    ..insert(kZeroWidthSpace, hr)
+    ..insert('\n')
+    ..insert('Los Angeles\n');
+  return new NotusDocument.fromDelta(delta);
+}
+
 final ul = NotusAttribute.ul.toJson();
 final h1 = NotusAttribute.h1.toJson();
 
       expect(doc.toPlainText(), 'DartConf\nLos Angeles\n');
     });
 
-    test('document delta must end with line-break', () {
+    test('document delta must end with line-break character', () {
       Delta delta = new Delta()..insert('DartConf\nLos Angeles');
       expect(() {
         new NotusDocument.fromDelta(delta);
       expect(line.style.get(NotusAttribute.heading), NotusAttribute.h1);
     });
 
+    test('delete which results in an empty change', () {
+      // This test relies on a delete rule which ensures line-breaks around
+      // and embed.
+      NotusDocument doc = dartconfEmbedDoc();
+      doc.delete(8, 1);
+      expect(doc.toPlainText(), 'DartConf\n${kZeroWidthSpace}\nLos Angeles\n');
+    });
+
     test('checks for closed state', () {
       final doc = dartconfDoc();
       expect(doc.isClosed, isFalse);
       expect(style, isNotNull);
     });
 
-    test('insert embed after newline', () {
+    test('insert embed after line-break', () {
       final doc = dartconfDoc();
       doc.insert(9, const HorizontalRuleEmbed());
       expect(doc.root.children, hasLength(3));
       expect(embed.style, style);
     });
 
-    test('insert embed before newline', () {
+    test('insert embed before line-break', () {
       final doc = dartconfDoc();
       doc.insert(8, const HorizontalRuleEmbed());
       expect(doc.root.children, hasLength(3));

packages/notus/test/heuristics/delete_rules_test.dart

       expect(actual, expected);
     });
   });
+
+  group('$EnsureEmbedLineRule', () {
+    final rule = new EnsureEmbedLineRule();
+
+    test('ensures line-break before embed', () {
+      final hr = NotusAttribute.embed.horizontalRule;
+      final doc = new Delta()
+        ..insert('Document\n')
+        ..insert(kZeroWidthSpace, hr.toJson())
+        ..insert('\n');
+      final actual = rule.apply(doc, 8, 1);
+      final expected = new Delta()..retain(8);
+      expect(actual, expected);
+    });
+
+    test('ensures line-break after embed', () {
+      final hr = NotusAttribute.embed.horizontalRule;
+      final doc = new Delta()
+        ..insert('Document\n')
+        ..insert(kZeroWidthSpace, hr.toJson())
+        ..insert('\n');
+      final actual = rule.apply(doc, 10, 1);
+      final expected = new Delta()..retain(11);
+      expect(actual, expected);
+    });
+
+    test('still deletes everything between embeds', () {
+      final hr = NotusAttribute.embed.horizontalRule;
+      final doc = new Delta()
+        ..insert('Document\n')
+        ..insert(kZeroWidthSpace, hr.toJson())
+        ..insert('\nSome text\n')
+        ..insert(kZeroWidthSpace, hr.toJson())
+        ..insert('\n');
+      final actual = rule.apply(doc, 10, 11);
+      final expected = new Delta()
+        ..retain(11)
+        ..delete(9);
+      expect(actual, expected);
+    });
+
+    test('allows deleting empty line after embed', () {
+      final hr = NotusAttribute.embed.horizontalRule;
+      final doc = new Delta()
+        ..insert('Document\n')
+        ..insert(kZeroWidthSpace, hr.toJson())
+        ..insert('\n')
+        ..insert('\n', NotusAttribute.block.bulletList.toJson())
+        ..insert('Text')
+        ..insert('\n');
+      final actual = rule.apply(doc, 10, 1);
+      final expected = new Delta()
+        ..retain(11)
+        ..delete(1);
+      expect(actual, expected);
+    });
+  });
 }

packages/notus/test/heuristics/insert_rules_test.dart

   group('$AutoExitBlockRule', () {
     final rule = new AutoExitBlockRule();
 
-    test('applies for new line-break on empty line in a block', () {
+    test('applies when line-break is inserted on empty line in a block', () {
       final ul = NotusAttribute.ul.toJson();
       final doc = new Delta()
         ..insert('Item 1')