Refactor Container

lib/models/documents/nodes/block.dart

@@ -1,6 +1,16 @@
+import 'package:quill_delta/quill_delta.dart';
+
+import 'container.dart';
 import 'line.dart';
-import 'node.dart';
 
 class Block extends Container<Line> {
+  @override
+  Line get defaultChild => Line();
 
-}
+  @override
+  Delta toDelta() {
+    return children
+        .map((child) => child.toDelta())
+        .fold(Delta(), (a, b) => a.concat(b));
+  }
+}

lib/models/documents/nodes/container.dart

@@ -0,0 +1,53 @@
+import 'dart:collection';
+
+import 'node.dart';
+
+/* Container of multiple nodes */
+abstract class Container<T extends Node> extends Node {
+  final LinkedList<Node> _children = LinkedList<Node>();
+
+  LinkedList<Node> get children => _children;
+
+  int get childCount => _children.length;
+
+  Node get first => _children.first;
+
+  Node get last => _children.last;
+
+  bool get isEmpty => _children.isEmpty;
+
+  bool get isNotEmpty => _children.isNotEmpty;
+
+  /// abstract methods begin
+
+  T get defaultChild;
+
+  /// abstract methods end
+
+  add(T node) {
+    assert(node.parent == null);
+    node.parent = this;
+    _children.add(node);
+  }
+
+  addFirst(T node) {
+    assert(node.parent == null);
+    node.parent = this;
+    _children.addFirst(node);
+  }
+
+  void remove(T node) {
+    assert(node.parent == this);
+    node.parent = null;
+    _children.remove(node);
+  }
+
+  @override
+  String toPlainText() => children.map((child) => child.toPlainText()).join();
+
+  @override
+  int get length => _children.fold(0, (cur, node) => cur + node.length);
+
+  @override
+  String toString() => _children.join('\n');
+}

lib/models/documents/nodes/leaf.dart

@@ -1,5 +1,42 @@
+import 'package:quill_delta/quill_delta.dart';
+
 import 'node.dart';
 
 /* A leaf node in document tree */
 abstract class Leaf extends Node {
+  Object _value;
+
+  Object get value => _value;
+
+  Leaf.val(Object val)
+      : assert(val != null),
+        _value = val;
+
+  @override
+  int get length {
+    if (_value is String) {
+      return (_value as String).length;
+    }
+    // return 1 for embedded object
+    return 1;
+  }
+
+  @override
+  Delta toDelta() {
+    return null; // TODO
+  }
+}
+
+class Text extends Leaf {
+  Text([String text = ''])
+      : assert(!text.contains('\n')),
+        super.val(text);
+
+  @override
+  String get value => _value as String;
+
+  @override
+  String toPlainText() {
+    return value;
+  }
 }

lib/models/documents/nodes/line.dart

@@ -1,5 +1,31 @@
+import 'package:quill_delta/quill_delta.dart';
+
+import 'block.dart';
+import 'container.dart';
 import 'leaf.dart';
-import 'node.dart';
 
 class Line extends Container<Leaf> {
+
+  @override
+  Leaf get defaultChild => Text();
+
+  @override
+  int get length => super.length + 1;
+
+  @override
+  Delta toDelta() {
+    final delta = children
+        .map((child) => child.toDelta())
+        .fold(Delta(), (a, b) => a.concat(b));
+    var attributes = style;
+    if (parent is Block) {
+      Block block = parent;
+      attributes = attributes.mergeAll(block.style);
+    }
+    delta.insert('\n', attributes.toJson());
+    return delta;
+  }
+
+  @override
+  String toPlainText() => super.toPlainText() + '\n';
 }

lib/models/documents/nodes/node.dart

@@ -1,18 +1,19 @@
 import 'dart:collection';
 
 import 'package:flutter_quill/models/documents/style.dart';
+import 'package:quill_delta/quill_delta.dart';
 
 import '../attribute.dart';
+import 'container.dart';
+import 'line.dart';
 
 /* node in a document tree */
-class Node extends LinkedListEntry<Node> {
-  Container _parent;
+abstract class Node extends LinkedListEntry<Node> {
+  Container parent;
   Style _style = Style();
 
   Style get style => _style;
 
-  Container get parent => _parent;
-
   void applyAttribute(Attribute attribute) {
     _style = _style.merge(attribute);
   }
@@ -32,29 +33,46 @@ class Node extends LinkedListEntry<Node> {
 
   bool get isLast => list.last == this;
 
+  int get length;
+
   @override
   void insertBefore(Node entry) {
-    assert(entry._parent == null && _parent != null);
-    entry._parent = _parent;
+    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;
+    assert(entry.parent == null && parent != null);
+    entry.parent = parent;
     super.insertAfter(entry);
   }
 
   @override
   void unlink() {
-    assert(_parent != null);
-    _parent = null;
+    assert(parent != null);
+    parent = null;
     super.unlink();
   }
-}
 
-abstract class Container<T extends Node> extends Node {}
+  /// abstract methods begin
+
+  String toPlainText();
+
+  Delta toDelta();
+
+  /// abstract methods end
+
+}
 
 /* Root node of document tree */
-class Root extends Container<Container<Node>> {}
+class Root extends Container<Container<Node>> {
+  @override
+  Container<Node> get defaultChild => Line();
+
+  @override
+  Delta toDelta() => children
+      .map((child) => child.toDelta())
+      .fold(Delta(), (a, b) => a.concat(b));
+}

lib/models/documents/style.dart

@@ -20,6 +20,11 @@ class Style {
     return Style.attr(result);
   }
 
+  Map<String, dynamic> toJson() => _attributes.isEmpty
+      ? null
+      : _attributes.map<String, dynamic>((String _, Attribute value) =>
+          MapEntry<String, dynamic>(value.key, value.value));
+
   Iterable<String> get keys => _attributes.keys;
 
   Iterable<Attribute> get values => _attributes.values;