From 365c7418641af4c92c4148cc8b346c9147d0ecb6 Mon Sep 17 00:00:00 2001
From: Knut Sveidqvist <knut.sveidqvist@ipiccolo.com>
Date: Thu, 2 Apr 2020 19:35:12 +0200
Subject: [PATCH 01/12] #1295 Fix for intersection calculation for edges to
 clusters and adding concurrency in stateDiagrams as clusters

---
 cypress/platform/current.html             | 70 ++++++++++++++++++-----
 src/dagre-wrapper/GraphObjects.md         | 22 +++----
 src/dagre-wrapper/createLabel.js          |  6 +-
 src/dagre-wrapper/edges.js                | 47 +++++----------
 src/dagre-wrapper/index.js                | 64 ++++++++++++++++-----
 src/diagrams/flowchart/flowRenderer-v2.js |  4 --
 src/diagrams/state/stateDb.js             | 41 ++++++++++++-
 src/diagrams/state/stateRenderer-v2.js    | 22 +++----
 src/utils.js                              | 16 +++++-
 9 files changed, 194 insertions(+), 98 deletions(-)

diff --git a/cypress/platform/current.html b/cypress/platform/current.html
index cc4b9e862..6b52388a7 100644
--- a/cypress/platform/current.html
+++ b/cypress/platform/current.html
@@ -32,13 +32,31 @@
         G-->c
       </div>
       <div class="mermaid2" style="width: 50%; height: 20%;">
-        flowchart LR
-        subgraph id1 [Test]
-            b
-          end
-        a-->id1
+    stateDiagram-v2
+    [*] --> monkey
+    state monkey {
+              Sitting
+            --
+              Eating
+            }
       </div>
-      <div class="mermaid mermaid-apa" style="width: 100%; height: 20%;">
+      <div class="mermaid2" style="width: 50%; height: 20%;">
+    stateDiagram-v2
+        state Active {
+            [*] --> NumLockOff
+            NumLockOff --> NumLockOn : EvNumLockPressed
+            NumLockOn --> NumLockOff : EvNumLockPressed
+            --
+            [*] --> CapsLockOff
+            CapsLockOff --> CapsLockOn : EvCapsLockPressed
+            CapsLockOn --> CapsLockOff : EvCapsLockPressed
+            --
+            [*] --> ScrollLockOff
+            ScrollLockOff --> ScrollLockOn : EvCapsLockPressed
+            ScrollLockOn --> ScrollLockOff : EvCapsLockPressed
+        }
+      </div>
+      <div class="mermaid2 mermaid-apa" style="width: 100%; height: 20%;">
         stateDiagram
         [*] --> Still
         Still --> [*]
@@ -52,15 +70,39 @@
         Moving --> Crash
         Crash --> [*]
       </div>
+      <div class="mermaid2" style="width: 100%; height: 100%;">
+stateDiagram-v2
+    [*] --> First
+    First --> Second
+%    First --> Third
+
+    state First {
+        [*] --> fir
+        fir --> [*]
+    }
+    state Second {
+        [*] --> sec
+        sec --> [*]
+    }
+    </div>
       <div class="mermaid" style="width: 100%; height: 100%;">
-        stateDiagram-v2
-        State1: The state with a note
-        note right of State1
-            Important information! You can write
-            notes.
-        end note
-        State1 --> State2
-        note left of State2 : This is the note to the left.
+stateDiagram-v2
+    [*] --> First
+    First --> Second
+    First --> Third
+
+    state First {
+        [*] --> fir
+        fir --> [*]
+    }
+    state Second {
+        [*] --> sec
+        sec --> [*]
+    }
+    state Third {
+        [*] --> thi
+        thi --> [*]
+    }
     </div>
       <div class="mermaid2" style="width: 100%; height: 100%;">
         stateDiagram-v2
