Implement moveChildUp operation for untab

Summary:
Implements a `moveChildUp` method to help with untab (`onTab` with shift key) in `NestedRichTextEditorUtil`.

This will move the first/last child up as the previous / next sibling of its parent.

These are the operations that are implemented (and they work as the test cases):

{F137866518}

Differential Revision: D9672458

fbshipit-source-id: f2ba306ae56d243071232f04bef2746c4a060dfb

Author: niveditc

src/model/modifier/exploration/DraftTreeOperations.js

@@ -289,10 +289,155 @@ const updateAsSiblingsChild = (
   return newBlockMap;
 };
 
+/**
+ * This is a utility method that abstracts the operation of moving a node up to become
+ * a sibling of its parent. If the operation results in a parent with no children,
+ * also delete the parent node.
+ *
+ * Can only operate on the first or last child (this is an invariant)
+ *
+ * This operation respects the tree data invariants - it expects and returns a
+ * valid tree.
+ */
+const moveChildUp = (blockMap: BlockMap, key: string): BlockMap => {
+  verifyTree(blockMap);
+  const block = blockMap.get(key);
+  invariant(block != null, 'block must exist in block map');
+
+  // if there is no parent, do nothing
+  const parentKey = block.getParentKey();
+  if (parentKey == null) {
+    return blockMap;
+  }
+
+  let parent = blockMap.get(parentKey);
+  invariant(parent !== null, 'parent must exist in block map');
+  let newBlockMap = blockMap;
+  const childIndex = parent.getChildKeys().indexOf(key);
+  invariant(
+    childIndex === 0 || childIndex === parent.getChildKeys().count() - 1,
+    'block is not first or last child of its parent',
+  );
+
+  // If it's the first child, move as previous sibling of parent
+  if (childIndex === 0) {
+    const parentPrevSibling = parent.getPrevSiblingKey();
+    newBlockMap = updateSibling(newBlockMap, key, parentKey);
+    // link to parent's previous sibling
+    if (parentPrevSibling != null) {
+      newBlockMap = updateSibling(newBlockMap, parentPrevSibling, key);
+    }
+    // remove as parent's child
+    parent = newBlockMap.get(parentKey);
+    newBlockMap = newBlockMap.set(
+      parentKey,
+      parent.merge({
+        children: parent.getChildKeys().slice(1),
+      }),
+    );
+    parent = newBlockMap.get(parentKey);
+    // remove as previous sibling of parent's children
+    if (parent.getChildKeys().count() > 0) {
+      const firstChildKey = parent.getChildKeys().first();
+      const firstChild = newBlockMap.get(firstChildKey);
+      newBlockMap = newBlockMap.set(
+        firstChildKey,
+        firstChild.merge({prevSibling: null}),
+      );
+    }
+    // add the node just before its former parent in the block map
+    newBlockMap = newBlockMap
+      .takeUntil(block => block.getKey() === parentKey)
+      .concat(
+        Immutable.OrderedMap([
+          [key, newBlockMap.get(key)],
+          [parentKey, newBlockMap.get(parentKey)],
+        ]),
+      )
+      .concat(newBlockMap.skipUntil(block => block.getKey() === key).slice(1));
+
+    // If it's the last child, move as next sibling of parent
+  } else if (childIndex === parent.getChildKeys().count() - 1) {
+    const parentNextSibling = parent.getNextSiblingKey();
+    newBlockMap = updateSibling(newBlockMap, parentKey, key);
+    // link to parent's next sibling
+    if (parentNextSibling != null) {
+      newBlockMap = updateSibling(newBlockMap, key, parentNextSibling);
+    }
+    // remove as parent's child
+    parent = newBlockMap.get(parentKey);
+    newBlockMap = newBlockMap.set(
+      parentKey,
+      parent.merge({
+        children: parent.getChildKeys().slice(0, -1),
+      }),
+    );
+    parent = newBlockMap.get(parentKey);
+    // remove as next sibling of parent's children
+    if (parent.getChildKeys().count() > 0) {
+      const lastChildKey = parent.getChildKeys().last();
+      const lastChild = newBlockMap.get(lastChildKey);
+      newBlockMap = newBlockMap.set(
+        lastChildKey,
+        lastChild.merge({nextSibling: null}),
+      );
+    }
+  }
+
+  // For both cases, also link to parent's parent
+  const grandparentKey = parent.getParentKey();
+  if (grandparentKey != null) {
+    const grandparentInsertPosition = newBlockMap
+      .get(grandparentKey)
+      .getChildKeys()
+      .findIndex(n => n === parentKey);
+    newBlockMap = updateParentChild(
+      newBlockMap,
+      grandparentKey,
+      key,
+      childIndex === 0
+        ? grandparentInsertPosition
+        : grandparentInsertPosition + 1,
+    );
+  } else {
+    newBlockMap = newBlockMap.set(
+      key,
+      newBlockMap.get(key).merge({parent: null}),
+    );
+  }
+
+  // Delete parent if it has no children
+  parent = newBlockMap.get(parentKey);
+  if (parent.getChildKeys().count() === 0) {
+    const prevSiblingKey = parent.getPrevSiblingKey();
+    const nextSiblingKey = parent.getNextSiblingKey();
+    if (prevSiblingKey != null && nextSiblingKey != null) {
+      newBlockMap = updateSibling(newBlockMap, prevSiblingKey, nextSiblingKey);
+    }
+    if (prevSiblingKey == null && nextSiblingKey != null) {
+      newBlockMap = newBlockMap.set(
+        nextSiblingKey,
+        newBlockMap.get(nextSiblingKey).merge({prevSibling: null}),
+      );
+    }
+    if (nextSiblingKey == null && prevSiblingKey != null) {
+      newBlockMap = newBlockMap.set(
+        prevSiblingKey,
+        newBlockMap.get(prevSiblingKey).merge({nextSibling: null}),
+      );
+    }
+    newBlockMap = newBlockMap.delete(parentKey);
+  }
+
+  verifyTree(newBlockMap);
+  return newBlockMap;
+};
+
 module.exports = {
   updateParentChild,
   replaceParentChild,
   updateSibling,
   createNewParent,
   updateAsSiblingsChild,
+  moveChildUp,
 };