diff --git a/src/dagre-wrapper/GraphObjects.md b/src/dagre-wrapper/GraphObjects.md
index 8821c7c36..b21d7efef 100644
--- a/src/dagre-wrapper/GraphObjects.md
+++ b/src/dagre-wrapper/GraphObjects.md
@@ -7,12 +7,10 @@ Explains the representation of various objects used to render the flow charts an
 Sample object:
 ```json
 {
-  "labelType":"svg",
-  "labelStyle":"",
   "shape":"rect",
-  "label":{},
   "labelText":"Test",
-  "rx":0,"ry":0,
+  "rx":0,
+  "ry":0,
   "class":"default",
   "style":"",
   "id":"Test",
@@ -24,18 +22,16 @@ This is set by the renderer of the diagram and insert the data that the wrapper
 
 |  property  |                                                 description                                                 |
 | ---------- | ----------------------------------------------------------------------------------------------------------- |
-| labelType  | If the label should be html label or a svg label. Should we continue to support both?                       |
-| labelStyle | Css styles for the label. Not currently used.                                                               |
-| shape      | The shape of the node. Currently on rect is suppoerted. This will change.                                   |
-| label      | ??                                                                                                          |
+| labelStyle | Css styles for the label. User for instance for stylling the labels for clusters                            |
+| shape      | The shape of the node.                                                                                      |
 | labelText  | The text on the label                                                                                       |
-| rx         | The corner radius - maybe part of the shape instead?                                                        |
-| ry         | The corner radius - maybe part of the shape instead?                                                        |
-| class      | Class to be set for the shape                                                                               |
+| rx         | The corner radius - maybe part of the shape instead? Used for rects.                                        |
+| ry         | The corner radius - maybe part of the shape instead? Used for rects.                                        |
+| classes    | Classes to be set for the shape. Not used                                                                   |
 | style      | Css styles for the actual shape                                                                             |
 | id         | id of the shape                                                                                             |
-| type       | if set to group then this node indicates *a cluster*.                                                         |
-| padding    | Padding. Passed from the renderr as this might differ between react for different diagrams. Maybe obsolete. |
+| type       | if set to group then this node indicates *a cluster*.                                                       |
+| padding    | Padding. Passed from the render as this might differ between different diagrams. Maybe obsolete.            |
 
 
 # edge
diff --git a/src/dagre-wrapper/createLabel.js b/src/dagre-wrapper/createLabel.js
index b7edb1572..a029f59fd 100644
--- a/src/dagre-wrapper/createLabel.js
+++ b/src/dagre-wrapper/createLabel.js
@@ -1,8 +1,10 @@
 const createLabel = (vertexText, style) => {
   const svgLabel = document.createElementNS('http://www.w3.org/2000/svg', 'text');
   svgLabel.setAttribute('style', style.replace('color:', 'fill:'));
-
-  const rows = vertexText.split(/\n|<br\s*\/?>/gi);
+  let rows = [];
+  if (vertexText) {
+    rows = vertexText.split(/\n|<br\s*\/?>/gi);
+  }
 
   for (let j = 0; j < rows.length; j++) {
     const tspan = document.createElementNS('http://www.w3.org/2000/svg', 'tspan');
diff --git a/src/dagre-wrapper/edges.js b/src/dagre-wrapper/edges.js
index ecf4254a8..6b141a863 100644
--- a/src/dagre-wrapper/edges.js
+++ b/src/dagre-wrapper/edges.js
@@ -63,34 +63,17 @@ const outsideNode = (node, point) => {
   return false;
 };
 
-// const intersection = (node, outsidePoint, insidePoint) => {
-//   const x = node.x;
-//   const y = node.y;
-
-//   const dx = Math.abs(x - insidePoint.x);
-//   const w = node.width / 2;
-//   let r = w - dx;
-//   const dy = Math.abs(y - insidePoint.y);
-//   const h = node.height / 2;
-//   const q = h - dy;
-
-//   const Q = Math.abs(outsidePoint.y - insidePoint.y);
-//   const R = Math.abs(outsidePoint.x - insidePoint.x);
-//   r = (R * q) / Q;
-
-//   return { x: insidePoint.x + r, y: insidePoint.y + q };
-// };
 const intersection = (node, outsidePoint, insidePoint) => {
-  // logger.info('intersection', outsidePoint, insidePoint, node);
+  logger.info('intersection o:', outsidePoint, ' i:', insidePoint, node);
   const x = node.x;
   const y = node.y;
 
   const dx = Math.abs(x - insidePoint.x);
   const w = node.width / 2;
-  let r = w - dx;
+  let r = insidePoint.x < outsidePoint.x ? w - dx : w + dx;
   const dy = Math.abs(y - insidePoint.y);
   const h = node.height / 2;
-  let q = h - dy;
+  let q = insidePoint.y < outsidePoint.y ? h - dy : h - dy;
 
   const Q = Math.abs(outsidePoint.y - insidePoint.y);
   const R = Math.abs(outsidePoint.x - insidePoint.x);
@@ -105,9 +88,10 @@ const intersection = (node, outsidePoint, insidePoint) => {
     };
   } else {
     q = (Q * r) / R;
+    r = (R * q) / Q;
 
     return {
-      x: insidePoint.x < outsidePoint.x ? insidePoint.x + r : insidePoint.x - r,
+      x: insidePoint.x < outsidePoint.x ? insidePoint.x + r : insidePoint.x + dx - w,
       y: insidePoint.y < outsidePoint.y ? insidePoint.y + q : insidePoint.y - q
     };
   }
@@ -117,8 +101,8 @@ export const insertEdge = function(elem, edge, clusterDb, diagramType) {
   logger.info('\n\n\n\n');
   let points = edge.points;
   if (edge.toCluster) {
-    // logger.info('edge', edge);
-    // logger.info('to cluster', clusterDb[edge.toCluster]);
+    logger.info('edge', edge);
+    logger.info('to cluster', clusterDb[edge.toCluster]);
     points = [];
     let lastPointOutside;
     let isInside = false;
@@ -126,13 +110,12 @@ export const insertEdge = function(elem, edge, clusterDb, diagramType) {
       const node = clusterDb[edge.toCluster].node;
 
       if (!outsideNode(node, point) && !isInside) {
-        // logger.info('inside', edge.toCluster, point);
+        logger.info('inside', edge.toCluster, point, lastPointOutside);
 
         // First point inside the rect
         const insterection = intersection(node, lastPointOutside, point);
-        // logger.info('intersect', inter.rect(node, lastPointOutside));
+        logger.info('intersect', insterection);
         points.push(insterection);
-        // points.push(insterection);
         isInside = true;
       } else {
         if (!isInside) points.push(point);
@@ -142,8 +125,8 @@ export const insertEdge = function(elem, edge, clusterDb, diagramType) {
   }
 
   if (edge.fromCluster) {
-    // logger.info('edge', edge);
-    // logger.info('from cluster', clusterDb[edge.toCluster]);
+    logger.info('edge', edge);
+    logger.info('from cluster', clusterDb[edge.toCluster]);
     const updatedPoints = [];
     let lastPointOutside;
     let isInside = false;
@@ -152,7 +135,7 @@ export const insertEdge = function(elem, edge, clusterDb, diagramType) {
       const node = clusterDb[edge.fromCluster].node;
 
       if (!outsideNode(node, point) && !isInside) {
-        // logger.info('inside', edge.toCluster, point);
+        logger.info('inside', edge.toCluster, point);
 
         // First point inside the rect
         const insterection = intersection(node, lastPointOutside, point);
@@ -162,7 +145,7 @@ export const insertEdge = function(elem, edge, clusterDb, diagramType) {
         isInside = true;
       } else {
         // at the outside
-        // logger.info('Outside point', point);
+        logger.info('Outside point', point);
         if (!isInside) updatedPoints.unshift(point);
       }
       lastPointOutside = point;
@@ -170,10 +153,6 @@ export const insertEdge = function(elem, edge, clusterDb, diagramType) {
     points = updatedPoints;
   }
 
-  // logger.info('Poibts', points);
-
-  // logger.info('Edge', edge);
-
   // The data for our line
   const lineData = points.filter(p => !Number.isNaN(p.y));
 
diff --git a/src/dagre-wrapper/index.js b/src/dagre-wrapper/index.js
index 8f5a5c731..be024b4d1 100644
--- a/src/dagre-wrapper/index.js
+++ b/src/dagre-wrapper/index.js
@@ -7,8 +7,28 @@ import { logger } from '../logger';
 
 let clusterDb = {};
 
-const translateClusterId = id => {
-  if (clusterDb[id]) return clusterDb[id].id;
+const getAnchorId = (id, graph, nodes) => {
+  // Only insert an achor once
+  if (clusterDb[id]) {
+    //   if (!clusterDb[id].inserted) {
+    //     // Create anchor node for cluster
+    //     const anchorData = {
+    //       shape: 'start',
+    //       labelText: '',
+    //       classes: '',
+    //       style: '',
+    //       id: id + '_anchor',
+    //       type: 'anchor',
+    //       padding: 0
+    //     };
+    //     insertNode(nodes, anchorData);
+
+    //     graph.setNode(anchorData.id, anchorData);
+    //     graph.setParent(anchorData.id, id);
+    //     clusterDb[id].inserted = true;
+    //   }
+    return clusterDb[id].id;
+  }
   return id;
 };
 
@@ -24,24 +44,24 @@ export const render = (elem, graph, markers, diagramtype, id) => {
   const edgeLabels = elem.insert('g').attr('class', 'edgeLabels');
   const nodes = elem.insert('g').attr('class', 'nodes');
 
-  logger.warn('graph', graph);
-
   // Insert nodes, this will insert them into the dom and each node will get a size. The size is updated
   // to the abstract node and is later used by dagre for the layout
   graph.nodes().forEach(function(v) {
     const node = graph.node(v);
-    logger.warn('Node ' + v + ': ' + JSON.stringify(graph.node(v)));
+    logger.info('Node ' + v + ': ' + JSON.stringify(graph.node(v)));
     if (node.type !== 'group') {
       insertNode(nodes, graph.node(v));
     } else {
       // const width = getClusterTitleWidth(clusters, node);
       const children = graph.children(v);
+
       logger.info('Cluster identified', node.id, children[0]);
       // nodes2expand.push({ id: children[0], width });
       clusterDb[node.id] = { id: children[0] };
-      logger.info('Clusters ', clusterDb);
+      // clusterDb[node.id] = { id: node.id + '_anchor' };
     }
   });
+  logger.info('Clusters ', clusterDb);
 
   // Insert labels, this will insert them into the dom so that the width can be calculated
   // Also figure out which edges point to/from clusters and adjust them accordingly
@@ -49,21 +69,37 @@ export const render = (elem, graph, markers, diagramtype, id) => {
   // TODO: pick optimal child in the cluster to us as link anchor
   graph.edges().forEach(function(e) {
     const edge = graph.edge(e);
-    logger.warn('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
-    // logger.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(graph.edge(e)));
-    const v = translateClusterId(e.v);
-    const w = translateClusterId(e.w);
-    if (v !== e.v || w !== e.w) {
+    logger.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
+    logger.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(graph.edge(e)));
+
+    let v = e.v;
+    let w = e.w;
+    // Check if link is either from or to a cluster
+    logger.info(
+      'Fix',
+      clusterDb,
+      'ids:',
+      e.v,
+      e.w,
+      'Translateing: ',
+      clusterDb[e.v],
+      clusterDb[e.w]
+    );
+    if (clusterDb[e.v] || clusterDb[e.w]) {
+      logger.info('Fixing and trixing - rwemoving', e.v, e.w, e.name);
+      v = getAnchorId(e.v, graph, nodes);
+      w = getAnchorId(e.w, graph, nodes);
       graph.removeEdge(e.v, e.w, e.name);
       if (v !== e.v) edge.fromCluster = e.v;
       if (w !== e.w) edge.toCluster = e.w;
+      logger.info('Fixing Replacing with', v, w, e.name);
       graph.setEdge(v, w, edge, e.name);
     }
     insertEdgeLabel(edgeLabels, edge);
   });
 
   graph.edges().forEach(function(e) {
-    logger.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
+    logger.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
   });
   logger.info('#############################################');
   logger.info('###                Layout                 ###');
@@ -74,7 +110,7 @@ export const render = (elem, graph, markers, diagramtype, id) => {
   // Move the nodes to the correct place
   graph.nodes().forEach(function(v) {
     const node = graph.node(v);
-    logger.info('Node ' + v + ': ' + JSON.stringify(graph.node(v)));
+    logger.trace('Node ' + v + ': ' + JSON.stringify(graph.node(v)));
     if (node.type !== 'group') {
       positionNode(node);
     } else {
@@ -86,7 +122,7 @@ export const render = (elem, graph, markers, diagramtype, id) => {
   // Move the edge labels to the correct place after layout
   graph.edges().forEach(function(e) {
     const edge = graph.edge(e);
-    logger.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(edge), edge);
+    logger.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(edge), edge);
 
     insertEdge(edgePaths, edge, clusterDb, diagramtype);
     positionEdgeLabel(edge);
diff --git a/src/diagrams/flowchart/flowRenderer-v2.js b/src/diagrams/flowchart/flowRenderer-v2.js
index e8915fc08..e0cce8df8 100644
--- a/src/diagrams/flowchart/flowRenderer-v2.js
+++ b/src/diagrams/flowchart/flowRenderer-v2.js
@@ -130,10 +130,8 @@ export const addVertices = function(vert, g, svgId) {
     }
     // Add the node
     g.setNode(vertex.id, {
-      labelType: 'svg',
       labelStyle: styles.labelStyle,
       shape: _shape,
-      label: vertexNode,
       labelText: vertexText,
       rx: radious,
       ry: radious,
@@ -146,10 +144,8 @@ export const addVertices = function(vert, g, svgId) {
     });
 
     logger.info('setNode', {
-      labelType: 'svg',
       labelStyle: styles.labelStyle,
       shape: _shape,
-      label: vertexNode,
       labelText: vertexText,
       rx: radious,
       ry: radious,
diff --git a/src/diagrams/state/stateDb.js b/src/diagrams/state/stateDb.js
index d72e8f00c..c56dcd1a3 100644
--- a/src/diagrams/state/stateDb.js
+++ b/src/diagrams/state/stateDb.js
@@ -1,4 +1,7 @@
 import { logger } from '../../logger';
+import { generateId } from '../../utils';
+
+const clone = o => JSON.parse(JSON.stringify(o));
 
 let rootDoc = [];
 const setRootDoc = o => {
@@ -22,6 +25,34 @@ const docTranslator = (parent, node, first) => {
     }
 
     if (node.doc) {
+      const doc = [];
+      // Check for concurrency
+      let i = 0;
+      let currentDoc = [];
+      for (i = 0; i < node.doc.length; i++) {
+        if (node.doc[i].type === 'divider') {
+          // debugger;
+          const newNode = clone(node.doc[i]);
+          newNode.doc = clone(currentDoc);
+          doc.push(newNode);
+          currentDoc = [];
+        } else {
+          currentDoc.push(node.doc[i]);
+        }
+      }
+
+      // If any divider was encountered
+      if (doc.length > 0 && currentDoc.length > 0) {
+        const newNode = {
+          stmt: 'state',
+          id: generateId(),
+          type: 'divider',
+          doc: clone(currentDoc)
+        };
+        doc.push(clone(newNode));
+        node.doc = doc;
+      }
+
       node.doc.forEach(docNode => docTranslator(node, docNode, true));
     }
   }
@@ -31,8 +62,14 @@ const getRootDocV2 = () => {
   return { id: 'root', doc: rootDoc };
 };
 
-const extract = doc => {
+const extract = _doc => {
   // const res = { states: [], relations: [] };
+  let doc;
+  if (_doc.doc) {
+    doc = _doc.doc;
+  } else {
+    doc = _doc;
+  }
   // let doc = root.doc;
   // if (!doc) {
   //   doc = root;
@@ -40,6 +77,8 @@ const extract = doc => {
   logger.info(doc);
   clear();
 
+  logger.info('Extract', doc);
+
   doc.forEach(item => {
     if (item.stmt === 'state') {
       addState(item.id, item.type, item.doc, item.description, item.note);
diff --git a/src/diagrams/state/stateRenderer-v2.js b/src/diagrams/state/stateRenderer-v2.js
index 76dc2f186..f69d94ed3 100644
--- a/src/diagrams/state/stateRenderer-v2.js
+++ b/src/diagrams/state/stateRenderer-v2.js
@@ -72,10 +72,8 @@ const setupNode = (g, parent, node, altFlag) => {
     }
 
     const nodeData = {
-      labelType: 'svg',
       labelStyle: '',
       shape: nodeDb[node.id].shape,
-      label: node.id,
       labelText: nodeDb[node.id].description,
       classes: nodeDb[node.id].classes, //classStr,
       style: '', //styles.style,
@@ -87,10 +85,8 @@ const setupNode = (g, parent, node, altFlag) => {
     if (node.note) {
       // Todo: set random id
       const noteData = {
-        labelType: 'svg',
         labelStyle: '',
         shape: 'note',
-        label: node.id,
         labelText: node.note.text,
         classes: 'statediagram-note', //classStr,
         style: '', //styles.style,
@@ -99,10 +95,8 @@ const setupNode = (g, parent, node, altFlag) => {
         padding: 15 //getConfig().flowchart.padding
       };
       const groupData = {
-        labelType: 'svg',
         labelStyle: '',
         shape: 'noteGroup',
-        label: node.id + '----parent',
         labelText: node.note.text,
         classes: nodeDb[node.id].classes, //classStr,
         style: '', //styles.style,
@@ -133,8 +127,7 @@ const setupNode = (g, parent, node, altFlag) => {
         classes: 'note-edge',
         arrowheadStyle: 'fill: #333',
         labelpos: 'c',
-        labelType: 'text',
-        label: ''
+        labelType: 'text'
       });
     } else {
       g.setNode(node.id, nodeData);
@@ -143,12 +136,12 @@ const setupNode = (g, parent, node, altFlag) => {
 
   if (parent) {
     if (parent.id !== 'root') {
-      logger.trace('Setting node ', node.id, ' to be child of its parent ', parent.id);
+      logger.info('Setting node ', node.id, ' to be child of its parent ', parent.id);
       g.setParent(node.id, parent.id);
     }
   }
   if (node.doc) {
-    logger.trace('Adding nodes children ');
+    logger.info('Adding nodes children ');
     setupDoc(g, node, node.doc, !altFlag);
   }
 };
@@ -168,8 +161,7 @@ const setupDoc = (g, parent, doc, altFlag) => {
         labelStyle: '',
         arrowheadStyle: 'fill: #333',
         labelpos: 'c',
-        labelType: 'text',
-        label: ''
+        labelType: 'text'
       };
       let startId = item.state1.id;
       let endId = item.state2.id;
@@ -214,7 +206,7 @@ export const draw = function(text, id) {
     compound: true
   })
     .setGraph({
-      rankdir: 'LR',
+      rankdir: 'TB',
       nodesep: nodeSpacing,
       ranksep: rankSpacing,
       marginx: 8,
@@ -224,8 +216,8 @@ export const draw = function(text, id) {
       return {};
     });
 
-  // logger.info(stateDb.getRootDoc());
-  stateDb.extract(stateDb.getRootDocV2().doc);
+  logger.info(stateDb.getRootDocV2());
+  stateDb.extract(stateDb.getRootDocV2());
   logger.info(stateDb.getRootDocV2());
   setupNode(g, undefined, stateDb.getRootDocV2(), true);
 
diff --git a/src/utils.js b/src/utils.js
index 823191ffc..1adcb86f0 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -210,6 +210,19 @@ export const getStylesFromArray = arr => {
   return { style: style, labelStyle: labelStyle };
 };
 
+let cnt = 0;
+export const generateId = () => {
+  cnt++;
+  return (
+    'id-' +
+    Math.random()
+      .toString(36)
+      .substr(2, 12) +
+    '-' +
+    cnt
+  );
+};
+
 export default {
   detectType,
   isSubstringInArray,
@@ -217,5 +230,6 @@ export default {
   calcLabelPosition,
   calcCardinalityPosition,
   formatUrl,
-  getStylesFromArray
+  getStylesFromArray,
+  generateId
 };

From cff68fc06212b4822c8df2ad6bd34796ecadae92 Mon Sep 17 00:00:00 2001
From: Knut Sveidqvist <knut.sveidqvist@ipiccolo.com>
Date: Thu, 2 Apr 2020 19:48:28 +0200
Subject: [PATCH 02/12] #1295 Better way of finding suitable child in cluster
 to point to

---
 cypress/platform/current.html |  4 ++--
 src/dagre-wrapper/index.js    | 20 ++++++++++++++++++--
 2 files changed, 20 insertions(+), 4 deletions(-)

diff --git a/cypress/platform/current.html b/cypress/platform/current.html
index 6b52388a7..4031bf0de 100644
--- a/cypress/platform/current.html
+++ b/cypress/platform/current.html
@@ -31,7 +31,7 @@
         G-->H
         G-->c
       </div>
-      <div class="mermaid2" style="width: 50%; height: 20%;">
+      <div class="mermaid" style="width: 50%; height: 20%;">
     stateDiagram-v2
     [*] --> monkey
     state monkey {
@@ -85,7 +85,7 @@ stateDiagram-v2
         sec --> [*]
     }
     </div>
-      <div class="mermaid" style="width: 100%; height: 100%;">
+      <div class="mermaid2" style="width: 100%; height: 100%;">
 stateDiagram-v2
     [*] --> First
     First --> Second
diff --git a/src/dagre-wrapper/index.js b/src/dagre-wrapper/index.js
index be024b4d1..6f8b9f7e3 100644
--- a/src/dagre-wrapper/index.js
+++ b/src/dagre-wrapper/index.js
@@ -32,6 +32,22 @@ const getAnchorId = (id, graph, nodes) => {
   return id;
 };
 
+const findNonClusterChild = (id, graph) => {
+  const node = graph.node(id);
+  logger.info('identified node', node);
+  if (node.type !== 'group') {
+    return node.id;
+  }
+  logger.info('identified node Not', node.id);
+  const children = graph.children(id);
+  for (let i = 0; i < children.length; i++) {
+    const _id = findNonClusterChild(children[i], graph);
+    if (_id) {
+      return _id;
+    }
+  }
+};
+
 export const render = (elem, graph, markers, diagramtype, id) => {
   insertMarkers(elem, markers, diagramtype, id);
   clusterDb = {};
@@ -55,9 +71,9 @@ export const render = (elem, graph, markers, diagramtype, id) => {
       // const width = getClusterTitleWidth(clusters, node);
       const children = graph.children(v);
 
-      logger.info('Cluster identified', node.id, children[0]);
+      logger.info('Cluster identified', node.id, children[0], findNonClusterChild(node.id, graph));
       // nodes2expand.push({ id: children[0], width });
-      clusterDb[node.id] = { id: children[0] };
+      clusterDb[node.id] = { id: findNonClusterChild(node.id, graph) };
       // clusterDb[node.id] = { id: node.id + '_anchor' };
     }
   });

From 857c86095222cad2262042ed4877675587b35760 Mon Sep 17 00:00:00 2001
From: Knut Sveidqvist <knut.sveidqvist@ipiccolo.com>
Date: Thu, 2 Apr 2020 19:50:21 +0200
Subject: [PATCH 03/12] #1295 Lint fix

---
 src/dagre-wrapper/index.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dagre-wrapper/index.js b/src/dagre-wrapper/index.js
index 6f8b9f7e3..332f005b7 100644
--- a/src/dagre-wrapper/index.js
+++ b/src/dagre-wrapper/index.js
@@ -7,7 +7,7 @@ import { logger } from '../logger';
 
 let clusterDb = {};
 
-const getAnchorId = (id, graph, nodes) => {
+const getAnchorId = id => {
   // Only insert an achor once
   if (clusterDb[id]) {
     //   if (!clusterDb[id].inserted) {

From 8455db6fae4c671f0a488e3498ed6f49dd5fb0ee Mon Sep 17 00:00:00 2001
From: Knut Sveidqvist <knut.sveidqvist@ipiccolo.com>
Date: Fri, 10 Apr 2020 07:27:04 +0200
Subject: [PATCH 04/12] #1295 Moving graph operations into mermaid-graplib and
 adding tests

---
 cypress/platform/current.html              |   4 +-
 src/dagre-wrapper/GraphObjects.md          |  52 +++++
 src/dagre-wrapper/index.js                 |  16 +-
 src/dagre-wrapper/mermaid-graphlib.js      | 237 +++++++++++++++++++++
 src/dagre-wrapper/mermaid-graphlib.spec.js | 228 ++++++++++++++++++++
 src/logger.js                              |   2 +-
 6 files changed, 527 insertions(+), 12 deletions(-)
 create mode 100644 src/dagre-wrapper/mermaid-graphlib.js
 create mode 100644 src/dagre-wrapper/mermaid-graphlib.spec.js

diff --git a/cypress/platform/current.html b/cypress/platform/current.html
index 4031bf0de..abc63ea48 100644
--- a/cypress/platform/current.html
+++ b/cypress/platform/current.html
@@ -31,7 +31,7 @@
         G-->H
         G-->c
       </div>
-      <div class="mermaid" style="width: 50%; height: 20%;">
+      <div class="mermaid2" style="width: 50%; height: 20%;">
     stateDiagram-v2
     [*] --> monkey
     state monkey {
@@ -70,7 +70,7 @@
         Moving --> Crash
         Crash --> [*]
       </div>
-      <div class="mermaid2" style="width: 100%; height: 100%;">
+      <div class="mermaid" style="width: 100%; height: 100%;">
 stateDiagram-v2
     [*] --> First
     First --> Second
diff --git a/src/dagre-wrapper/GraphObjects.md b/src/dagre-wrapper/GraphObjects.md
index b21d7efef..cde45591d 100644
--- a/src/dagre-wrapper/GraphObjects.md
+++ b/src/dagre-wrapper/GraphObjects.md
@@ -1,3 +1,55 @@
+# Cluster handling
+
+Dagre does not support edges between nodes and clusters or between clusters to other clusters. In order to remedy this shortcoming the dagre wrapper implements a few work-arounds.
+
+In the diagram below there are two clusters and there are no edges to nodes outside the own cluster.
+
+```mermaid
+flowchart
+  subgraph C1
+    a --> b
+  end
+  subgraph C2
+    c
+  end
+  C1 --> C2
+```
+
+In this case the dagre-wrapper will transform the graph to the graph below.
+```mermaid
+flowchart
+  C1 --> C2
+```
+
+The new nodes C1 and C2 are a special type of nodes, clusterNodes. ClusterNodes have have the nodes in the cluster including the cluster attached in a graph object.
+
+When rendering this diagram it it beeing rendered recursivly. The diagram is rendered by the dagre-mermaid:render function which in turn will be used to render the node C1 and the node C2. The result of those renderings will be inserted as nodes in the "root" diagram. With this recursive approach it would be possible to have different layout direction for each cluster.
+
+```
+{ clusterNode: true, graph }
+```
+*Data for a clusterNode*
+
+When a cluster has edges to or from some of its nodes leading outside the cluster the approach of recursive rendering can not be used as the layout of the graph needs to take responsibility for nodes outside of the cluster.
+
+```mermaid
+flowchart
+  subgraph C1
+    a
+  end
+  subgraph C2
+    b
+  end
+  a --> C2
+```
+
+To handle this case a special type of edge is inserted. The edge to/from the cluster is replaced with an edge to/from a node in the cluster which is tagged with toCluster/fromCluster. When rendering this edge the intersection between the edge and the border of the cluster is calculated making the edge start/stop there. In practice this renders like an an edge to/from the cluster.
+
+In the diagram above the root diagram would be rendered with C1 whereas C2 would be rendered recursively.
+
+Of these two approaches the top one renders better and is used when possible. When this is not possible, ie an edge is added crossing the border the non recursive approach is used.
+
+
 # Graph objects and their properties
 
 Explains the representation of various objects used to render the flow charts and what the properties mean. This ofc from the perspective of the dagre-wrapper.
diff --git a/src/dagre-wrapper/index.js b/src/dagre-wrapper/index.js
index 332f005b7..eb0427215 100644
--- a/src/dagre-wrapper/index.js
+++ b/src/dagre-wrapper/index.js
@@ -1,11 +1,12 @@
 import dagre from 'dagre';
 import insertMarkers from './markers';
+import { clear as cleargraphlib, clusterDb, adjustClustersAndEdges } from './mermaid-graphlib';
 import { insertNode, positionNode, clear as clearNodes } from './nodes';
 import { insertCluster, clear as clearClusters } from './clusters';
 import { insertEdgeLabel, positionEdgeLabel, insertEdge, clear as clearEdges } from './edges';
 import { logger } from '../logger';
 
-let clusterDb = {};
+// let clusterDb = {};
 
 const getAnchorId = id => {
   // Only insert an achor once
@@ -50,11 +51,12 @@ const findNonClusterChild = (id, graph) => {
 
 export const render = (elem, graph, markers, diagramtype, id) => {
   insertMarkers(elem, markers, diagramtype, id);
-  clusterDb = {};
   clearNodes();
   clearEdges();
   clearClusters();
 
+  adjustClustersAndEdges(graph);
+
   const clusters = elem.insert('g').attr('class', 'clusters'); // eslint-disable-line
   const edgePaths = elem.insert('g').attr('class', 'edgePaths');
   const edgeLabels = elem.insert('g').attr('class', 'edgeLabels');
@@ -68,13 +70,9 @@ export const render = (elem, graph, markers, diagramtype, id) => {
     if (node.type !== 'group') {
       insertNode(nodes, graph.node(v));
     } else {
-      // const width = getClusterTitleWidth(clusters, node);
-      const children = graph.children(v);
-
-      logger.info('Cluster identified', node.id, children[0], findNonClusterChild(node.id, graph));
-      // nodes2expand.push({ id: children[0], width });
-      clusterDb[node.id] = { id: findNonClusterChild(node.id, graph) };
-      // clusterDb[node.id] = { id: node.id + '_anchor' };
+      // const children = graph.children(v);
+      // logger.info('Cluster identified', node.id, children[0], findNonClusterChild(node.id, graph));
+      // clusterDb[node.id] = { id: findNonClusterChild(node.id, graph) };
     }
   });
   logger.info('Clusters ', clusterDb);
diff --git a/src/dagre-wrapper/mermaid-graphlib.js b/src/dagre-wrapper/mermaid-graphlib.js
new file mode 100644
index 000000000..ae4e4086c
--- /dev/null
+++ b/src/dagre-wrapper/mermaid-graphlib.js
@@ -0,0 +1,237 @@
+/**
+ * Decorates with functions required by mermaids dagre-wrapper.
+ */
+import { logger } from '../logger';
+import graphlib from 'graphlib';
+
+export let clusterDb = {};
+let decendants = {};
+
+export const clear = () => {
+  decendants = {};
+  clusterDb = {};
+};
+
+const copy = (clusterId, graph, newGraph, rootId) => {
+  logger.trace('Copying ', clusterId);
+  const nodes = graph.children(clusterId);
+  nodes.forEach(node => {
+    if (graph.children(node).length > 0) {
+      copy(node, graph, newGraph, rootId);
+    }
+
+    const data = graph.node(node);
+    logger.trace(node, data, ' parent is ', clusterId);
+    newGraph.setNode(node, data);
+    newGraph.setParent(node, clusterId);
+    const edges = graph.edges(node);
+    graph.removeNode(node);
+    logger.trace('Edges', edges);
+    edges.forEach(edge => {
+      const data = graph.edge(edge);
+      // Do not copy edges in and out of the root cluster, they belong to the parent graph
+      if (!(edge.v === rootId || edge.w === rootId)) {
+        logger.trace('Copying as ', rootId, edge.v, edge.w, clusterId);
+        newGraph.setEdge(edge.v, edge.w, data);
+      } else {
+        logger.trace('Skipping copy of edge as ', rootId, edge.v, edge.w, clusterId);
+      }
+    });
+  });
+  newGraph.setNode(clusterId, graph.node(clusterId));
+};
+
+const extractDecendants = (id, graph) => {
+  const children = graph.children(id);
+  let res = [].concat(children);
+
+  for (let i = 0; i < children.length; i++) {
+    res = res.concat(extractDecendants(children[i], graph));
+  }
+
+  return res;
+};
+
+export const extractGraphFromCluster = (clusterId, graph) => {
+  const clusterGraph = new graphlib.Graph({
+    multigraph: true,
+    compound: true
+  })
+    .setGraph({
+      rankdir: 'TB',
+      // Todo: set proper spacing
+      nodesep: 10,
+      ranksep: 10,
+      marginx: 8,
+      marginy: 8
+    })
+    .setDefaultEdgeLabel(function() {
+      return {};
+    });
+
+  copy(clusterId, graph, clusterGraph, clusterId);
+
+  return clusterGraph;
+};
+
+/**
+ * Validates the graph, checking that all parent child relation points to existing nodes and that
+ * edges between nodes also ia correct. When not correct the function logs the discrepancies.
+ * @param {graphlib graph} g
+ */
+export const validate = graph => {
+  const edges = graph.edges();
+  logger.trace('Edges: ', edges);
+  for (let i = 0; i < edges.length; i++) {
+    if (graph.children(edges[i].v).length > 0) {
+      logger.trace('The node ', edges[i].v, ' is part of and edge even though it has children');
+      return false;
+    }
+    if (graph.children(edges[i].w).length > 0) {
+      logger.trace('The node ', edges[i].w, ' is part of and edge even though it has children');
+      return false;
+    }
+  }
+  return true;
+};
+
+/**
+ * Finds a child that is not a cluster. When faking a edge between a node and a cluster.
+ * @param {Finds a } id
+ * @param {*} graph
+ */
+const findNonClusterChild = (id, graph) => {
+  // const node = graph.node(id);
+  logger.trace('Searching', id);
+  const children = graph.children(id);
+  if (children.length < 1) {
+    logger.trace('This is a valid node', id);
+    return id;
+  }
+  for (let i = 0; i < children.length; i++) {
+    const _id = findNonClusterChild(children[i], graph);
+    if (_id) {
+      logger.trace('Found replacement for', id, ' => ', _id);
+      return _id;
+    }
+  }
+};
+
+const getAnchorId = id => {
+  if (!clusterDb[id]) {
+    return id;
+  }
+  // If the cluster has no external connections
+  if (!clusterDb[id].externalConnections) {
+    return id;
+  }
+
+  // Return the replacement node
+  if (clusterDb[id]) {
+    return clusterDb[id].id;
+  }
+  return id;
+};
+
+export const adjustClustersAndEdges = graph => {
+  // calc decendants, sa
+
+  // Go through the nodes and for each cluster found, save a replacment node, this can be used when
+  // faking a link to a cluster
+  graph.nodes().forEach(function(id) {
+    const children = graph.children(id);
+    if (children.length > 0) {
+      logger.trace(
+        'Cluster identified',
+        id,
+        ' Replacement id in edges: ',
+        findNonClusterChild(id, graph)
+      );
+      decendants[id] = extractDecendants(id, graph);
+      clusterDb[id] = { id: findNonClusterChild(id, graph) };
+    }
+  });
+
+  // Check incoming and outgoing edges for each cluster
+  graph.nodes().forEach(function(id) {
+    const children = graph.children(id);
+    const edges = graph.edges();
+    if (children.length > 0) {
+      logger.trace('Cluster identified', id);
+      edges.forEach(edge => {
+        logger.trace('Edge: ', edge, decendants[id]);
+        // Check if any edge leaves the cluster (not the actual cluster, thats a link from the box)
+        if (edge.v !== id && edge.w !== id) {
+          if (decendants[id].indexOf(edge.v) < 0 || decendants[id].indexOf(edge.w) < 0) {
+            logger.trace('Edge: ', edge, ' leaves cluster ', id);
+            clusterDb[id].externalConnections = true;
+          }
+        }
+      });
+    }
+  });
+
+  // For clusters without incoming and/or outgoing edges, create a new cluster-node
+  // containing the nodes and edges in the custer in a new graph
+  // for (let i = 0;)
+  const clusters = Object.keys(clusterDb);
+  // clusters.forEach(clusterId => {
+  for (let i = 0; i < clusters.length; i++) {
+    const clusterId = clusters[i];
+    if (!clusterDb[clusterId].externalConnections) {
+      logger.trace('Cluster without external connections', clusterId);
+      const edges = graph.nodeEdges(clusterId);
+
+      // New graph with the nodes in the cluster
+      const clusterGraph = extractGraphFromCluster(clusterId, graph);
+      logger.trace('Cluster graph', clusterGraph.nodes());
+      logger.trace('Graph', graph.nodes());
+
+      // Create a new node in the original graph, this new node is not a cluster
+      // but a regular node with the cluster dontent as a new attached graph
+      graph.setNode(clusterId, { clusterNode: true, graph: clusterGraph });
+
+      // The original edges in and out of the cluster is applied
+      edges.forEach(edge => {
+        logger.trace('Setting edge', edge);
+        const data = graph.edge(edge);
+        graph.setEdge(edge.v, edge.w, data);
+      });
+    }
+  }
+  logger.trace('Graph', graph.nodes());
+  // For clusters with incoming and/or outgoing edges translate those edges to a real node
+  // in the cluster inorder to fake the edge
+  graph.edges().forEach(function(e) {
+    const edge = graph.edge(e);
+    logger.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
+    logger.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(graph.edge(e)));
+
+    let v = e.v;
+    let w = e.w;
+    // Check if link is either from or to a cluster
+    logger.trace(
+      'Fix',
+      clusterDb,
+      'ids:',
+      e.v,
+      e.w,
+      'Translateing: ',
+      clusterDb[e.v],
+      clusterDb[e.w]
+    );
+    if (clusterDb[e.v] || clusterDb[e.w]) {
+      logger.trace('Fixing and trixing - removing', e.v, e.w, e.name);
+      v = getAnchorId(e.v);
+      w = getAnchorId(e.w);
+      graph.removeEdge(e.v, e.w, e.name);
+      if (v !== e.v) edge.fromCluster = e.v;
+      if (w !== e.w) edge.toCluster = e.w;
+      logger.trace('Replacing with', v, w, e.name);
+      graph.setEdge(v, w, edge, e.name);
+    }
+  });
+  logger.trace('Graph', graph.nodes());
+
+  logger.trace(clusterDb);
+};
diff --git a/src/dagre-wrapper/mermaid-graphlib.spec.js b/src/dagre-wrapper/mermaid-graphlib.spec.js
new file mode 100644
index 000000000..b842a455b
--- /dev/null
+++ b/src/dagre-wrapper/mermaid-graphlib.spec.js
@@ -0,0 +1,228 @@
+import graphlib from 'graphlib';
+import dagre from 'dagre';
+import { validate, adjustClustersAndEdges, extractGraphFromCluster } from './mermaid-graphlib';
+import { setLogLevel, logger } from '../logger';
+
+describe('Graphlib decorations', () => {
+  let g;
+  beforeEach(function () {
+    setLogLevel(1);
+    g = new graphlib.Graph({
+      multigraph: true,
+      compound: true
+    });
+    g.setGraph({
+      rankdir: 'TB',
+      nodesep: 10,
+      ranksep: 10,
+      marginx: 8,
+      marginy: 8
+    });
+    g.setDefaultEdgeLabel(function () {
+        return {};
+    });
+
+//     // Add node 'a' to the graph with no label
+//     g.setNode('a');
+
+//     // Add node 'b' to the graph with a String label
+//     g.setNode('b', 'b's value');
+
+//     // Add node 'c' to the graph with an Object label
+//     g.setNode('c', { k: 123 });
+
+//     // What nodes are in the graph?
+//     g.nodes();
+//     // => `[ 'a', 'b', 'c' ]`
+
+//     // Add a directed edge from 'a' to 'b', but assign no label
+//     g.setEdge('a', 'b');
+
+//     // Add a directed edge from 'c' to 'd' with an Object label.
+//     // Since 'd' did not exist prior to this call it is automatically
+//     // created with an undefined label.
+//     g.setEdge('c', 'd', { k: 456 });
+
+//     // What edges are in the graph?
+//     g.edges();
+//     // => `[ { v: 'a', w: 'b' },
+//     //       { v: 'c', w: 'd' } ]`.
+
+//     // Which edges leave node 'a'?
+//     g.outEdges('a');
+//     // => `[ { v: 'a', w: 'b' } ]`
+
+//     // Which edges enter and leave node 'd'?
+//     g.nodeEdges('d');
+// // => `[ { v: 'c', w: 'd' } ]`
+  });
+
+  describe('validate', function () {
+    it('Validate should detect edges between clusters', function () {
+      /*
+        subgraph C1
+          a --> b
+        end
+        subgraph C2
+          c
+        end
+        C1 --> C2
+      */
+      g.setNode('a', { data:1});
+      g.setNode('b', { data: 2 });
+      g.setNode('c', { data: 3 });
+      g.setParent('a', 'C1');
+      g.setParent('b', 'C1');
+      g.setParent('c', 'C2');
+      g.setEdge('a', 'b');
+      g.setEdge('C1', 'C2');
+
+      console.log(g.nodes())
+
+      expect(validate(g)).toBe(false);
+    });
+    it('Validate should not detect edges between clusters after adjustment', function () {
+      /*
+        subgraph C1
+          a --> b
+        end
+        subgraph C2
+          c
+        end
+        C1 --> C2
+      */
+      g.setNode('a', {});
+      g.setNode('b', {});
+      g.setNode('c', {});
+      g.setParent('a', 'C1');
+      g.setParent('b', 'C1');
+      g.setParent('c', 'C2');
+      g.setEdge('a', 'b');
+      g.setEdge('C1', 'C2');
+
+      console.log(g.nodes())
+      adjustClustersAndEdges(g);
+      logger.info(g.edges())
+      expect(validate(g)).toBe(true);
+    });
+
+    it('It is possible to copy a cluster to a new graph 1', function () {
+      /*
+        a --> b
+        subgraph C1
+          subgraph C2
+            a
+          end
+          b
+        end
+        C1 --> c
+      */
+      g.setNode('a', { data: 1 });
+      g.setNode('b', { data: 2 });
+      g.setNode('c', { data: 3 });
+      g.setParent('a', 'C2');
+      g.setParent('b', 'C1');
+      g.setParent('C2', 'C1');
+      g.setEdge('a', 'b', { name: 'C1-internal-link' });
+      g.setEdge('C1', 'c', { name: 'C1-external-link' });
+
+      const newGraph = extractGraphFromCluster('C1', g);
+      expect(newGraph.nodes().length).toBe(4);
+      expect(newGraph.edges().length).toBe(1);
+      logger.info(newGraph.children('C1'));
+      expect(newGraph.children('C2')).toEqual(['a']);
+      expect(newGraph.children('C1')).toEqual(['b', 'C2']);
+      expect(newGraph.edges('a')).toEqual([{ v: 'a', w: 'b' }]);
+    });
+
+    it('It is possible to extract a clusters to a new graph 2', function () {
+      /*
+        subgraph C1
+          a --> b
+        end
+        subgraph C2
+          c
+        end
+        C1 --> C2
+      */
+      g.setNode('a', { data: 1 });
+      g.setNode('b', { data: 2 });
+      g.setNode('c', { data: 3 });
+      g.setNode('c', { data: 3 });
+      g.setParent('a', 'C1');
+      g.setParent('b', 'C1');
+      g.setParent('c', 'C2');
+      g.setEdge('a', 'b', { name: 'C1-internal-link' });
+      g.setEdge('C1', 'C2', { name: 'C1-external-link' });
+
+      const C1 = extractGraphFromCluster('C1', g);
+      const C2 = extractGraphFromCluster('C2', g);
+
+      expect(g.nodes()).toEqual(['C1', 'C2']);
+      expect(g.children('C1')).toEqual([]);
+      expect(g.children('C2')).toEqual([]);
+      expect(g.edges()).toEqual([{ v: 'C1', w: 'C2' }]);
+
+      logger.info(C1.nodes());
+      expect(C1.nodes()).toEqual(['a', 'C1', 'b']);
+      expect(C1.children('C1')).toEqual(['a', 'b']);
+      expect(C1.edges()).toEqual([{ v: 'a', w: 'b' }]);
+
+      expect(C2.nodes()).toEqual(['c', 'C2']);
+      expect(C2.edges()).toEqual([]);
+    });
+
+    it('It is possible to extract a cluster from a graph so that the nodes are removed from original graph', function () {
+      /*
+        a --> b
+        subgraph C1
+          subgraph C2
+            a
+          end
+          b
+        end
+        C1 --> c
+      */
+      g.setNode('a', { data: 1 });
+      g.setNode('b', { data: 2 });
+      g.setNode('c', { data: 3 });
+      g.setParent('a', 'C2');
+      g.setParent('b', 'C1');
+      g.setParent('C2', 'C1');
+      g.setEdge('a', 'b', { name: 'C1-internal-link' });
+      g.setEdge('C1', 'c', { name: 'C1-external-link' });
+
+      const newGraph = extractGraphFromCluster('C1', g);
+      logger.info(g.nodes());
+      expect(g.nodes()).toEqual(['c','C1']);
+      expect(g.edges().length).toBe(1);
+      expect(g.children()).toEqual(['c','C1']);
+      expect(g.children('C1')).toEqual([]);
+    });
+  });
+    it('Validate should detect edges between clusters and transform clusters', function () {
+      /*
+        a --> b
+        subgraph C1
+          subgraph C2
+            a
+          end
+          b
+        end
+        C1 --> c
+      */
+      g.setNode('a', { data: 1 });
+      g.setNode('b', { data: 2 });
+      g.setNode('c', { data: 3 });
+      g.setParent('a', 'C2');
+      g.setParent('b', 'C1');
+      g.setParent('C2', 'C1');
+      g.setEdge('a', 'b', { name: 'C1-internal-link' });
+      g.setEdge('C1', 'c', { name: 'C1-external-link' });
+
+      adjustClustersAndEdges(g);
+      logger.info(g.nodes())
+      expect(g.nodes().length).toBe(2);
+      expect(validate(g)).toBe(true);
+    });
+});
diff --git a/src/logger.js b/src/logger.js
index b54ce6937..3b6b60f16 100644
--- a/src/logger.js
+++ b/src/logger.js
@@ -1,5 +1,5 @@
 import moment from 'moment-mini';