src/model/modifier/exploration/__tests__/DraftTreeOperations-test.js

@@ -380,3 +380,167 @@ test("test creating a updating node to become previous sibling's child 2", () =>
     DraftTreeOperations.updateAsSiblingsChild(blockMap6, 'C', 'previous'),
   ).toMatchSnapshot();
 });
+
+test('test moving child up with no parent - no-op', () => {
+  expect(DraftTreeOperations.moveChildUp(blockMap3, 'B')).toMatchSnapshot();
+});
+
+test('test moving first child up 1', () => {
+  expect(DraftTreeOperations.moveChildUp(blockMap1, 'B')).toMatchSnapshot();
+});
+
+const blockMap7 = Immutable.OrderedMap({
+  X: new ContentBlockNode({
+    key: 'X',
+    parent: null,
+    text: '',
+    children: Immutable.List(['A', 'Y']),
+    prevSibling: null,
+    nextSibling: null,
+  }),
+  A: new ContentBlockNode({
+    key: 'A',
+    parent: 'X',
+    text: 'alpha',
+    children: Immutable.List([]),
+    prevSibling: null,
+    nextSibling: 'Y',
+  }),
+  Y: new ContentBlockNode({
+    key: 'Y',
+    parent: 'X',
+    text: '',
+    children: Immutable.List(['B', 'C']),
+    prevSibling: 'A',
+    nextSibling: null,
+  }),
+  B: new ContentBlockNode({
+    key: 'B',
+    parent: 'Y',
+    text: 'beta',
+    children: Immutable.List([]),
+    prevSibling: null,
+    nextSibling: 'C',
+  }),
+  C: new ContentBlockNode({
+    key: 'C',
+    parent: 'Y',
+    text: 'charlie',
+    children: Immutable.List([]),
+    prevSibling: 'B',
+    nextSibling: null,
+  }),
+});
+
+test('test moving first child up 2', () => {
+  expect(DraftTreeOperations.moveChildUp(blockMap7, 'B')).toMatchSnapshot();
+});
+
+test('test moving last child up 1', () => {
+  expect(DraftTreeOperations.moveChildUp(blockMap1, 'C')).toMatchSnapshot();
+});
+
+test('test moving last child up 2', () => {
+  expect(DraftTreeOperations.moveChildUp(blockMap7, 'C')).toMatchSnapshot();
+});
+
+const blockMap8 = Immutable.OrderedMap({
+  A: new ContentBlockNode({
+    key: 'A',
+    parent: null,
+    text: 'alpha',
+    children: Immutable.List([]),
+    prevSibling: null,
+    nextSibling: 'X',
+  }),
+  X: new ContentBlockNode({
+    key: 'X',
+    parent: null,
+    text: '',
+    children: Immutable.List(['B']),
+    prevSibling: 'A',
+    nextSibling: 'C',
+  }),
+  B: new ContentBlockNode({
+    key: 'B',
+    parent: 'X',
+    text: 'beta',
+    children: Immutable.List([]),
+    prevSibling: null,
+    nextSibling: null,
+  }),
+  C: new ContentBlockNode({
+    key: 'C',
+    parent: null,
+    text: 'charlie',
+    children: Immutable.List([]),
+    prevSibling: 'X',
+    nextSibling: null,
+  }),
+});
+
+test('test moving only child up deletes parent 1', () => {
+  expect(DraftTreeOperations.moveChildUp(blockMap8, 'B')).toMatchSnapshot();
+});
+
+const blockMap9 = Immutable.OrderedMap({
+  X: new ContentBlockNode({
+    key: 'X',
+    parent: null,
+    text: '',
+    children: Immutable.List(['B']),
+    prevSibling: null,
+    nextSibling: 'C',
+  }),
+  B: new ContentBlockNode({
+    key: 'B',
+    parent: 'X',
+    text: 'beta',
+    children: Immutable.List([]),
+    prevSibling: null,
+    nextSibling: null,
+  }),
+  C: new ContentBlockNode({
+    key: 'C',
+    parent: null,
+    text: 'charlie',
+    children: Immutable.List([]),
+    prevSibling: 'X',
+    nextSibling: null,
+  }),
+});
+
+test('test moving only child up deletes parent 2', () => {
+  expect(DraftTreeOperations.moveChildUp(blockMap9, 'B')).toMatchSnapshot();
+});
+
+const blockMap10 = Immutable.OrderedMap({
+  A: new ContentBlockNode({
+    key: 'A',
+    parent: null,
+    text: 'alpha',
+    children: Immutable.List([]),
+    prevSibling: null,
+    nextSibling: 'X',
+  }),
+  X: new ContentBlockNode({
+    key: 'X',
+    parent: null,
+    text: '',
+    children: Immutable.List(['B']),
+    prevSibling: 'A',
+    nextSibling: null,
+  }),
+  B: new ContentBlockNode({
+    key: 'B',
+    parent: 'X',
+    text: 'beta',
+    children: Immutable.List([]),
+    prevSibling: null,
+    nextSibling: null,
+  }),
+});
+
+test('test moving only child up deletes parent 3', () => {
+  expect(DraftTreeOperations.moveChildUp(blockMap10, 'B')).toMatchSnapshot();
+});