-
+//
 export const LEVELS = {
   debug: 1,
   info: 2,

From 22e17172dd4e5dfbc54e832f5364f157f176f687 Mon Sep 17 00:00:00 2001
From: Knut Sveidqvist <knut.sveidqvist@ipiccolo.com>
Date: Sat, 11 Apr 2020 17:16:01 +0200
Subject: [PATCH 05/12] #1295 Recursive rendering, draft

---
 cypress/platform/current.html              |   8 +-
 src/dagre-wrapper/clusters.js              |  17 ++-
 src/dagre-wrapper/index.js                 | 162 +++++++++++----------
 src/dagre-wrapper/mermaid-graphlib.js      |  73 +++++++---
 src/dagre-wrapper/mermaid-graphlib.spec.js |  31 +++-
 src/dagre-wrapper/nodes.js                 |   3 +
 src/diagrams/flowchart/flowRenderer-v2.js  |  40 ++---
 7 files changed, 211 insertions(+), 123 deletions(-)

diff --git a/cypress/platform/current.html b/cypress/platform/current.html
index abc63ea48..50cb3ed3c 100644
--- a/cypress/platform/current.html
+++ b/cypress/platform/current.html
@@ -70,7 +70,7 @@
         Moving --> Crash
         Crash --> [*]
       </div>
-      <div class="mermaid" style="width: 100%; height: 100%;">
+      <div class="mermaid2" style="width: 100%; height: 100%;">
 stateDiagram-v2
     [*] --> First
     First --> Second
@@ -84,6 +84,12 @@ stateDiagram-v2
         [*] --> sec
         sec --> [*]
     }
+    </div>
+      <div class="mermaid" style="width: 100%; height: 100%;">
+flowchart TD
+    subgraph Apa
+      a --> b
+    end
     </div>
       <div class="mermaid2" style="width: 100%; height: 100%;">
 stateDiagram-v2
diff --git a/src/dagre-wrapper/clusters.js b/src/dagre-wrapper/clusters.js
index 55db0b32e..02da85c58 100644
--- a/src/dagre-wrapper/clusters.js
+++ b/src/dagre-wrapper/clusters.js
@@ -1,8 +1,10 @@
 import intersectRect from './intersect/intersect-rect';
-import { logger } from '../logger'; // eslint-disable-line
+import { logger as log } from '../logger'; // eslint-disable-line
 import createLabel from './createLabel';
 
 const rect = (parent, node) => {
+  log.info('Creating subgraph rect for ', node.id, node);
+
   // Add outer g element
   const shapeSvg = parent
     .insert('g')
@@ -22,7 +24,10 @@ const rect = (parent, node) => {
 
   const padding = 0 * node.padding;
   const halfPadding = padding / 2;
+  const width = node.width || 50;
+  const height = node.height || 50;
 
+  log.info('Data ', node, JSON.stringify(node));
   // center the rect around its coordinate
   rect
     .attr('rx', node.rx)
@@ -32,7 +37,7 @@ const rect = (parent, node) => {
     .attr('width', node.width + padding)
     .attr('height', node.height + padding);
 
-  // logger.info('bbox', bbox.width, node.x, node.width);
+  // log.info('bbox', bbox.width, node.x, node.width);
   // Center the label
   // label.attr('transform', 'translate(' + adj + ', ' + (node.y - node.height / 2) + ')');
   label.attr(
@@ -127,7 +132,7 @@ const roundedWithTitle = (parent, node) => {
     .attr('width', node.width + padding)
     .attr('height', node.height + padding - bbox.height - 3);
 
-  // logger.info('bbox', bbox.width, node.x, node.width);
+  // log.info('bbox', bbox.width, node.x, node.width);
   // Center the label
   // label.attr('transform', 'translate(' + adj + ', ' + (node.y - node.height / 2) + ')');
   label.attr(
@@ -155,7 +160,9 @@ const shapes = { rect, roundedWithTitle, noteGroup };
 let clusterElems = {};
 
 export const insertCluster = (elem, node) => {
-  clusterElems[node.id] = shapes[node.shape](elem, node);
+  log.info('Inserting cluster');
+  const shape = node.shape || 'rect';
+  clusterElems[node.id] = shapes[shape](elem, node);
 };
 export const getClusterTitleWidth = (elem, node) => {
   const label = createLabel(node.labelText, node.labelStyle);
@@ -170,6 +177,8 @@ export const clear = () => {
 };
 
 export const positionCluster = node => {
+  log.info('Position cluster');
   const el = clusterElems[node.id];
+
   el.attr('transform', 'translate(' + node.x + ', ' + node.y + ')');
 };
diff --git a/src/dagre-wrapper/index.js b/src/dagre-wrapper/index.js
index eb0427215..f3dd6c885 100644
--- a/src/dagre-wrapper/index.js
+++ b/src/dagre-wrapper/index.js
@@ -1,62 +1,38 @@
 import dagre from 'dagre';
+import graphlib from 'graphlib';
 import insertMarkers from './markers';
-import { clear as cleargraphlib, clusterDb, adjustClustersAndEdges } from './mermaid-graphlib';
-import { insertNode, positionNode, clear as clearNodes } from './nodes';
-import { insertCluster, clear as clearClusters } from './clusters';
+import { updateNodeBounds } from './shapes/util';
+import {
+  clear as clearGraphlib,
+  clusterDb,
+  adjustClustersAndEdges,
+  findNonClusterChild
+} from './mermaid-graphlib';
+import { insertNode, positionNode, clear as clearNodes, setNodeElem } from './nodes';
+import { insertCluster, clear as clearClusters, positionCluster } from './clusters';
 import { insertEdgeLabel, positionEdgeLabel, insertEdge, clear as clearEdges } from './edges';
-import { logger } from '../logger';
+import { logger as log } from '../logger';
 
 // let clusterDb = {};
 
 const getAnchorId = id => {
   // Only insert an achor once
   if (clusterDb[id]) {
-    //   if (!clusterDb[id].inserted) {
-    //     // Create anchor node for cluster
-    //     const anchorData = {
-    //       shape: 'start',
-    //       labelText: '',
-    //       classes: '',
-    //       style: '',
-    //       id: id + '_anchor',
-    //       type: 'anchor',
-    //       padding: 0
-    //     };
-    //     insertNode(nodes, anchorData);
-
-    //     graph.setNode(anchorData.id, anchorData);
-    //     graph.setParent(anchorData.id, id);
-    //     clusterDb[id].inserted = true;
-    //   }
     return clusterDb[id].id;
   }
   return id;
 };
 
-const findNonClusterChild = (id, graph) => {
-  const node = graph.node(id);
-  logger.info('identified node', node);
-  if (node.type !== 'group') {
-    return node.id;
+const recursiveRender = (_elem, graph, diagramtype) => {
+  const elem = _elem.insert('g').attr('class', 'root'); // eslint-disable-line
+  if (!graph.nodes()) {
+    log.info('No nodes found for', graph);
+  } else {
+    log.info('Recursive render', graph.edges());
   }
-  logger.info('identified node Not', node.id);
-  const children = graph.children(id);
-  for (let i = 0; i < children.length; i++) {
-    const _id = findNonClusterChild(children[i], graph);
-    if (_id) {
-      return _id;
-    }
+  if (graph.edges().length > 0) {
+    log.info('Recursive edges', graph.edge(graph.edges()[0]));
   }
-};
-
-export const render = (elem, graph, markers, diagramtype, id) => {
-  insertMarkers(elem, markers, diagramtype, id);
-  clearNodes();
-  clearEdges();
-  clearClusters();
-
-  adjustClustersAndEdges(graph);
-
   const clusters = elem.insert('g').attr('class', 'clusters'); // eslint-disable-line
   const edgePaths = elem.insert('g').attr('class', 'edgePaths');
   const edgeLabels = elem.insert('g').attr('class', 'edgeLabels');
@@ -66,81 +42,115 @@ export const render = (elem, graph, markers, diagramtype, id) => {
   // to the abstract node and is later used by dagre for the layout
   graph.nodes().forEach(function(v) {
     const node = graph.node(v);
-    logger.info('Node ' + v + ': ' + JSON.stringify(graph.node(v)));
-    if (node.type !== 'group') {
-      insertNode(nodes, graph.node(v));
-    } else {
+    log.info('(Insert) Node ' + v + ': ' + JSON.stringify(graph.node(v)));
+    if (node.clusterNode) {
       // const children = graph.children(v);
-      // logger.info('Cluster identified', node.id, children[0], findNonClusterChild(node.id, graph));
-      // clusterDb[node.id] = { id: findNonClusterChild(node.id, graph) };
+      log.info('Cluster identified', v, node, graph.node(v));
+      const newEl = recursiveRender(clusters, node.graph, diagramtype);
+      updateNodeBounds(node, newEl);
+      setNodeElem(newEl, node);
+
+      log.info('Recursice render complete', newEl, node);
+    } else {
+      if (graph.children(v).length > 0) {
+        // This is a cluster but not to be rendered recusively
+        // Render as before
+        log.info('Cluster - the non recursive path', v, node.id, node, graph);
+        log.info(findNonClusterChild(node.id, graph));
+        clusterDb[node.id] = { id: findNonClusterChild(node.id, graph), node };
+        // insertCluster(clusters, graph.node(v));
+      } else {
+        log.info('Node - the non recursive path', v, node.id, node);
+        insertNode(nodes, graph.node(v));
+      }
     }
   });
-  logger.info('Clusters ', clusterDb);
+  log.info('Clusters ', clusterDb);
 
   // Insert labels, this will insert them into the dom so that the width can be calculated
   // Also figure out which edges point to/from clusters and adjust them accordingly
   // Edges from/to clusters really points to the first child in the cluster.
   // TODO: pick optimal child in the cluster to us as link anchor
   graph.edges().forEach(function(e) {
-    const edge = graph.edge(e);
-    logger.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
-    logger.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(graph.edge(e)));
+    const edge = graph.edge(e.v, e.w, e.name);
+    log.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
+    log.info(
+      'Edge ' + e.v + ' -> ' + e.w + ': ',
+      e,
+      ' ',
+      +JSON.stringify(graph.edge(e.v, e.w, e.name))
+    );
 
     let v = e.v;
     let w = e.w;
     // Check if link is either from or to a cluster
-    logger.info(
-      'Fix',
-      clusterDb,
-      'ids:',
-      e.v,
-      e.w,
-      'Translateing: ',
-      clusterDb[e.v],
-      clusterDb[e.w]
-    );
+    log.info('Fix', clusterDb, 'ids:', e.v, e.w, 'Translateing: ', clusterDb[e.v], clusterDb[e.w]);
     if (clusterDb[e.v] || clusterDb[e.w]) {
-      logger.info('Fixing and trixing - rwemoving', e.v, e.w, e.name);
+      log.info('Fixing and trixing - removing', e.v, e.w, e.name);
       v = getAnchorId(e.v, graph, nodes);
       w = getAnchorId(e.w, graph, nodes);
       graph.removeEdge(e.v, e.w, e.name);
       if (v !== e.v) edge.fromCluster = e.v;
       if (w !== e.w) edge.toCluster = e.w;
-      logger.info('Fixing Replacing with', v, w, e.name);
+      log.info('Fixing Replacing with', v, w, e.name);
       graph.setEdge(v, w, edge, e.name);
     }
     insertEdgeLabel(edgeLabels, edge);
   });
 
   graph.edges().forEach(function(e) {
-    logger.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
+    log.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
   });
-  logger.info('#############################################');
-  logger.info('###                Layout                 ###');
-  logger.info('#############################################');
-  logger.info(graph);
+  log.info('#############################################');
+  log.info('###                Layout                 ###');
+  log.info('#############################################');
+  log.info(graph);
   dagre.layout(graph);
 
   // Move the nodes to the correct place
   graph.nodes().forEach(function(v) {
     const node = graph.node(v);
-    logger.trace('Node ' + v + ': ' + JSON.stringify(graph.node(v)));
-    if (node.type !== 'group') {
-      positionNode(node);
+    log.info('Position ' + v + ': ' + JSON.stringify(graph.node(v)));
+    if (node && node.clusterNode) {
+      // clusterDb[node.id].node = node;
+      // positionNode(node);
     } else {
-      insertCluster(clusters, node);
-      clusterDb[node.id].node = node;
+      // Non cluster node
+      if (graph.children(v).length > 0) {
+        // A cluster in the non-recurive way
+        // positionCluster(node);
+        insertCluster(clusters, node);
+        clusterDb[node.id].node = node;
+      } else {
+        positionNode(node);
+      }
     }
   });
 
   // Move the edge labels to the correct place after layout
   graph.edges().forEach(function(e) {
     const edge = graph.edge(e);
-    logger.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(edge), edge);
+    log.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(edge), edge);
 
     insertEdge(edgePaths, edge, clusterDb, diagramtype);
     positionEdgeLabel(edge);
   });
+
+  return elem;
+};
+
+export const render = (elem, graph, markers, diagramtype, id) => {
+  insertMarkers(elem, markers, diagramtype, id);
+  clearNodes();
+  clearEdges();
+  clearClusters();
+  clearGraphlib();
+
+  log.warn('Graph before:', graphlib.json.write(graph));
+  adjustClustersAndEdges(graph);
+  log.warn('Graph after:', graphlib.json.write(graph));
+
+  recursiveRender(elem, graph, diagramtype);
 };
 
 // const shapeDefinitions = {};
diff --git a/src/dagre-wrapper/mermaid-graphlib.js b/src/dagre-wrapper/mermaid-graphlib.js
index ae4e4086c..a232c09db 100644
--- a/src/dagre-wrapper/mermaid-graphlib.js
+++ b/src/dagre-wrapper/mermaid-graphlib.js
@@ -13,7 +13,7 @@ export const clear = () => {
 };
 
 const copy = (clusterId, graph, newGraph, rootId) => {
-  logger.trace('Copying ', clusterId);
+  logger.info('Copying ', clusterId, graph.node(clusterId));
   const nodes = graph.children(clusterId);
   nodes.forEach(node => {
     if (graph.children(node).length > 0) {
@@ -21,22 +21,29 @@ const copy = (clusterId, graph, newGraph, rootId) => {
     }
 
     const data = graph.node(node);
-    logger.trace(node, data, ' parent is ', clusterId);
+    logger.info(node, data, ' parent is ', clusterId);
     newGraph.setNode(node, data);
     newGraph.setParent(node, clusterId);
     const edges = graph.edges(node);
-    graph.removeNode(node);
-    logger.trace('Edges', edges);
+    logger.info('Copying Edges', edges);
     edges.forEach(edge => {
-      const data = graph.edge(edge);
-      // Do not copy edges in and out of the root cluster, they belong to the parent graph
-      if (!(edge.v === rootId || edge.w === rootId)) {
-        logger.trace('Copying as ', rootId, edge.v, edge.w, clusterId);
-        newGraph.setEdge(edge.v, edge.w, data);
-      } else {
-        logger.trace('Skipping copy of edge as ', rootId, edge.v, edge.w, clusterId);
+      logger.info('Edge', edge);
+      const data = graph.edge(edge.v, edge.w, edge.name);
+      logger.info('Edge data', data, rootId);
+      try {
+        // Do not copy edges in and out of the root cluster, they belong to the parent graph
+        if (!(edge.v === rootId || edge.w === rootId)) {
+          logger.info('Copying as ', edge.v, edge.w, data, edge.name);
+          newGraph.setEdge(edge.v, edge.w, data, edge.name);
+          logger.info('newgrapg edges ', newGraph.edges(), newGraph.edge(newGraph.edges()[0]));
+        } else {
+          logger.info('Skipping copy of edge as ', rootId, edge.v, edge.w, clusterId);
+        }
+      } catch (e) {
+        logger.error(e);
       }
     });
+    graph.removeNode(node);
   });
   newGraph.setNode(clusterId, graph.node(clusterId));
 };
@@ -60,8 +67,8 @@ export const extractGraphFromCluster = (clusterId, graph) => {
     .setGraph({
       rankdir: 'TB',
       // Todo: set proper spacing
-      nodesep: 10,
-      ranksep: 10,
+      nodesep: 50,
+      ranksep: 50,
       marginx: 8,
       marginy: 8
     })
@@ -69,6 +76,26 @@ export const extractGraphFromCluster = (clusterId, graph) => {
       return {};
     });
 
+  // const conf = getConfig().flowchart;
+  // const nodeSpacing = conf.nodeSpacing || 50;
+  // const rankSpacing = conf.rankSpacing || 50;
+
+  // // Create the input mermaid.graph
+  // const g = new graphlib.Graph({
+  //   multigraph: true,
+  //   compound: true
+  // })
+  //   .setGraph({
+  //     rankdir: 'TB',
+  //     nodesep: nodeSpacing,
+  //     ranksep: rankSpacing,
+  //     marginx: 8,
+  //     marginy: 8
+  //   })
+  //   .setDefaultEdgeLabel(function() {
+  //     return {};
+  //   });
+
   copy(clusterId, graph, clusterGraph, clusterId);
 
   return clusterGraph;
@@ -100,7 +127,7 @@ export const validate = graph => {
  * @param {Finds a } id
  * @param {*} graph
  */
-const findNonClusterChild = (id, graph) => {
+export const findNonClusterChild = (id, graph) => {
   // const node = graph.node(id);
   logger.trace('Searching', id);
   const children = graph.children(id);
@@ -141,7 +168,7 @@ export const adjustClustersAndEdges = graph => {
   graph.nodes().forEach(function(id) {
     const children = graph.children(id);
     if (children.length > 0) {
-      logger.trace(
+      logger.info(
         'Cluster identified',
         id,
         ' Replacement id in edges: ',
@@ -157,13 +184,13 @@ export const adjustClustersAndEdges = graph => {
     const children = graph.children(id);
     const edges = graph.edges();
     if (children.length > 0) {
-      logger.trace('Cluster identified', id);
+      logger.info('Cluster identified', id);
       edges.forEach(edge => {
-        logger.trace('Edge: ', edge, decendants[id]);
+        logger.info('Edge: ', edge, decendants[id]);
         // Check if any edge leaves the cluster (not the actual cluster, thats a link from the box)
         if (edge.v !== id && edge.w !== id) {
           if (decendants[id].indexOf(edge.v) < 0 || decendants[id].indexOf(edge.w) < 0) {
-            logger.trace('Edge: ', edge, ' leaves cluster ', id);
+            logger.info('Edge: ', edge, ' leaves cluster ', id);
             clusterDb[id].externalConnections = true;
           }
         }
@@ -189,7 +216,13 @@ export const adjustClustersAndEdges = graph => {
 
       // Create a new node in the original graph, this new node is not a cluster
       // but a regular node with the cluster dontent as a new attached graph
-      graph.setNode(clusterId, { clusterNode: true, graph: clusterGraph });
+      graph.setNode(clusterId, {
+        clusterNode: true,
+        id: clusterId,
+        clusterData: clusterDb[clusterId],
+        labelText: clusterDb[clusterId].labelText,
+        graph: clusterGraph
+      });
 
       // The original edges in and out of the cluster is applied
       edges.forEach(edge => {
@@ -205,7 +238,7 @@ export const adjustClustersAndEdges = graph => {
   graph.edges().forEach(function(e) {
     const edge = graph.edge(e);
     logger.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
-    logger.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(graph.edge(e)));
+    logger.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(graph.edge(e)));
 
     let v = e.v;
     let w = e.w;
diff --git a/src/dagre-wrapper/mermaid-graphlib.spec.js b/src/dagre-wrapper/mermaid-graphlib.spec.js
index b842a455b..cd0c29b34 100644
--- a/src/dagre-wrapper/mermaid-graphlib.spec.js
+++ b/src/dagre-wrapper/mermaid-graphlib.spec.js
@@ -135,7 +135,7 @@ describe('Graphlib decorations', () => {
       expect(newGraph.edges('a')).toEqual([{ v: 'a', w: 'b' }]);
     });
 
-    it('It is possible to extract a clusters to a new graph 2', function () {
+    it('It is possible to extract a clusters to a new graph 2 GLB1', function () {
       /*
         subgraph C1
           a --> b
@@ -163,7 +163,7 @@ describe('Graphlib decorations', () => {
       expect(g.children('C2')).toEqual([]);
       expect(g.edges()).toEqual([{ v: 'C1', w: 'C2' }]);
 
-      logger.info(C1.nodes());
+      logger.info(g.nodes());
       expect(C1.nodes()).toEqual(['a', 'C1', 'b']);
       expect(C1.children('C1')).toEqual(['a', 'b']);
       expect(C1.edges()).toEqual([{ v: 'a', w: 'b' }]);
@@ -200,7 +200,7 @@ describe('Graphlib decorations', () => {
       expect(g.children('C1')).toEqual([]);
     });
   });
-    it('Validate should detect edges between clusters and transform clusters', function () {
+    it('Validate should detect edges between clusters and transform clusters GLB4', function () {
       /*
         a --> b
         subgraph C1
@@ -225,4 +225,29 @@ describe('Graphlib decorations', () => {
       expect(g.nodes().length).toBe(2);
       expect(validate(g)).toBe(true);
     });
+    it('Validate should detect edges between clusters and transform clusters GLB5', function () {
+      /*
+        a --> b
+        subgraph C1
+          a
+        end
+        subgraph C2
+          b
+        end
+        C1 -->
+      */
+      g.setNode('a', { data: 1 });
+      g.setNode('b', { data: 2 });
+      g.setParent('a', 'C1');
+      g.setParent('b', 'C2');
+      g.setParent('C1', 'C2');
+      // g.setEdge('a', 'b', { name: 'C1-internal-link' });
+      g.setEdge('C1', 'C2', { name: 'C1-external-link' });
+
+      logger.info(g.nodes())
+      adjustClustersAndEdges(g);
+      logger.info(g.nodes())
+      expect(g.nodes().length).toBe(2);
+      expect(validate(g)).toBe(true);
+    });
 });
diff --git a/src/dagre-wrapper/nodes.js b/src/dagre-wrapper/nodes.js
index f1db09a43..47be56991 100644
--- a/src/dagre-wrapper/nodes.js
+++ b/src/dagre-wrapper/nodes.js
@@ -387,6 +387,9 @@ let nodeElems = {};
 export const insertNode = (elem, node) => {
   nodeElems[node.id] = shapes[node.shape](elem, node);
 };
+export const setNodeElem = (elem, node) => {
+  nodeElems[node.id] = elem;
+};
 export const clear = () => {
   nodeElems = {};
 };
diff --git a/src/diagrams/flowchart/flowRenderer-v2.js b/src/diagrams/flowchart/flowRenderer-v2.js
index e0cce8df8..f66bf947c 100644
--- a/src/diagrams/flowchart/flowRenderer-v2.js
+++ b/src/diagrams/flowchart/flowRenderer-v2.js
@@ -314,8 +314,10 @@ export const draw = function(text, id) {
 
   let subG;
   const subGraphs = flowDb.getSubGraphs();
+  logger.info('Subgraphs - ', subGraphs);
   for (let i = subGraphs.length - 1; i >= 0; i--) {
     subG = subGraphs[i];
+    logger.info('Subgraph - ', subG);
     flowDb.addVertex(subG.id, subG.title, 'group', undefined, subG.classes);
   }
 
@@ -347,7 +349,7 @@ export const draw = function(text, id) {
   // Run the renderer. This is what draws the final graph.
   const element = d3.select('#' + id + ' g');
   render(element, g, ['point', 'circle', 'cross'], 'flowchart', id);
-  dagre.layout(g);
+  // dagre.layout(g);
 
   element.selectAll('g.node').attr('title', function() {
     return flowDb.getTooltip(this.id);
@@ -378,27 +380,27 @@ export const draw = function(text, id) {
   // Index nodes
   flowDb.indexNodes('subGraph' + i);
 
-  // reposition labels
-  for (i = 0; i < subGraphs.length; i++) {
-    subG = subGraphs[i];
+  // // reposition labels
+  // for (i = 0; i < subGraphs.length; i++) {
+  //   subG = subGraphs[i];
 
-    if (subG.title !== 'undefined') {
-      const clusterRects = document.querySelectorAll('#' + id + ' [id="' + subG.id + '"] rect');
-      const clusterEl = document.querySelectorAll('#' + id + ' [id="' + subG.id + '"]');
+  //   if (subG.title !== 'undefined') {
+  //     const clusterRects = document.querySelectorAll('#' + id + ' [id="' + subG.id + '"] rect');
+  //     const clusterEl = document.querySelectorAll('#' + id + ' [id="' + subG.id + '"]');
 
-      const xPos = clusterRects[0].x.baseVal.value;
-      const yPos = clusterRects[0].y.baseVal.value;
-      const width = clusterRects[0].width.baseVal.value;
-      const cluster = d3.select(clusterEl[0]);
-      const te = cluster.select('.label');
-      te.attr('transform', `translate(${xPos + width / 2}, ${yPos + 14})`);
-      te.attr('id', id + 'Text');
+  //     const xPos = clusterRects[0].x.baseVal.value;
+  //     const yPos = clusterRects[0].y.baseVal.value;
+  //     const width = clusterRects[0].width.baseVal.value;
+  //     const cluster = d3.select(clusterEl[0]);
+  //     const te = cluster.select('.label');
+  //     te.attr('transform', `translate(${xPos + width / 2}, ${yPos + 14})`);
+  //     te.attr('id', id + 'Text');
 
-      for (let j = 0; j < subG.classes.length; j++) {
-        clusterEl[0].classList.add(subG.classes[j]);
-      }
-    }
-  }
+  //     for (let j = 0; j < subG.classes.length; j++) {
+  //       clusterEl[0].classList.add(subG.classes[j]);
+  //     }
+  //   }
+  // }
 
   // Add label rects for non html labels
   if (!conf.htmlLabels) {

From 704d56d193d97b3423b27edeba23c3bb3513db9d Mon Sep 17 00:00:00 2001
From: Knut Sveidqvist <knut.sveidqvist@ipiccolo.com>
Date: Mon, 13 Apr 2020 16:25:10 +0200
Subject: [PATCH 06/12] #1295 Updates mermaid-graphlib

---
 cypress/platform/current.html              |  14 +-
 src/dagre-wrapper/clusters.js              |   2 -
 src/dagre-wrapper/index.js                 |  53 ++-
 src/dagre-wrapper/mermaid-graphlib.js      | 505 +++++++++++++++++----
 src/dagre-wrapper/mermaid-graphlib.spec.js | 348 +++++++++-----
 src/dagre-wrapper/nodes.js                 |   2 +
 src/diagrams/flowchart/flowRenderer-v2.js  |   1 -
 7 files changed, 701 insertions(+), 224 deletions(-)

diff --git a/cypress/platform/current.html b/cypress/platform/current.html
index 50cb3ed3c..dd32f0be0 100644
--- a/cypress/platform/current.html
+++ b/cypress/platform/current.html
@@ -87,9 +87,19 @@ stateDiagram-v2
     </div>
       <div class="mermaid" style="width: 100%; height: 100%;">
 flowchart TD
-    subgraph Apa
-      a --> b
+    subgraph A
+      a
     end
+    subgraph B
+      b
+    end
+    subgraph C
+      subgraph D
+        d
+      end
+    end
+    A -- oAo --> B
+    A --> C
     </div>
       <div class="mermaid2" style="width: 100%; height: 100%;">
 stateDiagram-v2
diff --git a/src/dagre-wrapper/clusters.js b/src/dagre-wrapper/clusters.js
index 02da85c58..ff65496a1 100644
--- a/src/dagre-wrapper/clusters.js
+++ b/src/dagre-wrapper/clusters.js
@@ -24,8 +24,6 @@ const rect = (parent, node) => {
 
   const padding = 0 * node.padding;
   const halfPadding = padding / 2;
-  const width = node.width || 50;
-  const height = node.height || 50;
 
   log.info('Data ', node, JSON.stringify(node));
   // center the rect around its coordinate
diff --git a/src/dagre-wrapper/index.js b/src/dagre-wrapper/index.js
index f3dd6c885..c1b2b7933 100644
--- a/src/dagre-wrapper/index.js
+++ b/src/dagre-wrapper/index.js
@@ -9,7 +9,7 @@ import {
   findNonClusterChild
 } from './mermaid-graphlib';
 import { insertNode, positionNode, clear as clearNodes, setNodeElem } from './nodes';
-import { insertCluster, clear as clearClusters, positionCluster } from './clusters';
+import { insertCluster, clear as clearClusters } from './clusters';
 import { insertEdgeLabel, positionEdgeLabel, insertEdge, clear as clearEdges } from './edges';
 import { logger as log } from '../logger';
 
@@ -24,11 +24,12 @@ const getAnchorId = id => {
 };
 
 const recursiveRender = (_elem, graph, diagramtype) => {
+  log.info('Graph in recursive render:', graphlib.json.write(graph));
   const elem = _elem.insert('g').attr('class', 'root'); // eslint-disable-line
   if (!graph.nodes()) {
     log.info('No nodes found for', graph);
   } else {
-    log.info('Recursive render', graph.edges());
+    log.info('Recursive render', graph.nodes());
   }
   if (graph.edges().length > 0) {
     log.info('Recursive edges', graph.edge(graph.edges()[0]));
@@ -50,7 +51,7 @@ const recursiveRender = (_elem, graph, diagramtype) => {
       updateNodeBounds(node, newEl);
       setNodeElem(newEl, node);
 
-      log.info('Recursice render complete', newEl, node);
+      log.warn('Recursive render complete', newEl, node);
     } else {
       if (graph.children(v).length > 0) {
         // This is a cluster but not to be rendered recusively
@@ -65,7 +66,6 @@ const recursiveRender = (_elem, graph, diagramtype) => {
       }
     }
   });
-  log.info('Clusters ', clusterDb);
 
   // Insert labels, this will insert them into the dom so that the width can be calculated
   // Also figure out which edges point to/from clusters and adjust them accordingly
@@ -74,27 +74,24 @@ const recursiveRender = (_elem, graph, diagramtype) => {
   graph.edges().forEach(function(e) {
     const edge = graph.edge(e.v, e.w, e.name);
     log.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
-    log.info(
-      'Edge ' + e.v + ' -> ' + e.w + ': ',
-      e,
-      ' ',
-      +JSON.stringify(graph.edge(e.v, e.w, e.name))
-    );
+    log.info('Edge ' + e.v + ' -> ' + e.w + ': ', e, ' ', JSON.stringify(graph.edge(e)));
 
     let v = e.v;
     let w = e.w;
     // Check if link is either from or to a cluster
     log.info('Fix', clusterDb, 'ids:', e.v, e.w, 'Translateing: ', clusterDb[e.v], clusterDb[e.w]);
-    if (clusterDb[e.v] || clusterDb[e.w]) {
-      log.info('Fixing and trixing - removing', e.v, e.w, e.name);
-      v = getAnchorId(e.v, graph, nodes);
-      w = getAnchorId(e.w, graph, nodes);
-      graph.removeEdge(e.v, e.w, e.name);
-      if (v !== e.v) edge.fromCluster = e.v;
-      if (w !== e.w) edge.toCluster = e.w;
-      log.info('Fixing Replacing with', v, w, e.name);
-      graph.setEdge(v, w, edge, e.name);
-    }
+    // Todo handle case with links
+
+    // if (clusterDb[e.v] || clusterDb[e.w]) {
+    //   log.info('Fixing and trixing - removing', e.v, e.w, e.name);
+    //   v = getAnchorId(e.v, graph, nodes);
+    //   w = getAnchorId(e.w, graph, nodes);
+    //   graph.removeEdge(e.v, e.w, e.name);
+    //   if (v !== e.v) edge.fromCluster = e.v;
+    //   if (w !== e.w) edge.toCluster = e.w;
+    //   log.info('Fixing Replacing with', v, w, e.name);
+    //   graph.setEdge(v, w, edge, e.name);
+    // }
     insertEdgeLabel(edgeLabels, edge);
   });
 
@@ -106,14 +103,22 @@ const recursiveRender = (_elem, graph, diagramtype) => {
   log.info('#############################################');
   log.info(graph);
   dagre.layout(graph);
-
+  log.warn('Graph after layout:', graphlib.json.write(graph));
   // Move the nodes to the correct place
   graph.nodes().forEach(function(v) {
     const node = graph.node(v);
-    log.info('Position ' + v + ': ' + JSON.stringify(graph.node(v)));
+    // log.info('Position ' + v + ': ' + JSON.stringify(graph.node(v)));
+    log.info(
+      'Position ' + v + ': (' + node.x,
+      ',' + node.y,
+      ') width: ',
+      node.width,
+      ' height: ',
+      node.height
+    );
     if (node && node.clusterNode) {
       // clusterDb[node.id].node = node;
-      // positionNode(node);
+      positionNode(node);
     } else {
       // Non cluster node
       if (graph.children(v).length > 0) {
@@ -130,7 +135,7 @@ const recursiveRender = (_elem, graph, diagramtype) => {
   // Move the edge labels to the correct place after layout
   graph.edges().forEach(function(e) {
     const edge = graph.edge(e);
-    log.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(edge), edge);
+    log.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(edge), edge);
 
     insertEdge(edgePaths, edge, clusterDb, diagramtype);
     positionEdgeLabel(edge);
diff --git a/src/dagre-wrapper/mermaid-graphlib.js b/src/dagre-wrapper/mermaid-graphlib.js
index a232c09db..30f69dbd9 100644
--- a/src/dagre-wrapper/mermaid-graphlib.js
+++ b/src/dagre-wrapper/mermaid-graphlib.js
@@ -1,58 +1,152 @@
 /**
  * Decorates with functions required by mermaids dagre-wrapper.
  */
-import { logger } from '../logger';
+import { logger as log } from '../logger';
 import graphlib from 'graphlib';
 
 export let clusterDb = {};
 let decendants = {};
+let parents = {};
+let graphs = {};
 
 export const clear = () => {
   decendants = {};
+  parents = {};
   clusterDb = {};
+  graphs = {};
 };
 
-const copy = (clusterId, graph, newGraph, rootId) => {
-  logger.info('Copying ', clusterId, graph.node(clusterId));
+const isDecendant = (id, ancenstorId) => {
+  // if (id === ancenstorId) return true;
+
+  log.info('In isDecendant', ancenstorId, ' ', id, ' = ', decendants[ancenstorId].indexOf(id) >= 0);
+  if (decendants[ancenstorId].indexOf(id) >= 0) return true;
+
+  return false;
+};
+
+const edgeInCluster = (edge, clusterId) => {
+  // Edges to/from the cluster is not in the cluster, they are in the parent
+  if (!(edge.v === clusterId || edge.w === clusterId)) return false;
+
+  if (!decendants[clusterId]) {
+    log.info('Tilt, ', clustedId, ',not in decendants');
+    return false;
+  }
+
+  if (decendants[clusterId].indexOf(edge.v) >= 0) return true;
+  if (isDecendant(edge.v, clusterId)) return true;
+  if (isDecendant(edge.w, clusterId)) return true;
+  if (decendants[clusterId].indexOf(edge.w) >= 0) return true;
+
+  return false;
+};
+
+const copyOld = (clusterId, graph, newGraph, rootId) => {
+  log.info('Copying to', rootId, ' from ', clusterId, graph.node(clusterId), rootId);
   const nodes = graph.children(clusterId);
+  log.info('Copying (nodes)', nodes);
+  if (nodes) {
+    nodes.forEach(node => {
+      if (graph.children(node).length > 0) {
+        copy(node, graph, newGraph, rootId);
+      } else {
+        // if (clusterId === rootId) {
+        const data = graph.node(node);
+        log.info('cp ', node, ' to ', rootId, ' with parent ', clusterId); //,node, data, ' parent is ', clusterId);
+        newGraph.setNode(node, data);
+        newGraph.setParent(node, clusterId);
+        const edges = graph.edges(node);
+        log.trace('Copying Edges', edges);
+        edges.forEach(edge => {
+          log.trace('Edge', edge);
+          const data = graph.edge(edge.v, edge.w, edge.name);
+          log.trace('Edge data', data, rootId);
+          try {
+            // Do not copy edges in and out of the root cluster, they belong to the parent graph
+            if (edgeInCluster(edge, rootId)) {
+              log.trace('Copying as ', edge.v, edge.w, data, edge.name);
+              newGraph.setEdge(edge.v, edge.w, data, edge.name);
+              log.trace('newGraph edges ', newGraph.edges(), newGraph.edge(newGraph.edges()[0]));
+            } else {
+              log.trace('Skipping copy of edge as ', rootId, edge.v, edge.w, clusterId);
+            }
+          } catch (e) {
+            log.error(e);
+          }
+        });
+        // } else {
+        //   log.info('Skipping leaf as root ', rootId, ' !== ', clusterId, ' leaf id = ', node);
+        // }
+      }
+      // log.info('Removing node', node, graphlib.json.write(graph));
+      log.info('Removing node', node);
+      graph.removeNode(node);
+    });
+  }
+  // newGraph.setNode(clusterId, graph.node(clusterId));
+};
+const copy = (clusterId, graph, newGraph, rootId) => {
+  log.trace(
+    'Copying children of ',
+    clusterId,
+    rootId,
+    ' from ',
+    clusterId,
+    graph.node(clusterId),
+    rootId
+  );
+  const nodes = graph.children(clusterId) || [];
+
+  // Include cluster node if it is not the root
+  if (clusterId !== rootId) {
+    nodes.push(clusterId);
+  }
+
+  log.info('Copying (nodes)', nodes);
+
   nodes.forEach(node => {
     if (graph.children(node).length > 0) {
       copy(node, graph, newGraph, rootId);
-    }
-
-    const data = graph.node(node);
-    logger.info(node, data, ' parent is ', clusterId);
-    newGraph.setNode(node, data);
-    newGraph.setParent(node, clusterId);
-    const edges = graph.edges(node);
-    logger.info('Copying Edges', edges);
-    edges.forEach(edge => {
-      logger.info('Edge', edge);
-      const data = graph.edge(edge.v, edge.w, edge.name);
-      logger.info('Edge data', data, rootId);
-      try {
-        // Do not copy edges in and out of the root cluster, they belong to the parent graph
-        if (!(edge.v === rootId || edge.w === rootId)) {
-          logger.info('Copying as ', edge.v, edge.w, data, edge.name);
-          newGraph.setEdge(edge.v, edge.w, data, edge.name);
-          logger.info('newgrapg edges ', newGraph.edges(), newGraph.edge(newGraph.edges()[0]));
-        } else {
-          logger.info('Skipping copy of edge as ', rootId, edge.v, edge.w, clusterId);
-        }
-      } catch (e) {
-        logger.error(e);
+    } else {
+      const data = graph.node(node);
+      log.trace('cp ', node, ' to ', rootId, ' with parent ', clusterId); //,node, data, ' parent is ', clusterId);
+      newGraph.setNode(node, data);
+      if (clusterId !== rootId && node !== clusterId) {
+        log.info('Setting parent', node, clusterId);
+        newGraph.setParent(node, clusterId);
       }
-    });
+      const edges = graph.edges(node);
+      log.info('Copying Edges', edges);
+      edges.forEach(edge => {
+        log.trace('Edge', edge);
+        const data = graph.edge(edge.v, edge.w, edge.name);
+        log.trace('Edge data', data, rootId);
+        try {
+          // Do not copy edges in and out of the root cluster, they belong to the parent graph
+          if (edgeInCluster(edge, rootId)) {
+            log.trace('Copying as ', edge.v, edge.w, data, edge.name);
+            newGraph.setEdge(edge.v, edge.w, data, edge.name);
+            log.trace('newGraph edges ', newGraph.edges(), newGraph.edge(newGraph.edges()[0]));
+          } else {
+            log.trace('Skipping copy of edge as ', rootId, edge.v, edge.w, clusterId);
+          }
+        } catch (e) {
+          log.error(e);
+        }
+      });
+    }
+    log.info('Removing node', node);
     graph.removeNode(node);
   });
-  newGraph.setNode(clusterId, graph.node(clusterId));
 };
-
-const extractDecendants = (id, graph) => {
+export const extractDecendants = (id, graph) => {
+  // log.info('Extracting ', id);
   const children = graph.children(id);
   let res = [].concat(children);
 
   for (let i = 0; i < children.length; i++) {
+    parents[children[i]] = id;
     res = res.concat(extractDecendants(children[i], graph));
   }
 
@@ -60,6 +154,7 @@ const extractDecendants = (id, graph) => {
 };
 
 export const extractGraphFromCluster = (clusterId, graph) => {
+  log.info('Extracting graph ', clusterId);
   const clusterGraph = new graphlib.Graph({
     multigraph: true,
     compound: true
@@ -96,8 +191,25 @@ export const extractGraphFromCluster = (clusterId, graph) => {
   //     return {};
   //   });
 
+  log.trace('Extracting before copy', graphlib.json.write(graph));
+  log.trace('Extracting before copy', graphlib.json.write(graph));
   copy(clusterId, graph, clusterGraph, clusterId);
+  log.trace('Extracting after copy', graphlib.json.write(graph));
+  log.trace('Extracting after copy', clusterGraph.nodes());
+  graphs[clusterId] = clusterGraph;
 
+  // Remove references to extracted cluster
+  // graph.edges().forEach(edge => {
+  //   if (isDecendant(edge.v, clusterId) || isDecendant(edge.w, clusterId)) {
+  //     graph.removeEdge(edge);
+  //   }
+  // });
+  // graph.nodes().forEach(node => {
+  //   if (isDecendant(node, clusterId)) {
+  //     log.info('Removing ', node, ' from ', clusterId);
+  //     graph.removeNode(node);
+  //   }
+  // });
   return clusterGraph;
 };
 
@@ -108,14 +220,14 @@ export const extractGraphFromCluster = (clusterId, graph) => {
  */
 export const validate = graph => {
   const edges = graph.edges();
-  logger.trace('Edges: ', edges);
+  log.trace('Edges: ', edges);
   for (let i = 0; i < edges.length; i++) {
     if (graph.children(edges[i].v).length > 0) {
-      logger.trace('The node ', edges[i].v, ' is part of and edge even though it has children');
+      log.trace('The node ', edges[i].v, ' is part of and edge even though it has children');
       return false;
     }
     if (graph.children(edges[i].w).length > 0) {
-      logger.trace('The node ', edges[i].w, ' is part of and edge even though it has children');
+      log.trace('The node ', edges[i].w, ' is part of and edge even though it has children');
       return false;
     }
   }
@@ -129,16 +241,16 @@ export const validate = graph => {
  */
 export const findNonClusterChild = (id, graph) => {
   // const node = graph.node(id);
-  logger.trace('Searching', id);
+  log.trace('Searching', id);
   const children = graph.children(id);
   if (children.length < 1) {
-    logger.trace('This is a valid node', id);
+    log.trace('This is a valid node', id);
     return id;
   }
   for (let i = 0; i < children.length; i++) {
     const _id = findNonClusterChild(children[i], graph);
     if (_id) {
-      logger.trace('Found replacement for', id, ' => ', _id);
+      log.trace('Found replacement for', id, ' => ', _id);
       return _id;
     }
   }
@@ -160,15 +272,19 @@ const getAnchorId = id => {
   return id;
 };
 
-export const adjustClustersAndEdges = graph => {
-  // calc decendants, sa
-
+export const adjustClustersAndEdges = (graph, depth) => {
+  if (!graph || depth > 10) {
+    log.info('Opting out, no graph ');
+    return;
+  } else {
+    log.info('Opting in, graph ');
+  }
   // Go through the nodes and for each cluster found, save a replacment node, this can be used when
   // faking a link to a cluster
   graph.nodes().forEach(function(id) {
     const children = graph.children(id);
     if (children.length > 0) {
-      logger.info(
+      log.trace(
         'Cluster identified',
         id,
         ' Replacement id in edges: ',
@@ -184,13 +300,22 @@ export const adjustClustersAndEdges = graph => {
     const children = graph.children(id);
     const edges = graph.edges();
     if (children.length > 0) {
-      logger.info('Cluster identified', id);
+      log.info('Cluster identified', id, decendants);
       edges.forEach(edge => {
-        logger.info('Edge: ', edge, decendants[id]);
+        // log.info('Edge, decendants: ', edge, decendants[id]);
+
         // Check if any edge leaves the cluster (not the actual cluster, thats a link from the box)
         if (edge.v !== id && edge.w !== id) {
-          if (decendants[id].indexOf(edge.v) < 0 || decendants[id].indexOf(edge.w) < 0) {
-            logger.info('Edge: ', edge, ' leaves cluster ', id);
+          // Any edge where either the one of the nodes is decending to the cluster but not the other
+          // if (decendants[id].indexOf(edge.v) < 0 && decendants[id].indexOf(edge.w) < 0) {
+
+          const d1 = isDecendant(edge.v, id);
+          const d2 = isDecendant(edge.w, id);
+
+          // d1 xor d2 - if either d1 is true and d2 is false or the other way around
+          if (d1 ^ d2) {
+            log.info('Edge: ', edge, ' leaves cluster ', id);
+            log.info('Decendants of ', id, ': ', decendants[id]);
             clusterDb[id].externalConnections = true;
           }
         }
@@ -198,73 +323,265 @@ export const adjustClustersAndEdges = graph => {
     }
   });
 
-  // For clusters without incoming and/or outgoing edges, create a new cluster-node
-  // containing the nodes and edges in the custer in a new graph
-  // for (let i = 0;)
-  const clusters = Object.keys(clusterDb);
-  // clusters.forEach(clusterId => {
-  for (let i = 0; i < clusters.length; i++) {
-    const clusterId = clusters[i];
-    if (!clusterDb[clusterId].externalConnections) {
-      logger.trace('Cluster without external connections', clusterId);
-      const edges = graph.nodeEdges(clusterId);
+  extractor(graph, 0);
 
-      // New graph with the nodes in the cluster
-      const clusterGraph = extractGraphFromCluster(clusterId, graph);
-      logger.trace('Cluster graph', clusterGraph.nodes());
-      logger.trace('Graph', graph.nodes());
-
-      // Create a new node in the original graph, this new node is not a cluster
-      // but a regular node with the cluster dontent as a new attached graph
-      graph.setNode(clusterId, {
-        clusterNode: true,
-        id: clusterId,
-        clusterData: clusterDb[clusterId],
-        labelText: clusterDb[clusterId].labelText,
-        graph: clusterGraph
-      });
-
-      // The original edges in and out of the cluster is applied
-      edges.forEach(edge => {
-        logger.trace('Setting edge', edge);
-        const data = graph.edge(edge);
-        graph.setEdge(edge.v, edge.w, data);
-      });
-    }
-  }
-  logger.trace('Graph', graph.nodes());
   // For clusters with incoming and/or outgoing edges translate those edges to a real node
   // in the cluster inorder to fake the edge
   graph.edges().forEach(function(e) {
     const edge = graph.edge(e);
-    logger.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
-    logger.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(graph.edge(e)));
+    log.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
+    log.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(graph.edge(e)));
 
     let v = e.v;
     let w = e.w;
     // Check if link is either from or to a cluster
-    logger.trace(
-      'Fix',
-      clusterDb,
-      'ids:',
-      e.v,
-      e.w,
-      'Translateing: ',
-      clusterDb[e.v],
-      clusterDb[e.w]
-    );
+    log.trace('Fix', clusterDb, 'ids:', e.v, e.w, 'Translateing: ', clusterDb[e.v], clusterDb[e.w]);
     if (clusterDb[e.v] || clusterDb[e.w]) {
-      logger.trace('Fixing and trixing - removing', e.v, e.w, e.name);
+      log.trace('Fixing and trixing - removing', e.v, e.w, e.name);
       v = getAnchorId(e.v);
       w = getAnchorId(e.w);
       graph.removeEdge(e.v, e.w, e.name);
       if (v !== e.v) edge.fromCluster = e.v;
       if (w !== e.w) edge.toCluster = e.w;
-      logger.trace('Replacing with', v, w, e.name);
+      log.trace('Replacing with', v, w, e.name);
       graph.setEdge(v, w, edge, e.name);
     }
   });
-  logger.trace('Graph', graph.nodes());
+  log.info('Adjusted Graph', graphlib.json.write(graph));
 
-  logger.trace(clusterDb);
+  log.trace(clusterDb);
+
+  // Remove references to extracted cluster
+  // graph.edges().forEach(edge => {
+  //   if (isDecendant(edge.v, clusterId) || isDecendant(edge.w, clusterId)) {
+  //     graph.removeEdge(edge);
+  //   }
+  // });
+};
+
+export const transformClustersToNodes = (graph, depth) => {
+  log.info('transformClustersToNodes - ', depth);
+  if (depth > 10) {
+    log.error('Bailing out');
+    return;
+  }
+  // For clusters without incoming and/or outgoing edges, create a new cluster-node
+  // containing the nodes and edges in the custer in a new graph
+  // for (let i = 0;)
+  const nodes = graph.nodes();
+  let hasChildren = false;
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const children = graph.children(node);
+    hasChildren = hasChildren || children.length > 0;
+  }
+
+  if (!hasChildren) {
+    log.info('Done, no node has children', graph.nodes());
+    return;
+  }
+  // const clusters = Object.keys(clusterDb);
+  // clusters.forEach(clusterId => {
+  log.info('Nodes = ', nodes);
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    log.info(
+      'Handling node',
+      node,
+      clusterDb,
+      clusterDb[node] && !clusterDb[node].externalConnections,
+      !graph.parent(node),
+      graph.node(node)
+    );
+    // Note that the node might have been removed after the Object.keys call so better check
+    // that it still is in the game
+    if (clusterDb[node]) {
+      if (
+        !clusterDb[node].externalConnections &&
+        !graph.parent(node) &&
+        graph.children(node) &&
+        graph.children(node).length > 0
+      ) {
+        log.info('Cluster without external connections', node);
+        // const parentGraph = parent && graphs[parent] ? graphs[parent] : graph;
+        // New graph with the nodes in the cluster
+        log.info('before Extracting ', node, ' parent is ', graph.parent(node));
+        const clusterGraph = extractGraphFromCluster(node, graph);
+
+        if (clusterGraph) {
+          log.trace('Cluster graph', clusterGraph.nodes());
+          log.trace('Graph', graph.edges());
+
+          log.info('Creating node in original', node, clusterGraph);
+
+          // Create a new node in the original graph, this new node is not a cluster
+          // but a regular node with the cluster content as a new attached graph
+          graph.setNode(node, {
+            clusterNode: true,
+            id: node,
+            clusterData: clusterDb[node],
+            labelText: clusterDb[node].labelText,
+            graph: clusterGraph
+          });
+
+          // if any node in the clusterGraph still has children
+          transformClustersToNodes(clusterGraph, depth + 1);
+        }
+
+        // The original edges in and out of the cluster is applied
+        // edges.forEach(edge => {
+        //   log.info('Setting edge', edge);
+        //   const data = graph.edge(edge);
+        //   graph.setEdge(edge.v, edge.w, data);
+        // });
+      }
+    } else {
+      log.info('Not a cluster ', node);
+    }
+  }
+};
+
+export const extractor = (graph, depth) => {
+  log.info('extractor - ', depth, graphlib.json.write(graph), graph.children('D'));
+  if (depth > 10) {
+    log.error('Bailing out');
+    return;
+  }
+  // For clusters without incoming and/or outgoing edges, create a new cluster-node
+  // containing the nodes and edges in the custer in a new graph
+  // for (let i = 0;)
+  let nodes = graph.nodes();
+  let hasChildren = false;
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const children = graph.children(node);
+    hasChildren = hasChildren || children.length > 0;
+  }
+
+  if (!hasChildren) {
+    log.info('Done, no node has children', graph.nodes());
+    return;
+  }
+  // const clusters = Object.keys(clusterDb);
+  // clusters.forEach(clusterId => {
+  log.info('Nodes = ', nodes, depth);
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    log.info(
+      'Extracting node',
+      node,
+      clusterDb,
+      clusterDb[node] && !clusterDb[node].externalConnections,
+      !graph.parent(node),
+      graph.node(node),
+      graph.children('D'),
+      ' Depth ',
+      depth
+    );
+    // Note that the node might have been removed after the Object.keys call so better check
+    // that it still is in the game
+    if (!clusterDb[node]) {
+      // Skip if the node is not a cluster
+      log.info('Not a cluster', node, depth);
+      // break;
+    } else if (
+      !clusterDb[node].externalConnections &&
+      !graph.parent(node) &&
+      graph.children(node) &&
+      graph.children(node).length > 0
+    ) {
+      log.info(
+        'Cluster without external connections, without a parent and with children',
+        node,
+        depth
+      );
+
+      const clusterGraph = new graphlib.Graph({
+        multigraph: true,
+        compound: true
+      })
+        .setGraph({
+          rankdir: 'TB',
+          // Todo: set proper spacing
+          nodesep: 50,
+          ranksep: 50,
+          marginx: 8,
+          marginy: 8
+        })
+        .setDefaultEdgeLabel(function() {
+          return {};
+        });
+
+      copy(node, graph, clusterGraph, node);
+      graph.setNode(node, {
+        clusterNode: true,
+        id: node,
+        clusterData: clusterDb[node],
+        labelText: clusterDb[node].labelText,
+        graph: clusterGraph
+      });
+      log.info('New graph after copy', graphlib.json.write(clusterGraph));
+      log.info('Old graph after copy', graphlib.json.write(graph));
+
+      /*
+      // New graph with the nodes in the cluster
+      log.info('before Extracting ', node, ' parent is ', graph.parent(node));
+      const clusterGraph = extractGraphFromCluster(node, graph);
+
+      if (clusterGraph) {
+        log.trace('Cluster graph', clusterGraph.nodes());
+        log.trace('Graph', graph.edges());
+
+        log.info('Creating node in original', node, clusterGraph);
+
+        // Create a new node in the original graph, this new node is not a cluster
+        // but a regular node with the cluster content as a new attached graph
+        graph.setNode(node, {
+          clusterNode: true,
+          id: node,
+          clusterData: clusterDb[node],
+          labelText: clusterDb[node].labelText,
+          graph: clusterGraph
+        });
+
+        // if any node in the clusterGraph still has children
+        transformClustersToNodes(clusterGraph, depth + 1);
+      }
+
+      // The original edges in and out of the cluster is applied
+      // edges.forEach(edge => {
+      //   log.info('Setting edge', edge);
+      //   const data = graph.edge(edge);
+      //   graph.setEdge(edge.v, edge.w, data);
+      // });
+      */
+    } else {
+      log.info(
+        'Cluster ** ',
+        node,
+        ' **not meeting the criteria !externalConnections:',
+        !clusterDb[node].externalConnections,
+        ' no parent: ',
+        !graph.parent(node),
+        ' children ',
+        graph.children(node) && graph.children(node).length > 0,
+        graph.children('D'),
+        depth
+      );
+      log.info(clusterDb);
+    }
+  }
+
+  nodes = graph.nodes();
+  log.info('New list of nodes', nodes);
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const data = graph.node(node);
+    log.info(' Now next leveö', node, data);
+    if (data.clusterNode) {
+      extractor(data.graph, depth + 1);
+    }
+  }
 };
diff --git a/src/dagre-wrapper/mermaid-graphlib.spec.js b/src/dagre-wrapper/mermaid-graphlib.spec.js
index cd0c29b34..ad483eea7 100644
--- a/src/dagre-wrapper/mermaid-graphlib.spec.js
+++ b/src/dagre-wrapper/mermaid-graphlib.spec.js
@@ -1,6 +1,6 @@
 import graphlib from 'graphlib';
 import dagre from 'dagre';
-import { validate, adjustClustersAndEdges, extractGraphFromCluster } from './mermaid-graphlib';
+import { validate, adjustClustersAndEdges, extractGraphFromCluster, extractDecendants } from './mermaid-graphlib';
 import { setLogLevel, logger } from '../logger';
 
 describe('Graphlib decorations', () => {
@@ -21,40 +21,6 @@ describe('Graphlib decorations', () => {
     g.setDefaultEdgeLabel(function () {
         return {};
     });
-
-//     // Add node 'a' to the graph with no label
-//     g.setNode('a');
-
-//     // Add node 'b' to the graph with a String label
-//     g.setNode('b', 'b's value');
-
-//     // Add node 'c' to the graph with an Object label
-//     g.setNode('c', { k: 123 });
-
-//     // What nodes are in the graph?
-//     g.nodes();
-//     // => `[ 'a', 'b', 'c' ]`
-
-//     // Add a directed edge from 'a' to 'b', but assign no label
-//     g.setEdge('a', 'b');
-
-//     // Add a directed edge from 'c' to 'd' with an Object label.
-//     // Since 'd' did not exist prior to this call it is automatically
-//     // created with an undefined label.
-//     g.setEdge('c', 'd', { k: 456 });
-
-//     // What edges are in the graph?
-//     g.edges();
-//     // => `[ { v: 'a', w: 'b' },
-//     //       { v: 'c', w: 'd' } ]`.
-
-//     // Which edges leave node 'a'?
-//     g.outEdges('a');
-//     // => `[ { v: 'a', w: 'b' } ]`
-
-//     // Which edges enter and leave node 'd'?
-//     g.nodeEdges('d');
-// // => `[ { v: 'c', w: 'd' } ]`
   });
 
   describe('validate', function () {
@@ -135,71 +101,6 @@ describe('Graphlib decorations', () => {
       expect(newGraph.edges('a')).toEqual([{ v: 'a', w: 'b' }]);
     });
 
-    it('It is possible to extract a clusters to a new graph 2 GLB1', function () {
-      /*
-        subgraph C1
-          a --> b
-        end
-        subgraph C2
-          c
-        end
-        C1 --> C2
-      */
-      g.setNode('a', { data: 1 });
-      g.setNode('b', { data: 2 });
-      g.setNode('c', { data: 3 });
-      g.setNode('c', { data: 3 });
-      g.setParent('a', 'C1');
-      g.setParent('b', 'C1');
-      g.setParent('c', 'C2');
-      g.setEdge('a', 'b', { name: 'C1-internal-link' });
-      g.setEdge('C1', 'C2', { name: 'C1-external-link' });
-
-      const C1 = extractGraphFromCluster('C1', g);
-      const C2 = extractGraphFromCluster('C2', g);
-
-      expect(g.nodes()).toEqual(['C1', 'C2']);
-      expect(g.children('C1')).toEqual([]);
-      expect(g.children('C2')).toEqual([]);
-      expect(g.edges()).toEqual([{ v: 'C1', w: 'C2' }]);
-
-      logger.info(g.nodes());
-      expect(C1.nodes()).toEqual(['a', 'C1', 'b']);
-      expect(C1.children('C1')).toEqual(['a', 'b']);
-      expect(C1.edges()).toEqual([{ v: 'a', w: 'b' }]);
-
-      expect(C2.nodes()).toEqual(['c', 'C2']);
-      expect(C2.edges()).toEqual([]);
-    });
-
-    it('It is possible to extract a cluster from a graph so that the nodes are removed from original graph', function () {
-      /*
-        a --> b
-        subgraph C1
-          subgraph C2
-            a
-          end
-          b
-        end
-        C1 --> c
-      */
-      g.setNode('a', { data: 1 });
-      g.setNode('b', { data: 2 });
-      g.setNode('c', { data: 3 });
-      g.setParent('a', 'C2');
-      g.setParent('b', 'C1');
-      g.setParent('C2', 'C1');
-      g.setEdge('a', 'b', { name: 'C1-internal-link' });
-      g.setEdge('C1', 'c', { name: 'C1-external-link' });
-
-      const newGraph = extractGraphFromCluster('C1', g);
-      logger.info(g.nodes());
-      expect(g.nodes()).toEqual(['c','C1']);
-      expect(g.edges().length).toBe(1);
-      expect(g.children()).toEqual(['c','C1']);
-      expect(g.children('C1')).toEqual([]);
-    });
-  });
     it('Validate should detect edges between clusters and transform clusters GLB4', function () {
       /*
         a --> b
@@ -214,6 +115,8 @@ describe('Graphlib decorations', () => {
       g.setNode('a', { data: 1 });
       g.setNode('b', { data: 2 });
       g.setNode('c', { data: 3 });
+      g.setNode('C1', { data: 4 });
+      g.setNode('C2', { data: 5 });
       g.setParent('a', 'C2');
       g.setParent('b', 'C1');
       g.setParent('C2', 'C1');
@@ -240,7 +143,6 @@ describe('Graphlib decorations', () => {
       g.setNode('b', { data: 2 });
       g.setParent('a', 'C1');
       g.setParent('b', 'C2');
-      g.setParent('C1', 'C2');
       // g.setEdge('a', 'b', { name: 'C1-internal-link' });
       g.setEdge('C1', 'C2', { name: 'C1-external-link' });
 
@@ -250,4 +152,248 @@ describe('Graphlib decorations', () => {
       expect(g.nodes().length).toBe(2);
       expect(validate(g)).toBe(true);
     });
+  it('adjustClustersAndEdges GLB6', function () {
+    /*
+      subgraph C1
+        a
+      end
+      C1 --> b
+    */
+    g.setNode('a', { data: 1 });
+    g.setNode('b', { data: 2 });
+    g.setNode('C1', { data: 3 });
+    g.setParent('a', 'C1');
+    g.setEdge('C1', 'b', { data: 'link1' }, '1');
+
+    // logger.info(g.edges())
+    adjustClustersAndEdges(g);
+    logger.info(g.edges())
+    expect(g.nodes()).toEqual(['b', 'C1']);
+    expect(g.edges().length).toBe(1);
+    expect(validate(g)).toBe(true);
+    expect(g.node('C1').clusterNode).toBe(true);
+
+    const C1Graph = g.node('C1').graph;
+    expect(C1Graph.nodes()).toEqual(['a']);
+  });
+  it('adjustClustersAndEdges GLB7', function () {
+    /*
+      subgraph C1
+        a
+      end
+      C1 --> b
+      C1 --> c
+    */
+    g.setNode('a', { data: 1 });
+    g.setNode('b', { data: 2 });
+    g.setNode('c', { data: 3 });
+    g.setParent('a', 'C1');
+    g.setNode('C1', { data: 4 });
+    g.setEdge('C1', 'b', { data: 'link1' }, '1');
+    g.setEdge('C1', 'c', { data: 'link2' }, '2');
+
+    logger.info(g.node('C1'))
+    adjustClustersAndEdges(g);
+    logger.info(g.edges())
+    expect(g.nodes()).toEqual(['b', 'c', 'C1']);
+    expect(g.nodes().length).toBe(3);
+    expect(g.edges().length).toBe(2);
+
+    expect(g.edges().length).toBe(2);
+    const edgeData = g.edge(g.edges()[1]);
+    expect(edgeData.data).toBe('link2');
+    expect(validate(g)).toBe(true);
+
+    const C1Graph = g.node('C1').graph;
+    expect(C1Graph.nodes()).toEqual(['a']);
+  });
+  it('adjustClustersAndEdges GLB8', function () {
+    /*
+    subgraph A
+      a
+    end
+    subgraph B
+      b
+    end
+    subgraph C
+      c
+    end
+    A --> B
+    A --> C
+    */
+    g.setNode('a', { data: 1 });
+    g.setNode('b', { data: 2 });
+    g.setNode('c', { data: 3 });
+    g.setParent('a', 'A');
+    g.setParent('b', 'B');
+    g.setParent('c', 'C');
+    g.setEdge('A', 'B', { data: 'link1' }, '1');
+    g.setEdge('A', 'C', { data: 'link2' }, '2');
+
+    // logger.info(g.edges())
+    adjustClustersAndEdges(g);
+    expect(g.nodes()).toEqual(['A', 'B', 'C']);
+    expect(g.edges().length).toBe(2);
+
+    expect(g.edges().length).toBe(2);
+    const edgeData = g.edge(g.edges()[1]);
+    expect(edgeData.data).toBe('link2');
+    expect(validate(g)).toBe(true);
+
+    const CGraph = g.node('C').graph;
+    expect(CGraph.nodes()).toEqual(['c']);
+
+  });
+
+  it('adjustClustersAndEdges the extracted graphs shall contain the correct data GLB10', function () {
+    /*
+    subgraph C
+      subgraph D
+        d
+      end
+    end
+    */
+
+    g.setNode('C', { data: 1 });
+    g.setNode('D', { data: 2 });
+    g.setNode('d', { data: 3 });
+    g.setParent('d', 'D');
+    g.setParent('D', 'C');
+
+    // logger.info('Graph before', g.node('D'))
+    // logger.info('Graph before', graphlib.json.write(g))
+    adjustClustersAndEdges(g);
+    // logger.info('Graph after', graphlib.json.write(g), g.node('C').graph)
+
+    const CGraph = g.node('C').graph;
+    const DGraph = CGraph.node('D').graph;
+
+    expect(CGraph.nodes()).toEqual(['D']);
+    expect(DGraph.nodes()).toEqual(['d']);
+
+    expect(g.nodes()).toEqual(['C']);
+    expect(g.nodes().length).toBe(1);
+  });
+
+  it('adjustClustersAndEdges the extracted graphs shall contain the correct data GLB11', function () {
+    /*
+    subgraph A
+      a
+    end
+    subgraph B
+      b
+    end
+    subgraph C
+      subgraph D
+        d
+      end
+    end
+    A --> B
+    A --> C
+    */
+
+    g.setNode('C', { data: 1 });
+    g.setNode('D', { data: 2 });
+    g.setNode('d', { data: 3 });
+    g.setNode('B', { data: 4 });
+    g.setNode('b', { data: 5 });
+    g.setNode('A', { data: 6 });
+    g.setNode('a', { data: 7 });
+    g.setParent('a', 'A');
+    g.setParent('b', 'B');
+    g.setParent('d', 'D');
+    g.setParent('D', 'C');
+    g.setEdge('A', 'B', { data: 'link1' }, '1');
+    g.setEdge('A', 'C', { data: 'link2' }, '2');
+
+    logger.info('Graph before', g.node('D'))
+    logger.info('Graph before', graphlib.json.write(g))
+    adjustClustersAndEdges(g);
+    logger.trace('Graph after', graphlib.json.write(g))
+    expect(g.nodes()).toEqual(['C', 'B', 'A']);
+    expect(g.nodes().length).toBe(3);
+    expect(g.edges().length).toBe(2);
+
+    const AGraph = g.node('A').graph;
+    const BGraph = g.node('B').graph;
+    const CGraph = g.node('C').graph;
+    // logger.info(CGraph.nodes());
+    const DGraph = CGraph.node('D').graph;
+    // logger.info('DG', CGraph.children('D'));
+
+    logger.info('A', AGraph.nodes());
+    expect(AGraph.nodes().length).toBe(1);
+    expect(AGraph.nodes()).toEqual(['a']);
+    logger.trace('Nodes', BGraph.nodes())
+    expect(BGraph.nodes().length).toBe(1);
+    expect(BGraph.nodes()).toEqual(['b']);
+    expect(CGraph.nodes()).toEqual(['D']);
+    expect(CGraph.nodes().length).toEqual(1);
+
+    expect(AGraph.edges().length).toBe(0);
+    expect(BGraph.edges().length).toBe(0);
+    expect(CGraph.edges().length).toBe(0);
+    expect(DGraph.nodes()).toEqual(['d']);
+    expect(DGraph.edges().length).toBe(0);
+    // expect(CGraph.node('D')).toEqual({ data: 2 });
+    expect(g.edges().length).toBe(2);
+
+    // expect(g.edges().length).toBe(2);
+    // const edgeData = g.edge(g.edges()[1]);
+    // expect(edgeData.data).toBe('link2');
+    // expect(validate(g)).toBe(true);
+  });
+});
+});
+describe('extractDecendants', function () {
+  let g;
+  beforeEach(function () {
+    setLogLevel(1);
+    g = new graphlib.Graph({
+      multigraph: true,
+      compound: true
+    });
+    g.setGraph({
+      rankdir: 'TB',
+      nodesep: 10,
+      ranksep: 10,
+      marginx: 8,
+      marginy: 8
+    });
+    g.setDefaultEdgeLabel(function () {
+      return {};
+    });
+  });
+  it('Simple case of one level decendants GLB9', function () {
+    /*
+    subgraph A
+      a
+    end
+    subgraph B
+      b
+    end
+    subgraph C
+      c
+    end
+    A --> B
+    A --> C
+    */
+    g.setNode('a', { data: 1 });
+    g.setNode('b', { data: 2 });
+    g.setNode('c', { data: 3 });
+    g.setParent('a', 'A');
+    g.setParent('b', 'B');
+    g.setParent('c', 'C');
+    g.setEdge('A', 'B', { data: 'link1' }, '1');
+    g.setEdge('A', 'C', { data: 'link2' }, '2');
+
+    // logger.info(g.edges())
+    const d1 = extractDecendants('A',g)
+    const d2 = extractDecendants('B',g)
+    const d3 = extractDecendants('C',g)
+
+    expect(d1).toEqual(['a']);
+    expect(d2).toEqual(['b']);
+    expect(d3).toEqual(['c']);
+  });
 });
diff --git a/src/dagre-wrapper/nodes.js b/src/dagre-wrapper/nodes.js
index 47be56991..ec45764e7 100644
--- a/src/dagre-wrapper/nodes.js
+++ b/src/dagre-wrapper/nodes.js
@@ -396,5 +396,7 @@ export const clear = () => {
 
 export const positionNode = node => {
   const el = nodeElems[node.id];
+  logger.debug('Transforming node', node);
   el.attr('transform', 'translate(' + node.x + ', ' + node.y + ')');
+  // el.attr('transform', 'translate(' + node.x / 2 + ', ' + 0 + ')');
 };
diff --git a/src/diagrams/flowchart/flowRenderer-v2.js b/src/diagrams/flowchart/flowRenderer-v2.js
index b76ff361a..9e781a2b5 100644
--- a/src/diagrams/flowchart/flowRenderer-v2.js
+++ b/src/diagrams/flowchart/flowRenderer-v2.js
@@ -1,6 +1,5 @@
 import graphlib from 'graphlib';
 import * as d3 from 'd3';
-import dagre from 'dagre';
 
 import flowDb from './flowDb';
 import flow from './parser/flow';

From d228769b1bf464da4c8dd8f7b2594da4e8e019c9 Mon Sep 17 00:00:00 2001
From: Aaron Dutton <adutton@gmail.com>
Date: Tue, 14 Apr 2020 15:15:10 -0700
Subject: [PATCH 07/12] Show source code in later examples

The first few examples on the page show source code but the later ones didn't
---
 docs/examples.md | 63 +++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 59 insertions(+), 4 deletions(-)

diff --git a/docs/examples.md b/docs/examples.md
index 02985474d..127173384 100644
--- a/docs/examples.md
+++ b/docs/examples.md
@@ -5,7 +5,7 @@ pie title NETFLIX
          "Time spent looking for movie" : 90
          "Time spent watching it" : 10
 ```
-``` mermaid
+```mermaid
 pie title NETFLIX
          "Time spent looking for movie" : 90
          "Time spent watching it" : 10
@@ -35,8 +35,6 @@ sequenceDiagram
     Bob-->Alice: Checking with John...
     Alice->John: Yes... John, how are you?
 ```
-
-
 ```mermaid
 sequenceDiagram
     Alice ->> Bob: Hello Bob, how are you?
@@ -49,9 +47,15 @@ sequenceDiagram
     Alice->John: Yes... John, how are you?
 ```
 
-
 ## Basic flowchart
 
+```
+graph LR
+    A[Square Rect] -- Link text --> B((Circle))
+    A --> C(Round Rect)
+    B --> D{Rhombus}
+    C --> D
+```
 ```mermaid
 graph LR
     A[Square Rect] -- Link text --> B((Circle))
@@ -63,6 +67,29 @@ graph LR
 
 ## Larger flowchart with some styling
 
+```
+graph TB
+    sq[Square shape] --> ci((Circle shape))
+
+    subgraph A
+        od>Odd shape]-- Two line<br/>edge comment --> ro
+        di{Diamond with <br/> line break} -.-> ro(Rounded<br>square<br>shape)
+        di==>ro2(Rounded square shape)
+    end
+
+    %% Notice that no text in shape are added here instead that is appended further down
+    e --> od3>Really long text with linebreak<br>in an Odd shape]
+
+    %% Comments after double percent signs
+    e((Inner / circle<br>and some odd <br>special characters)) --> f(,.?!+-*ز)
+
+    cyr[Cyrillic]-->cyr2((Circle shape Начало));
+
+     classDef green fill:#9f6,stroke:#333,stroke-width:2px;
+     classDef orange fill:#f96,stroke:#333,stroke-width:4px;
+     class sq,e green
+     class di orange
+```
 ```mermaid
 graph TB
     sq[Square shape] --> ci((Circle shape))
@@ -90,6 +117,21 @@ graph TB
 
 ## Loops, alt and opt
 
+```
+sequenceDiagram
+    loop Daily query
+        Alice->>Bob: Hello Bob, how are you?
+        alt is sick
+            Bob->>Alice: Not so good :(
+        else is well
+            Bob->>Alice: Feeling fresh like a daisy
+        end
+
+        opt Extra response
+            Bob->>Alice: Thanks for asking
+        end
+    end
+```
 ```mermaid
 sequenceDiagram
     loop Daily query
@@ -109,6 +151,19 @@ sequenceDiagram
 
 ## Message to self in loop
 
+```
+sequenceDiagram
+    participant Alice
+    participant Bob
+    Alice->>John: Hello John, how are you?
+    loop Healthcheck
+        John->>John: Fight against hypochondria
+    end
+    Note right of John: Rational thoughts<br/>prevail...
+    John-->>Alice: Great!
+    John->>Bob: How about you?
+    Bob-->>John: Jolly good!
+```
 ```mermaid
 sequenceDiagram
     participant Alice

From 12d26d5a3df44916c9d71ca3dffea85ddbd6e425 Mon Sep 17 00:00:00 2001
From: Tom Wright <contact@tomwright.me>
Date: Wed, 15 Apr 2020 19:29:17 +0100
Subject: [PATCH 08/12] Add HTTP Server implementation to related projects.

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 83fe09ec7..345c6622e 100644
--- a/README.md
+++ b/README.md
@@ -188,6 +188,7 @@ pie
 
 - [Command Line Interface](https://github.com/mermaid-js/mermaid.cli)
 - [Live Editor](https://github.com/mermaid-js/mermaid-live-editor)
+- [HTTP Server](https://github.com/TomWright/mermaid-server)
 
 # Contributors [![Help wanted](https://img.shields.io/github/labels/mermaid-js/mermaid/Help%20wanted!)](https://github.com/mermaid-js/mermaid/issues?q=is%3Aissue+is%3Aopen+label%3A%22Help+wanted%21%22) [![Contributors](https://img.shields.io/github/contributors/mermaid-js/mermaid)](https://github.com/mermaid-js/mermaid/graphs/contributors) [![Commits](https://img.shields.io/github/commit-activity/m/mermaid-js/mermaid)](https://github.com/mermaid-js/mermaid/graphs/contributors)
 

From 7c82e4b6c16615205f8bbbd0bb82a965aecd0a94 Mon Sep 17 00:00:00 2001
From: Tom Wright <contact@tomwright.me>
Date: Wed, 15 Apr 2020 21:00:47 +0100
Subject: [PATCH 09/12] Add mermaid-server to integrations.md

---
 docs/integrations.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/integrations.md b/docs/integrations.md
index d01f7c35c..33f424a98 100644
--- a/docs/integrations.md
+++ b/docs/integrations.md
@@ -137,3 +137,4 @@ The following is a list of different integrations and plugins where mermaid is b
   - [bisheng-plugin-mermaid](https://github.com/yct21/bisheng-plugin-mermaid)
 - [Reveal CK](https://github.com/jedcn/reveal-ck)
   - [reveal-ck-mermaid-plugin](https://github.com/tmtm/reveal-ck-mermaid-plugin)
+- [mermaid-server: Generate diagrams using a HTTP request](https://github.com/TomWright/mermaid-server)

From 4e4c80b7fa88c432b0970db13d10ba17024cbc28 Mon Sep 17 00:00:00 2001
From: Adrian Hall <ade@adrian-hall.name>
Date: Thu, 16 Apr 2020 12:19:04 +0100
Subject: [PATCH 10/12] Update docs to include ER diagram descriptions

---
 docs/README.md                    |  18 +++++++++++++++---
 docs/entityRelationshipDiagram.md |   4 ++--
 docs/img/er.png                   | Bin 0 -> 56576 bytes
 docs/img/simple-er.png            | Bin 0 -> 8080 bytes
 4 files changed, 17 insertions(+), 5 deletions(-)
 create mode 100644 docs/img/er.png
 create mode 100644 docs/img/simple-er.png

diff --git a/docs/README.md b/docs/README.md
index 4fb40e62b..f8e5046df 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -16,11 +16,11 @@ Check out the list of [Integrations and Usages of Mermaid](./integrations.md)
 
 **Mermaid was nominated and won the JS Open Source Awards (2019) in the category "The most exciting use of technology"!!! Thanks to all involved, people committing pull requests, people answering questions and special thanks to Tyler Long who is helping me maintain the project.**
 
-## New diagrams in 8.4
+## New diagrams in 8.5
 
-With version 8.4 class diagrams have got some new features, bug fixes and documentation. Another new feature in 8.4 is the new diagram type, state diagrams.
+With version 8.5 there are some bug fixes and enhancements, plus a new diagram type,  entity relationship diagrams.
 
-![Image show the two new diagram types](./img/new-diagrams.png)
+![Image showing the new ER diagram type](./img/er.png)
 
 ## Special note regarding version 8.2
 
@@ -137,6 +137,18 @@ merge newbranch
 
 ![Git graph](./img/git.png)
 
+### Entity Relationship Diagram - :exclamation: experimental
+
+```
+erDiagram
+    CUSTOMER ||--o{ ORDER : places
+    ORDER ||--|{ LINE-ITEM : contains
+    CUSTOMER }|..|{ DELIVERY-ADDRESS : uses
+
+```
+
+![ER diagram](./img/simple-er.png)
+
 ## Installation
 
 ### CDN
diff --git a/docs/entityRelationshipDiagram.md b/docs/entityRelationshipDiagram.md
index 8a3924d3b..042adae6d 100644
--- a/docs/entityRelationshipDiagram.md
+++ b/docs/entityRelationshipDiagram.md
@@ -9,13 +9,13 @@ Mermaid can render ER diagrams
 erDiagram
     CUSTOMER ||--o{ ORDER : places
     ORDER ||--|{ LINE-ITEM : contains
-    CUSTOMER }|..|{ : DELIVERY-ADDRESS : uses 
+    CUSTOMER }|..|{ DELIVERY-ADDRESS : uses 
 ```
 ```mermaid
 erDiagram
     CUSTOMER ||--o{ ORDER : places
     ORDER ||--|{ LINE-ITEM : contains
-    CUSTOMER }|..|{ : DELIVERY-ADDRESS : uses 
+    CUSTOMER }|..|{ DELIVERY-ADDRESS : uses 
 ```
 
 Entity names are often capitalised, although there is no accepted standard on this, and it is not required in Mermaid.
diff --git a/docs/img/er.png b/docs/img/er.png
new file mode 100644
index 0000000000000000000000000000000000000000..21c44c257a3e0ee3e782dd5b6696602f6d9f5172
GIT binary patch
literal 56576
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
G_~T!k%VIVF

literal 0
HcmV?d00001

diff --git a/docs/img/simple-er.png b/docs/img/simple-er.png
new file mode 100644
index 0000000000000000000000000000000000000000..5e139380bea8892c01d1a680d6d78031e7512f21
GIT binary patch
literal 8080
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
A!T<mO

literal 0
HcmV?d00001


From c3f2e8dde16fa9826cd2993ee88835a9965f971f Mon Sep 17 00:00:00 2001
From: Knut Sveidqvist <knut.sveidqvist@ipiccolo.com>
Date: Thu, 16 Apr 2020 19:44:11 +0200
Subject: [PATCH 11/12] #1295 Render fix for flowchart, correct marker handling
 and some cleanup

---
 cypress/platform/current.html             |  15 +-
 src/dagre-wrapper/clusters.js             |  10 +-
 src/dagre-wrapper/edges.js                |  23 +-
 src/dagre-wrapper/index.js                |  64 +++--
 src/dagre-wrapper/markers.js              |  24 +-
 src/dagre-wrapper/mermaid-graphlib.js     | 283 +++-------------------
 src/dagre-wrapper/nodes.js                |  23 +-
 src/diagrams/flowchart/flowRenderer-v2.js |   2 +
 8 files changed, 126 insertions(+), 318 deletions(-)

diff --git a/cypress/platform/current.html b/cypress/platform/current.html
index dd32f0be0..01ce04d88 100644
--- a/cypress/platform/current.html
+++ b/cypress/platform/current.html
@@ -7,7 +7,7 @@
     <link href="https://fonts.googleapis.com/css?family=Noto+Sans+SC&display=swap" rel="stylesheet">
     <style>
       body {
-        background: white;
+        background: rgb(221, 208, 208);
         font-family: 'Arial';
         }
       h1 { color: white;}
@@ -98,9 +98,20 @@ flowchart TD
         d
       end
     end
-    A -- oAo --> B
+    A -- oAo --o B
     A --> C
     </div>
+      <div class="mermaid" style="width: 100%; height: 100%;">
+flowchart TD
+    subgraph A
+      a
+    end
+    subgraph B
+      b
+    end
+    c-->A
+    c-->B
+  </div>
       <div class="mermaid2" style="width: 100%; height: 100%;">
 stateDiagram-v2
     [*] --> First
diff --git a/src/dagre-wrapper/clusters.js b/src/dagre-wrapper/clusters.js
index ff65496a1..ac1163be8 100644
--- a/src/dagre-wrapper/clusters.js
+++ b/src/dagre-wrapper/clusters.js
@@ -3,7 +3,7 @@ import { logger as log } from '../logger'; // eslint-disable-line
 import createLabel from './createLabel';
 
 const rect = (parent, node) => {
-  log.info('Creating subgraph rect for ', node.id, node);
+  log.trace('Creating subgraph rect for ', node.id, node);
 
   // Add outer g element
   const shapeSvg = parent
@@ -25,7 +25,7 @@ const rect = (parent, node) => {
   const padding = 0 * node.padding;
   const halfPadding = padding / 2;
 
-  log.info('Data ', node, JSON.stringify(node));
+  log.trace('Data ', node, JSON.stringify(node));
   // center the rect around its coordinate
   rect
     .attr('rx', node.rx)
@@ -35,9 +35,7 @@ const rect = (parent, node) => {
     .attr('width', node.width + padding)
     .attr('height', node.height + padding);
 
-  // log.info('bbox', bbox.width, node.x, node.width);
   // Center the label
-  // label.attr('transform', 'translate(' + adj + ', ' + (node.y - node.height / 2) + ')');
   label.attr(
     'transform',
     'translate(' +
@@ -130,9 +128,7 @@ const roundedWithTitle = (parent, node) => {
     .attr('width', node.width + padding)
     .attr('height', node.height + padding - bbox.height - 3);
 
-  // log.info('bbox', bbox.width, node.x, node.width);
   // Center the label
-  // label.attr('transform', 'translate(' + adj + ', ' + (node.y - node.height / 2) + ')');
   label.attr(
     'transform',
     'translate(' +
@@ -158,7 +154,7 @@ const shapes = { rect, roundedWithTitle, noteGroup };
 let clusterElems = {};
 
 export const insertCluster = (elem, node) => {
-  log.info('Inserting cluster');
+  log.trace('Inserting cluster');
   const shape = node.shape || 'rect';
   clusterElems[node.id] = shapes[shape](elem, node);
 };
diff --git a/src/dagre-wrapper/edges.js b/src/dagre-wrapper/edges.js
index 6b141a863..0b5e474e2 100644
--- a/src/dagre-wrapper/edges.js
+++ b/src/dagre-wrapper/edges.js
@@ -64,7 +64,7 @@ const outsideNode = (node, point) => {
 };
 
 const intersection = (node, outsidePoint, insidePoint) => {
-  logger.info('intersection o:', outsidePoint, ' i:', insidePoint, node);
+  logger.trace('intersection o:', outsidePoint, ' i:', insidePoint, node);
   const x = node.x;
   const y = node.y;
 
@@ -98,11 +98,10 @@ const intersection = (node, outsidePoint, insidePoint) => {
 };
 
 export const insertEdge = function(elem, edge, clusterDb, diagramType) {
-  logger.info('\n\n\n\n');
   let points = edge.points;
   if (edge.toCluster) {
-    logger.info('edge', edge);
-    logger.info('to cluster', clusterDb[edge.toCluster]);
+    logger.trace('edge', edge);
+    logger.trace('to cluster', clusterDb[edge.toCluster]);
     points = [];
     let lastPointOutside;
     let isInside = false;
@@ -110,11 +109,11 @@ export const insertEdge = function(elem, edge, clusterDb, diagramType) {
       const node = clusterDb[edge.toCluster].node;
 
       if (!outsideNode(node, point) && !isInside) {
-        logger.info('inside', edge.toCluster, point, lastPointOutside);
+        logger.trace('inside', edge.toCluster, point, lastPointOutside);
 
         // First point inside the rect
         const insterection = intersection(node, lastPointOutside, point);
-        logger.info('intersect', insterection);
+        logger.trace('intersect', insterection);
         points.push(insterection);
         isInside = true;
       } else {
@@ -125,8 +124,8 @@ export const insertEdge = function(elem, edge, clusterDb, diagramType) {
   }
 
   if (edge.fromCluster) {
-    logger.info('edge', edge);
-    logger.info('from cluster', clusterDb[edge.toCluster]);
+    logger.trace('edge', edge);
+    logger.trace('from cluster', clusterDb[edge.toCluster]);
     const updatedPoints = [];
     let lastPointOutside;
     let isInside = false;
@@ -135,17 +134,17 @@ export const insertEdge = function(elem, edge, clusterDb, diagramType) {
       const node = clusterDb[edge.fromCluster].node;
 
       if (!outsideNode(node, point) && !isInside) {
-        logger.info('inside', edge.toCluster, point);
+        logger.trace('inside', edge.toCluster, point);
 
         // First point inside the rect
         const insterection = intersection(node, lastPointOutside, point);
-        // logger.info('intersect', intersection(node, lastPointOutside, point));
+        // logger.trace('intersect', intersection(node, lastPointOutside, point));
         updatedPoints.unshift(insterection);
         // points.push(insterection);
         isInside = true;
       } else {
         // at the outside
-        logger.info('Outside point', point);
+        logger.trace('Outside point', point);
         if (!isInside) updatedPoints.unshift(point);
       }
       lastPointOutside = point;
@@ -195,7 +194,7 @@ export const insertEdge = function(elem, edge, clusterDb, diagramType) {
     url = url.replace(/\(/g, '\\(');
     url = url.replace(/\)/g, '\\)');
   }
-  // logger.info('arrowType', edge.arrowType);
+  logger.info('arrowType', edge.arrowType);
   switch (edge.arrowType) {
     case 'arrow_cross':
       svgPath.attr('marker-end', 'url(' + url + '#' + diagramType + '-crossEnd' + ')');
diff --git a/src/dagre-wrapper/index.js b/src/dagre-wrapper/index.js
index c1b2b7933..75ab6be1a 100644
--- a/src/dagre-wrapper/index.js
+++ b/src/dagre-wrapper/index.js
@@ -9,30 +9,20 @@ import {
   findNonClusterChild
 } from './mermaid-graphlib';
 import { insertNode, positionNode, clear as clearNodes, setNodeElem } from './nodes';
-import { insertCluster, clear as clearClusters } from './clusters';
+import { insertCluster, clear as clearClusters, positionCluster } from './clusters';
 import { insertEdgeLabel, positionEdgeLabel, insertEdge, clear as clearEdges } from './edges';
 import { logger as log } from '../logger';
 
-// let clusterDb = {};
-
-const getAnchorId = id => {
-  // Only insert an achor once
-  if (clusterDb[id]) {
-    return clusterDb[id].id;
-  }
-  return id;
-};
-
-const recursiveRender = (_elem, graph, diagramtype) => {
-  log.info('Graph in recursive render:', graphlib.json.write(graph));
+const recursiveRender = (_elem, graph, diagramtype, parentCluster) => {
+  log.trace('Graph in recursive render:', graphlib.json.write(graph), parentCluster);
   const elem = _elem.insert('g').attr('class', 'root'); // eslint-disable-line
   if (!graph.nodes()) {
-    log.info('No nodes found for', graph);
+    log.trace('No nodes found for', graph);
   } else {
-    log.info('Recursive render', graph.nodes());
+    log.trace('Recursive render', graph.nodes());
   }
   if (graph.edges().length > 0) {
-    log.info('Recursive edges', graph.edge(graph.edges()[0]));
+    log.trace('Recursive edges', graph.edge(graph.edges()[0]));
   }
   const clusters = elem.insert('g').attr('class', 'clusters'); // eslint-disable-line
   const edgePaths = elem.insert('g').attr('class', 'edgePaths');
@@ -43,11 +33,18 @@ const recursiveRender = (_elem, graph, diagramtype) => {
   // to the abstract node and is later used by dagre for the layout
   graph.nodes().forEach(function(v) {
     const node = graph.node(v);
-    log.info('(Insert) Node ' + v + ': ' + JSON.stringify(graph.node(v)));
+    if (typeof parentCluster !== 'undefined') {
+      const data = JSON.parse(JSON.stringify(parentCluster.clusterData));
+      // data.clusterPositioning = true;
+      log.trace('Setting data for cluster', data);
+      graph.setNode(parentCluster.id, data);
+      graph.setParent(v, parentCluster.id, data);
+    }
+    log.trace('(Insert) Node ' + v + ': ' + JSON.stringify(graph.node(v)));
     if (node.clusterNode) {
       // const children = graph.children(v);
-      log.info('Cluster identified', v, node, graph.node(v));
-      const newEl = recursiveRender(clusters, node.graph, diagramtype);
+      log.trace('Cluster identified', v, node, graph.node(v));
+      const newEl = recursiveRender(nodes, node.graph, diagramtype, graph.node(v));
       updateNodeBounds(node, newEl);
       setNodeElem(newEl, node);
 
@@ -56,12 +53,12 @@ const recursiveRender = (_elem, graph, diagramtype) => {
       if (graph.children(v).length > 0) {
         // This is a cluster but not to be rendered recusively
         // Render as before
-        log.info('Cluster - the non recursive path', v, node.id, node, graph);
-        log.info(findNonClusterChild(node.id, graph));
+        log.trace('Cluster - the non recursive path', v, node.id, node, graph);
+        log.trace(findNonClusterChild(node.id, graph));
         clusterDb[node.id] = { id: findNonClusterChild(node.id, graph), node };
         // insertCluster(clusters, graph.node(v));
       } else {
-        log.info('Node - the non recursive path', v, node.id, node);
+        log.trace('Node - the non recursive path', v, node.id, node);
         insertNode(nodes, graph.node(v));
       }
     }
@@ -74,22 +71,22 @@ const recursiveRender = (_elem, graph, diagramtype) => {
   graph.edges().forEach(function(e) {
     const edge = graph.edge(e.v, e.w, e.name);
     log.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
-    log.info('Edge ' + e.v + ' -> ' + e.w + ': ', e, ' ', JSON.stringify(graph.edge(e)));
+    log.trace('Edge ' + e.v + ' -> ' + e.w + ': ', e, ' ', JSON.stringify(graph.edge(e)));
 
     let v = e.v;
     let w = e.w;
     // Check if link is either from or to a cluster
-    log.info('Fix', clusterDb, 'ids:', e.v, e.w, 'Translateing: ', clusterDb[e.v], clusterDb[e.w]);
+    log.trace('Fix', clusterDb, 'ids:', e.v, e.w, 'Translateing: ', clusterDb[e.v], clusterDb[e.w]);
     // Todo handle case with links
 
     // if (clusterDb[e.v] || clusterDb[e.w]) {
-    //   log.info('Fixing and trixing - removing', e.v, e.w, e.name);
+    //   log.trace('Fixing and trixing - removing', e.v, e.w, e.name);
     //   v = getAnchorId(e.v, graph, nodes);
     //   w = getAnchorId(e.w, graph, nodes);
     //   graph.removeEdge(e.v, e.w, e.name);
     //   if (v !== e.v) edge.fromCluster = e.v;
     //   if (w !== e.w) edge.toCluster = e.w;
-    //   log.info('Fixing Replacing with', v, w, e.name);
+    //   log.trace('Fixing Replacing with', v, w, e.name);
     //   graph.setEdge(v, w, edge, e.name);
     // }
     insertEdgeLabel(edgeLabels, edge);
@@ -98,17 +95,17 @@ const recursiveRender = (_elem, graph, diagramtype) => {
   graph.edges().forEach(function(e) {
     log.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
   });
-  log.info('#############################################');
-  log.info('###                Layout                 ###');
-  log.info('#############################################');
-  log.info(graph);
+  log.trace('#############################################');
+  log.trace('###                Layout                 ###');
+  log.trace('#############################################');
+  log.trace(graph);
   dagre.layout(graph);
   log.warn('Graph after layout:', graphlib.json.write(graph));
   // Move the nodes to the correct place
   graph.nodes().forEach(function(v) {
     const node = graph.node(v);
-    // log.info('Position ' + v + ': ' + JSON.stringify(graph.node(v)));
-    log.info(
+    // log.trace('Position ' + v + ': ' + JSON.stringify(graph.node(v)));
+    log.trace(
       'Position ' + v + ': (' + node.x,
       ',' + node.y,
       ') width: ',
@@ -118,6 +115,7 @@ const recursiveRender = (_elem, graph, diagramtype) => {
     );
     if (node && node.clusterNode) {
       // clusterDb[node.id].node = node;
+
       positionNode(node);
     } else {
       // Non cluster node
@@ -135,7 +133,7 @@ const recursiveRender = (_elem, graph, diagramtype) => {
   // Move the edge labels to the correct place after layout
   graph.edges().forEach(function(e) {
     const edge = graph.edge(e);
-    log.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(edge), edge);
+    log.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(edge), edge);
 
     insertEdge(edgePaths, edge, clusterDb, diagramtype);
     positionEdgeLabel(edge);
diff --git a/src/dagre-wrapper/markers.js b/src/dagre-wrapper/markers.js
index 45884e0e8..70c653fdb 100644
--- a/src/dagre-wrapper/markers.js
+++ b/src/dagre-wrapper/markers.js
@@ -16,7 +16,7 @@ const extension = (elem, type, id) => {
   elem
     .append('defs')
     .append('marker')
-    .attr('id', 'extensionStart')
+    .attr('id', type + '-extensionStart')
     .attr('class', 'extension ' + type)
     .attr('refX', 0)
     .attr('refY', 7)
@@ -29,7 +29,7 @@ const extension = (elem, type, id) => {
   elem
     .append('defs')
     .append('marker')
-    .attr('id', 'extensionEnd ' + type)
+    .attr('id', type + '-extensionEnd ' + type)
     .attr('class', 'extension ' + type)
     .attr('refX', 19)
     .attr('refY', 7)
@@ -44,7 +44,7 @@ const composition = (elem, type) => {
   elem
     .append('defs')
     .append('marker')
-    .attr('id', 'compositionStart')
+    .attr('id', type + '-compositionStart')
     .attr('class', 'extension ' + type)
     .attr('refX', 0)
     .attr('refY', 7)
@@ -57,7 +57,7 @@ const composition = (elem, type) => {
   elem
     .append('defs')
     .append('marker')
-    .attr('id', 'compositionEnd')
+    .attr('id', type + '-compositionEnd')
     .attr('class', 'extension ' + type)
     .attr('refX', 19)
     .attr('refY', 7)
@@ -71,7 +71,7 @@ const aggregation = (elem, type) => {
   elem
     .append('defs')
     .append('marker')
-    .attr('id', 'aggregationStart')
+    .attr('id', type + '-aggregationStart')
     .attr('class', 'extension ' + type)
     .attr('refX', 0)
     .attr('refY', 7)
@@ -84,7 +84,7 @@ const aggregation = (elem, type) => {
   elem
     .append('defs')
     .append('marker')
-    .attr('id', 'aggregationEnd')
+    .attr('id', type + '-aggregationEnd')
     .attr('class', type)
     .attr('refX', 19)
     .attr('refY', 7)
@@ -98,7 +98,7 @@ const dependency = (elem, type) => {
   elem
     .append('defs')
     .append('marker')
-    .attr('id', 'dependencyStart')
+    .attr('id', type + '-dependencyStart')
     .attr('class', 'extension ' + type)
     .attr('refX', 0)
     .attr('refY', 7)
@@ -111,7 +111,7 @@ const dependency = (elem, type) => {
   elem
     .append('defs')
     .append('marker')
-    .attr('id', 'dependencyEnd')
+    .attr('id', type + '-dependencyEnd')
     .attr('class', type)
     .attr('refX', 19)
     .attr('refY', 7)
@@ -158,7 +158,7 @@ const point = (elem, type) => {
 const circle = (elem, type) => {
   elem
     .append('marker')
-    .attr('id', 'circleEnd')
+    .attr('id', type + '-circleEnd')
     .attr('class', type)
     .attr('viewBox', '0 0 10 10')
     .attr('refX', 11)
@@ -177,7 +177,7 @@ const circle = (elem, type) => {
 
   elem
     .append('marker')
-    .attr('id', 'circleStart')
+    .attr('id', type + '-circleStart')
     .attr('class', type)
     .attr('viewBox', '0 0 10 10')
     .attr('refX', -1)
@@ -197,7 +197,7 @@ const circle = (elem, type) => {
 const cross = (elem, type) => {
   elem
     .append('marker')
-    .attr('id', 'crossEnd')
+    .attr('id', type + '-crossEnd')
     .attr('class', type)
     .attr('viewBox', '0 0 11 11')
     .attr('refX', 12)
@@ -215,7 +215,7 @@ const cross = (elem, type) => {
 
   elem
     .append('marker')
-    .attr('id', 'crossStart')
+    .attr('id', type + '-crossStart')
     .attr('class', type)
     .attr('viewBox', '0 0 11 11')
     .attr('refX', -1)
diff --git a/src/dagre-wrapper/mermaid-graphlib.js b/src/dagre-wrapper/mermaid-graphlib.js
index 30f69dbd9..c7ad345a3 100644
--- a/src/dagre-wrapper/mermaid-graphlib.js
+++ b/src/dagre-wrapper/mermaid-graphlib.js
@@ -19,7 +19,14 @@ export const clear = () => {
 const isDecendant = (id, ancenstorId) => {
   // if (id === ancenstorId) return true;
 
-  log.info('In isDecendant', ancenstorId, ' ', id, ' = ', decendants[ancenstorId].indexOf(id) >= 0);
+  log.debug(
+    'In isDecendant',
+    ancenstorId,
+    ' ',
+    id,
+    ' = ',
+    decendants[ancenstorId].indexOf(id) >= 0
+  );
   if (decendants[ancenstorId].indexOf(id) >= 0) return true;
 
   return false;
@@ -30,7 +37,7 @@ const edgeInCluster = (edge, clusterId) => {
   if (!(edge.v === clusterId || edge.w === clusterId)) return false;
 
   if (!decendants[clusterId]) {
-    log.info('Tilt, ', clustedId, ',not in decendants');
+    log.debug('Tilt, ', clustedId, ',not in decendants');
     return false;
   }
 
@@ -42,50 +49,6 @@ const edgeInCluster = (edge, clusterId) => {
   return false;
 };
 
-const copyOld = (clusterId, graph, newGraph, rootId) => {
-  log.info('Copying to', rootId, ' from ', clusterId, graph.node(clusterId), rootId);
-  const nodes = graph.children(clusterId);
-  log.info('Copying (nodes)', nodes);
-  if (nodes) {
-    nodes.forEach(node => {
-      if (graph.children(node).length > 0) {
-        copy(node, graph, newGraph, rootId);
-      } else {
-        // if (clusterId === rootId) {
-        const data = graph.node(node);
-        log.info('cp ', node, ' to ', rootId, ' with parent ', clusterId); //,node, data, ' parent is ', clusterId);
-        newGraph.setNode(node, data);
-        newGraph.setParent(node, clusterId);
-        const edges = graph.edges(node);
-        log.trace('Copying Edges', edges);
-        edges.forEach(edge => {
-          log.trace('Edge', edge);
-          const data = graph.edge(edge.v, edge.w, edge.name);
-          log.trace('Edge data', data, rootId);
-          try {
-            // Do not copy edges in and out of the root cluster, they belong to the parent graph
-            if (edgeInCluster(edge, rootId)) {
-              log.trace('Copying as ', edge.v, edge.w, data, edge.name);
-              newGraph.setEdge(edge.v, edge.w, data, edge.name);
-              log.trace('newGraph edges ', newGraph.edges(), newGraph.edge(newGraph.edges()[0]));
-            } else {
-              log.trace('Skipping copy of edge as ', rootId, edge.v, edge.w, clusterId);
-            }
-          } catch (e) {
-            log.error(e);
-          }
-        });
-        // } else {
-        //   log.info('Skipping leaf as root ', rootId, ' !== ', clusterId, ' leaf id = ', node);
-        // }
-      }
-      // log.info('Removing node', node, graphlib.json.write(graph));
-      log.info('Removing node', node);
-      graph.removeNode(node);
-    });
-  }
-  // newGraph.setNode(clusterId, graph.node(clusterId));
-};
 const copy = (clusterId, graph, newGraph, rootId) => {
   log.trace(
     'Copying children of ',
@@ -103,7 +66,7 @@ const copy = (clusterId, graph, newGraph, rootId) => {
     nodes.push(clusterId);
   }
 
-  log.info('Copying (nodes)', nodes);
+  log.debug('Copying (nodes)', nodes);
 
   nodes.forEach(node => {
     if (graph.children(node).length > 0) {
@@ -113,11 +76,11 @@ const copy = (clusterId, graph, newGraph, rootId) => {
       log.trace('cp ', node, ' to ', rootId, ' with parent ', clusterId); //,node, data, ' parent is ', clusterId);
       newGraph.setNode(node, data);
       if (clusterId !== rootId && node !== clusterId) {
-        log.info('Setting parent', node, clusterId);
+        log.debug('Setting parent', node, clusterId);
         newGraph.setParent(node, clusterId);
       }
       const edges = graph.edges(node);
-      log.info('Copying Edges', edges);
+      log.debug('Copying Edges', edges);
       edges.forEach(edge => {
         log.trace('Edge', edge);
         const data = graph.edge(edge.v, edge.w, edge.name);
@@ -136,12 +99,12 @@ const copy = (clusterId, graph, newGraph, rootId) => {
         }
       });
     }
-    log.info('Removing node', node);
+    log.debug('Removing node', node);
     graph.removeNode(node);
   });
 };
 export const extractDecendants = (id, graph) => {
-  // log.info('Extracting ', id);
+  // log.debug('Extracting ', id);
   const children = graph.children(id);
   let res = [].concat(children);
 
@@ -153,66 +116,6 @@ export const extractDecendants = (id, graph) => {
   return res;
 };
 
-export const extractGraphFromCluster = (clusterId, graph) => {
-  log.info('Extracting graph ', clusterId);
-  const clusterGraph = new graphlib.Graph({
-    multigraph: true,
-    compound: true
-  })
-    .setGraph({
-      rankdir: 'TB',
-      // Todo: set proper spacing
-      nodesep: 50,
-      ranksep: 50,
-      marginx: 8,
-      marginy: 8
-    })
-    .setDefaultEdgeLabel(function() {
-      return {};
-    });
-
-  // const conf = getConfig().flowchart;
-  // const nodeSpacing = conf.nodeSpacing || 50;
-  // const rankSpacing = conf.rankSpacing || 50;
-
-  // // Create the input mermaid.graph
-  // const g = new graphlib.Graph({
-  //   multigraph: true,
-  //   compound: true
-  // })
-  //   .setGraph({
-  //     rankdir: 'TB',
-  //     nodesep: nodeSpacing,
-  //     ranksep: rankSpacing,
-  //     marginx: 8,
-  //     marginy: 8
-  //   })
-  //   .setDefaultEdgeLabel(function() {
-  //     return {};
-  //   });
-
-  log.trace('Extracting before copy', graphlib.json.write(graph));
-  log.trace('Extracting before copy', graphlib.json.write(graph));
-  copy(clusterId, graph, clusterGraph, clusterId);
-  log.trace('Extracting after copy', graphlib.json.write(graph));
-  log.trace('Extracting after copy', clusterGraph.nodes());
-  graphs[clusterId] = clusterGraph;
-
-  // Remove references to extracted cluster
-  // graph.edges().forEach(edge => {
-  //   if (isDecendant(edge.v, clusterId) || isDecendant(edge.w, clusterId)) {
-  //     graph.removeEdge(edge);
-  //   }
-  // });
-  // graph.nodes().forEach(node => {
-  //   if (isDecendant(node, clusterId)) {
-  //     log.info('Removing ', node, ' from ', clusterId);
-  //     graph.removeNode(node);
-  //   }
-  // });
-  return clusterGraph;
-};
-
 /**
  * Validates the graph, checking that all parent child relation points to existing nodes and that
  * edges between nodes also ia correct. When not correct the function logs the discrepancies.
@@ -274,10 +177,10 @@ const getAnchorId = id => {
 
 export const adjustClustersAndEdges = (graph, depth) => {
   if (!graph || depth > 10) {
-    log.info('Opting out, no graph ');
+    log.debug('Opting out, no graph ');
     return;
   } else {
-    log.info('Opting in, graph ');
+    log.debug('Opting in, graph ');
   }
   // Go through the nodes and for each cluster found, save a replacment node, this can be used when
   // faking a link to a cluster
@@ -291,7 +194,7 @@ export const adjustClustersAndEdges = (graph, depth) => {
         findNonClusterChild(id, graph)
       );
       decendants[id] = extractDecendants(id, graph);
-      clusterDb[id] = { id: findNonClusterChild(id, graph) };
+      clusterDb[id] = { id: findNonClusterChild(id, graph), clusterData: graph.node(id) };
     }
   });
 
@@ -300,9 +203,9 @@ export const adjustClustersAndEdges = (graph, depth) => {
     const children = graph.children(id);
     const edges = graph.edges();
     if (children.length > 0) {
-      log.info('Cluster identified', id, decendants);
+      log.debug('Cluster identified', id, decendants);
       edges.forEach(edge => {
-        // log.info('Edge, decendants: ', edge, decendants[id]);
+        // log.debug('Edge, decendants: ', edge, decendants[id]);
 
         // Check if any edge leaves the cluster (not the actual cluster, thats a link from the box)
         if (edge.v !== id && edge.w !== id) {
@@ -314,8 +217,8 @@ export const adjustClustersAndEdges = (graph, depth) => {
 
           // d1 xor d2 - if either d1 is true and d2 is false or the other way around
           if (d1 ^ d2) {
-            log.info('Edge: ', edge, ' leaves cluster ', id);
-            log.info('Decendants of ', id, ': ', decendants[id]);
+            log.debug('Edge: ', edge, ' leaves cluster ', id);
+            log.debug('Decendants of ', id, ': ', decendants[id]);
             clusterDb[id].externalConnections = true;
           }
         }
@@ -347,7 +250,7 @@ export const adjustClustersAndEdges = (graph, depth) => {
       graph.setEdge(v, w, edge, e.name);
     }
   });
-  log.info('Adjusted Graph', graphlib.json.write(graph));
+  log.debug('Adjusted Graph', graphlib.json.write(graph));
 
   log.trace(clusterDb);
 
@@ -359,91 +262,8 @@ export const adjustClustersAndEdges = (graph, depth) => {
   // });
 };
 
-export const transformClustersToNodes = (graph, depth) => {
-  log.info('transformClustersToNodes - ', depth);
-  if (depth > 10) {
-    log.error('Bailing out');
-    return;
-  }
-  // For clusters without incoming and/or outgoing edges, create a new cluster-node
-  // containing the nodes and edges in the custer in a new graph
-  // for (let i = 0;)
-  const nodes = graph.nodes();
-  let hasChildren = false;
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i];
-    const children = graph.children(node);
-    hasChildren = hasChildren || children.length > 0;
-  }
-
-  if (!hasChildren) {
-    log.info('Done, no node has children', graph.nodes());
-    return;
-  }
-  // const clusters = Object.keys(clusterDb);
-  // clusters.forEach(clusterId => {
-  log.info('Nodes = ', nodes);
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i];
-
-    log.info(
-      'Handling node',
-      node,
-      clusterDb,
-      clusterDb[node] && !clusterDb[node].externalConnections,
-      !graph.parent(node),
-      graph.node(node)
-    );
-    // Note that the node might have been removed after the Object.keys call so better check
-    // that it still is in the game
-    if (clusterDb[node]) {
-      if (
-        !clusterDb[node].externalConnections &&
-        !graph.parent(node) &&
-        graph.children(node) &&
-        graph.children(node).length > 0
-      ) {
-        log.info('Cluster without external connections', node);
-        // const parentGraph = parent && graphs[parent] ? graphs[parent] : graph;
-        // New graph with the nodes in the cluster
-        log.info('before Extracting ', node, ' parent is ', graph.parent(node));
-        const clusterGraph = extractGraphFromCluster(node, graph);
-
-        if (clusterGraph) {
-          log.trace('Cluster graph', clusterGraph.nodes());
-          log.trace('Graph', graph.edges());
-
-          log.info('Creating node in original', node, clusterGraph);
-
-          // Create a new node in the original graph, this new node is not a cluster
-          // but a regular node with the cluster content as a new attached graph
-          graph.setNode(node, {
-            clusterNode: true,
-            id: node,
-            clusterData: clusterDb[node],
-            labelText: clusterDb[node].labelText,
-            graph: clusterGraph
-          });
-
-          // if any node in the clusterGraph still has children
-          transformClustersToNodes(clusterGraph, depth + 1);
-        }
-
-        // The original edges in and out of the cluster is applied
-        // edges.forEach(edge => {
-        //   log.info('Setting edge', edge);
-        //   const data = graph.edge(edge);
-        //   graph.setEdge(edge.v, edge.w, data);
-        // });
-      }
-    } else {
-      log.info('Not a cluster ', node);
-    }
-  }
-};
-
 export const extractor = (graph, depth) => {
-  log.info('extractor - ', depth, graphlib.json.write(graph), graph.children('D'));
+  log.debug('extractor - ', depth, graphlib.json.write(graph), graph.children('D'));
   if (depth > 10) {
     log.error('Bailing out');
     return;
@@ -460,16 +280,16 @@ export const extractor = (graph, depth) => {
   }
 
   if (!hasChildren) {
-    log.info('Done, no node has children', graph.nodes());
+    log.debug('Done, no node has children', graph.nodes());
     return;
   }
   // const clusters = Object.keys(clusterDb);
   // clusters.forEach(clusterId => {
-  log.info('Nodes = ', nodes, depth);
+  log.debug('Nodes = ', nodes, depth);
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
 
-    log.info(
+    log.debug(
       'Extracting node',
       node,
       clusterDb,
@@ -484,7 +304,7 @@ export const extractor = (graph, depth) => {
     // that it still is in the game
     if (!clusterDb[node]) {
       // Skip if the node is not a cluster
-      log.info('Not a cluster', node, depth);
+      log.debug('Not a cluster', node, depth);
       // break;
     } else if (
       !clusterDb[node].externalConnections &&
@@ -492,7 +312,7 @@ export const extractor = (graph, depth) => {
       graph.children(node) &&
       graph.children(node).length > 0
     ) {
-      log.info(
+      log.debug(
         'Cluster without external connections, without a parent and with children',
         node,
         depth
@@ -518,47 +338,14 @@ export const extractor = (graph, depth) => {
       graph.setNode(node, {
         clusterNode: true,
         id: node,
-        clusterData: clusterDb[node],
+        clusterData: clusterDb[node].clusterData,
         labelText: clusterDb[node].labelText,
         graph: clusterGraph
       });
-      log.info('New graph after copy', graphlib.json.write(clusterGraph));
-      log.info('Old graph after copy', graphlib.json.write(graph));
-
-      /*
-      // New graph with the nodes in the cluster
-      log.info('before Extracting ', node, ' parent is ', graph.parent(node));
-      const clusterGraph = extractGraphFromCluster(node, graph);
-
-      if (clusterGraph) {
-        log.trace('Cluster graph', clusterGraph.nodes());
-        log.trace('Graph', graph.edges());
-
-        log.info('Creating node in original', node, clusterGraph);
-
-        // Create a new node in the original graph, this new node is not a cluster
-        // but a regular node with the cluster content as a new attached graph
-        graph.setNode(node, {
-          clusterNode: true,
-          id: node,
-          clusterData: clusterDb[node],
-          labelText: clusterDb[node].labelText,
-          graph: clusterGraph
-        });
-
-        // if any node in the clusterGraph still has children
-        transformClustersToNodes(clusterGraph, depth + 1);
-      }
-
-      // The original edges in and out of the cluster is applied
-      // edges.forEach(edge => {
-      //   log.info('Setting edge', edge);
-      //   const data = graph.edge(edge);
-      //   graph.setEdge(edge.v, edge.w, data);
-      // });
-      */
+      log.debug('New graph after copy', graphlib.json.write(clusterGraph));
+      log.debug('Old graph after copy', graphlib.json.write(graph));
     } else {
-      log.info(
+      log.debug(
         'Cluster ** ',
         node,
         ' **not meeting the criteria !externalConnections:',
@@ -570,16 +357,16 @@ export const extractor = (graph, depth) => {
         graph.children('D'),
         depth
       );
-      log.info(clusterDb);
+      log.debug(clusterDb);
     }
   }
 
   nodes = graph.nodes();
-  log.info('New list of nodes', nodes);
+  log.debug('New list of nodes', nodes);
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
     const data = graph.node(node);
-    log.info(' Now next leveö', node, data);
+    log.debug(' Now next leveö', node, data);
     if (data.clusterNode) {
       extractor(data.graph, depth + 1);
     }
diff --git a/src/dagre-wrapper/nodes.js b/src/dagre-wrapper/nodes.js
index ec45764e7..08a0e36db 100644
--- a/src/dagre-wrapper/nodes.js
+++ b/src/dagre-wrapper/nodes.js
@@ -248,7 +248,7 @@ const cylinder = (parent, node) => {
 const rect = (parent, node) => {
   const { shapeSvg, bbox, halfPadding } = labelHelper(parent, node, 'node ' + node.classes);
 
-  logger.info('Classes = ', node.classes);
+  logger.trace('Classes = ', node.classes);
   // add the rect
   const rect = shapeSvg.insert('rect', ':first-child');
 
@@ -396,7 +396,22 @@ export const clear = () => {
 
 export const positionNode = node => {
   const el = nodeElems[node.id];
-  logger.debug('Transforming node', node);
-  el.attr('transform', 'translate(' + node.x + ', ' + node.y + ')');
-  // el.attr('transform', 'translate(' + node.x / 2 + ', ' + 0 + ')');
+  logger.trace(
+    'Transforming node',
+    node,
+    'translate(' + (node.x - node.width / 2 - 5) + ', ' + (node.y - node.height / 2 - 5) + ')'
+  );
+  const padding = 8;
+  if (node.clusterNode) {
+    el.attr(
+      'transform',
+      'translate(' +
+        (node.x - node.width / 2 - padding) +
+        ', ' +
+        (node.y - node.height / 2 - padding) +
+        ')'
+    );
+  } else {
+    el.attr('transform', 'translate(' + node.x + ', ' + node.y + ')');
+  }
 };
diff --git a/src/diagrams/flowchart/flowRenderer-v2.js b/src/diagrams/flowchart/flowRenderer-v2.js
index 9e781a2b5..5e4b2ef87 100644
--- a/src/diagrams/flowchart/flowRenderer-v2.js
+++ b/src/diagrams/flowchart/flowRenderer-v2.js
@@ -188,6 +188,8 @@ export const addEdges = function(edges, g) {
     } else {
       edgeData.arrowhead = 'normal';
     }
+
+    logger.info(edgeData, edge);
     edgeData.arrowType = edge.type;
 
     let style = '';

From e8e7b419b5e1fba6af555a27e41bff54fe5ad7f5 Mon Sep 17 00:00:00 2001
From: Knut Sveidqvist <knut.sveidqvist@ipiccolo.com>
Date: Thu, 16 Apr 2020 19:57:56 +0200
Subject: [PATCH 12/12] #1295 Lint fixes

---
 src/dagre-wrapper/index.js                 | 16 +----------
 src/dagre-wrapper/mermaid-graphlib.js      |  4 +--
 src/dagre-wrapper/mermaid-graphlib.spec.js | 31 +---------------------
 3 files changed, 3 insertions(+), 48 deletions(-)

diff --git a/src/dagre-wrapper/index.js b/src/dagre-wrapper/index.js
index 75ab6be1a..dca32ddc8 100644
--- a/src/dagre-wrapper/index.js
+++ b/src/dagre-wrapper/index.js
@@ -9,7 +9,7 @@ import {
   findNonClusterChild
 } from './mermaid-graphlib';
 import { insertNode, positionNode, clear as clearNodes, setNodeElem } from './nodes';
-import { insertCluster, clear as clearClusters, positionCluster } from './clusters';
+import { insertCluster, clear as clearClusters } from './clusters';
 import { insertEdgeLabel, positionEdgeLabel, insertEdge, clear as clearEdges } from './edges';
 import { logger as log } from '../logger';
 
@@ -73,22 +73,8 @@ const recursiveRender = (_elem, graph, diagramtype, parentCluster) => {
     log.trace('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
     log.trace('Edge ' + e.v + ' -> ' + e.w + ': ', e, ' ', JSON.stringify(graph.edge(e)));
 
-    let v = e.v;
-    let w = e.w;
     // Check if link is either from or to a cluster
     log.trace('Fix', clusterDb, 'ids:', e.v, e.w, 'Translateing: ', clusterDb[e.v], clusterDb[e.w]);
-    // Todo handle case with links
-
-    // if (clusterDb[e.v] || clusterDb[e.w]) {
-    //   log.trace('Fixing and trixing - removing', e.v, e.w, e.name);
-    //   v = getAnchorId(e.v, graph, nodes);
-    //   w = getAnchorId(e.w, graph, nodes);
-    //   graph.removeEdge(e.v, e.w, e.name);
-    //   if (v !== e.v) edge.fromCluster = e.v;
-    //   if (w !== e.w) edge.toCluster = e.w;
-    //   log.trace('Fixing Replacing with', v, w, e.name);
-    //   graph.setEdge(v, w, edge, e.name);
-    // }
     insertEdgeLabel(edgeLabels, edge);
   });
 
diff --git a/src/dagre-wrapper/mermaid-graphlib.js b/src/dagre-wrapper/mermaid-graphlib.js
index c7ad345a3..9b8e61fdd 100644
--- a/src/dagre-wrapper/mermaid-graphlib.js
+++ b/src/dagre-wrapper/mermaid-graphlib.js
@@ -7,13 +7,11 @@ import graphlib from 'graphlib';
 export let clusterDb = {};
 let decendants = {};
 let parents = {};
-let graphs = {};
 
 export const clear = () => {
   decendants = {};
   parents = {};
   clusterDb = {};
-  graphs = {};
 };
 
 const isDecendant = (id, ancenstorId) => {
@@ -37,7 +35,7 @@ const edgeInCluster = (edge, clusterId) => {
   if (!(edge.v === clusterId || edge.w === clusterId)) return false;
 
   if (!decendants[clusterId]) {
-    log.debug('Tilt, ', clustedId, ',not in decendants');
+    log.debug('Tilt, ', clusterId, ',not in decendants');
     return false;
   }
 
diff --git a/src/dagre-wrapper/mermaid-graphlib.spec.js b/src/dagre-wrapper/mermaid-graphlib.spec.js
index ad483eea7..33fea60de 100644
--- a/src/dagre-wrapper/mermaid-graphlib.spec.js
+++ b/src/dagre-wrapper/mermaid-graphlib.spec.js
@@ -1,6 +1,6 @@
 import graphlib from 'graphlib';
 import dagre from 'dagre';
-import { validate, adjustClustersAndEdges, extractGraphFromCluster, extractDecendants } from './mermaid-graphlib';
+import { validate, adjustClustersAndEdges, extractDecendants } from './mermaid-graphlib';
 import { setLogLevel, logger } from '../logger';
 
 describe('Graphlib decorations', () => {
@@ -72,35 +72,6 @@ describe('Graphlib decorations', () => {
       expect(validate(g)).toBe(true);
     });
 
-    it('It is possible to copy a cluster to a new graph 1', function () {
-      /*
-        a --> b
-        subgraph C1
-          subgraph C2
-            a
-          end
-          b
-        end
-        C1 --> c
-      */
-      g.setNode('a', { data: 1 });
-      g.setNode('b', { data: 2 });
-      g.setNode('c', { data: 3 });
-      g.setParent('a', 'C2');
-      g.setParent('b', 'C1');
-      g.setParent('C2', 'C1');
-      g.setEdge('a', 'b', { name: 'C1-internal-link' });
-      g.setEdge('C1', 'c', { name: 'C1-external-link' });
-
-      const newGraph = extractGraphFromCluster('C1', g);
-      expect(newGraph.nodes().length).toBe(4);
-      expect(newGraph.edges().length).toBe(1);
-      logger.info(newGraph.children('C1'));
-      expect(newGraph.children('C2')).toEqual(['a']);
-      expect(newGraph.children('C1')).toEqual(['b', 'C2']);
-      expect(newGraph.edges('a')).toEqual([{ v: 'a', w: 'b' }]);
-    });
-
     it('Validate should detect edges between clusters and transform clusters GLB4', function () {
       /*
         a --> b