marcel/mermaid
1
0
Fork 0
mirror of https://github.com/mermaid-js/mermaid.git synced 2025-09-19 15:30:03 +02:00
Code Issues Packages Projects Releases Wiki Activity

Standardized naming in the log functionality

Browse Source
This commit is contained in:
harshilparmar
2021-02-02 08:33:44 +05:30
parent e70b32e14d
commit eb206cb687
3 changed files with 92 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/dagre-wrapper/clusters.js
View File

@@ -1,11 +1,11 @@
import intersectRect from './intersect/intersect-rect'; import intersectRect from './intersect/intersect-rect';
import { logger as log } from '../logger'; // eslint-disable-line import { logger } from '../logger'; // eslint-disable-line
import createLabel from './createLabel'; import createLabel from './createLabel';
import { select } from 'd3'; import { select } from 'd3';
import { getConfig } from '../config'; import { getConfig } from '../config';
const rect = (parent, node) => { const rect = (parent, node) => {
log.trace('Creating subgraph rect for ', node.id, node); logger.trace('Creating subgraph rect for ', node.id, node);
// Add outer g element // Add outer g element
const shapeSvg = parent const shapeSvg = parent
@@ -37,7 +37,7 @@ const rect = (parent, node) => {
const padding = 0 * node.padding; const padding = 0 * node.padding;
const halfPadding = padding / 2; const halfPadding = padding / 2;
log.trace('Data ', node, JSON.stringify(node)); logger.trace('Data ', node, JSON.stringify(node));
// center the rect around its coordinate // center the rect around its coordinate
rect rect
.attr('style', node.style) .attr('style', node.style)
@@ -208,7 +208,7 @@ const shapes = { rect, roundedWithTitle, noteGroup, divider };
let clusterElems = {}; let clusterElems = {};
export const insertCluster = (elem, node) => { export const insertCluster = (elem, node) => {
log.trace('Inserting cluster'); logger.trace('Inserting cluster');
const shape = node.shape || 'rect'; const shape = node.shape || 'rect';
clusterElems[node.id] = shapes[shape](elem, node); clusterElems[node.id] = shapes[shape](elem, node);
}; };
@@ -225,7 +225,7 @@ export const clear = () => {
}; };
export const positionCluster = node => { export const positionCluster = node => {
log.info('Position cluster'); logger.info('Position cluster');
const el = clusterElems[node.id]; const el = clusterElems[node.id];
el.attr('transform', 'translate(' + node.x + ', ' + node.y + ')'); el.attr('transform', 'translate(' + node.x + ', ' + node.y + ')');

58
src/dagre-wrapper/index.js
View File

@@ -12,21 +12,21 @@ import {
import { insertNode, positionNode, clear as clearNodes, setNodeElem } from './nodes'; import { insertNode, positionNode, clear as clearNodes, setNodeElem } from './nodes';
import { insertCluster, clear as clearClusters } from './clusters'; import { insertCluster, clear as clearClusters } from './clusters';
import { insertEdgeLabel, positionEdgeLabel, insertEdge, clear as clearEdges } from './edges'; import { insertEdgeLabel, positionEdgeLabel, insertEdge, clear as clearEdges } from './edges';
import { logger as log } from '../logger'; import { logger } from '../logger';
const recursiveRender = (_elem, graph, diagramtype, parentCluster) => { const recursiveRender = (_elem, graph, diagramtype, parentCluster) => {
log.info('Graph in recursive render: XXX', graphlib.json.write(graph), parentCluster); logger.info('Graph in recursive render: XXX', graphlib.json.write(graph), parentCluster);
const dir = graph.graph().rankdir; const dir = graph.graph().rankdir;
log.warn('Dir in recursive render - dir:', dir); logger.warn('Dir in recursive render - dir:', dir);
const elem = _elem.insert('g').attr('class', 'root'); // eslint-disable-line const elem = _elem.insert('g').attr('class', 'root'); // eslint-disable-line
if (!graph.nodes()) { if (!graph.nodes()) {
log.info('No nodes found for', graph); logger.info('No nodes found for', graph);
} else { } else {
log.info('Recursive render XXX', graph.nodes()); logger.info('Recursive render XXX', graph.nodes());
} }
if (graph.edges().length > 0) { if (graph.edges().length > 0) {
log.info('Recursive edges', graph.edge(graph.edges()[0])); logger.info('Recursive edges', graph.edge(graph.edges()[0]));
} }
const clusters = elem.insert('g').attr('class', 'clusters'); // eslint-disable-line const clusters = elem.insert('g').attr('class', 'clusters'); // eslint-disable-line
const edgePaths = elem.insert('g').attr('class', 'edgePaths'); const edgePaths = elem.insert('g').attr('class', 'edgePaths');
@@ -40,32 +40,32 @@ const recursiveRender = (_elem, graph, diagramtype, parentCluster) => {
if (typeof parentCluster !== 'undefined') { if (typeof parentCluster !== 'undefined') {
const data = JSON.parse(JSON.stringify(parentCluster.clusterData)); const data = JSON.parse(JSON.stringify(parentCluster.clusterData));
// data.clusterPositioning = true; // data.clusterPositioning = true;
log.info('Setting data for cluster XXX (', v, ') ', data, parentCluster); logger.info('Setting data for cluster XXX (', v, ') ', data, parentCluster);
graph.setNode(parentCluster.id, data); graph.setNode(parentCluster.id, data);
if (!graph.parent(v)) { if (!graph.parent(v)) {
log.warn('Setting parent', v, parentCluster.id); logger.warn('Setting parent', v, parentCluster.id);
graph.setParent(v, parentCluster.id, data); graph.setParent(v, parentCluster.id, data);
} }
} }
log.info('(Insert) Node XXX' + v + ': ' + JSON.stringify(graph.node(v))); logger.info('(Insert) Node XXX' + v + ': ' + JSON.stringify(graph.node(v)));
if (node && node.clusterNode) { if (node && node.clusterNode) {
// const children = graph.children(v); // const children = graph.children(v);
log.info('Cluster identified', v, node, graph.node(v)); logger.info('Cluster identified', v, node, graph.node(v));
const newEl = recursiveRender(nodes, node.graph, diagramtype, graph.node(v)); const newEl = recursiveRender(nodes, node.graph, diagramtype, graph.node(v));
updateNodeBounds(node, newEl); updateNodeBounds(node, newEl);
setNodeElem(newEl, node); setNodeElem(newEl, node);
log.warn('Recursive render complete', newEl, node); logger.warn('Recursive render complete', newEl, node);
} else { } else {
if (graph.children(v).length > 0) { if (graph.children(v).length > 0) {
// This is a cluster but not to be rendered recusively // This is a cluster but not to be rendered recusively
// Render as before // Render as before
log.info('Cluster - the non recursive path XXX', v, node.id, node, graph); logger.info('Cluster - the non recursive path XXX', v, node.id, node, graph);
log.info(findNonClusterChild(node.id, graph)); logger.info(findNonClusterChild(node.id, graph));
clusterDb[node.id] = { id: findNonClusterChild(node.id, graph), node }; clusterDb[node.id] = { id: findNonClusterChild(node.id, graph), node };
// insertCluster(clusters, graph.node(v)); // insertCluster(clusters, graph.node(v));
} else { } else {
log.info('Node - the non recursive path', v, node.id, node); logger.info('Node - the non recursive path', v, node.id, node);
insertNode(nodes, graph.node(v), dir); insertNode(nodes, graph.node(v), dir);
} }
} }
@@ -77,28 +77,28 @@ const recursiveRender = (_elem, graph, diagramtype, parentCluster) => {
// TODO: pick optimal child in the cluster to us as link anchor // TODO: pick optimal child in the cluster to us as link anchor
graph.edges().forEach(function(e) { graph.edges().forEach(function(e) {
const edge = graph.edge(e.v, e.w, e.name); const edge = graph.edge(e.v, e.w, e.name);
log.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e)); logger.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
log.info('Edge ' + e.v + ' -> ' + e.w + ': ', e, ' ', JSON.stringify(graph.edge(e))); logger.info('Edge ' + e.v + ' -> ' + e.w + ': ', e, ' ', JSON.stringify(graph.edge(e)));
// Check if link is either from or to a cluster // 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]); logger.info('Fix', clusterDb, 'ids:', e.v, e.w, 'Translateing: ', clusterDb[e.v], clusterDb[e.w]);
insertEdgeLabel(edgeLabels, edge); insertEdgeLabel(edgeLabels, edge);
}); });
graph.edges().forEach(function(e) { graph.edges().forEach(function(e) {
log.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e)); logger.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
}); });
log.info('#############################################'); logger.info('#############################################');
log.info('### Layout ###'); logger.info('### Layout ###');
log.info('#############################################'); logger.info('#############################################');
log.info(graph); logger.info(graph);
dagre.layout(graph); dagre.layout(graph);
log.info('Graph after layout:', graphlib.json.write(graph)); logger.info('Graph after layout:', graphlib.json.write(graph));
// Move the nodes to the correct place // Move the nodes to the correct place
sortNodesByHierarchy(graph).forEach(function(v) { sortNodesByHierarchy(graph).forEach(function(v) {
const node = graph.node(v); const node = graph.node(v);
log.info('Position ' + v + ': ' + JSON.stringify(graph.node(v))); logger.info('Position ' + v + ': ' + JSON.stringify(graph.node(v)));
log.info( logger.info(
'Position ' + v + ': (' + node.x, 'Position ' + v + ': (' + node.x,
',' + node.y, ',' + node.y,
') width: ', ') width: ',
@@ -126,7 +126,7 @@ const recursiveRender = (_elem, graph, diagramtype, parentCluster) => {
// Move the edge labels to the correct place after layout // Move the edge labels to the correct place after layout
graph.edges().forEach(function(e) { graph.edges().forEach(function(e) {
const edge = graph.edge(e); const edge = graph.edge(e);
log.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(edge), edge); logger.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(edge), edge);
const paths = insertEdge(edgePaths, e, edge, clusterDb, diagramtype, graph); const paths = insertEdge(edgePaths, e, edge, clusterDb, diagramtype, graph);
positionEdgeLabel(edge, paths); positionEdgeLabel(edge, paths);
@@ -142,10 +142,10 @@ export const render = (elem, graph, markers, diagramtype, id) => {
clearClusters(); clearClusters();
clearGraphlib(); clearGraphlib();
log.warn('Graph at first:', graphlib.json.write(graph)); logger.warn('Graph at first:', graphlib.json.write(graph));
adjustClustersAndEdges(graph); adjustClustersAndEdges(graph);
log.warn('Graph after:', graphlib.json.write(graph)); logger.warn('Graph after:', graphlib.json.write(graph));
// log.warn('Graph ever after:', graphlib.json.write(graph.node('A').graph)); // logger.warn('Graph ever after:', graphlib.json.write(graph.node('A').graph));
recursiveRender(elem, graph, diagramtype); recursiveRender(elem, graph, diagramtype);
}; };

116
src/dagre-wrapper/mermaid-graphlib.js
View File

@@ -1,7 +1,7 @@
/** /**
* Decorates with functions required by mermaids dagre-wrapper. * Decorates with functions required by mermaids dagre-wrapper.
*/ */
import { logger as log } from '../logger'; import { logger } from '../logger';
import graphlib from 'graphlib'; import graphlib from 'graphlib';
export let clusterDb = {}; export let clusterDb = {};
@@ -17,7 +17,7 @@ export const clear = () => {
const isDecendant = (id, ancenstorId) => { const isDecendant = (id, ancenstorId) => {
// if (id === ancenstorId) return true; // if (id === ancenstorId) return true;
log.debug( logger.debug(
'In isDecendant', 'In isDecendant',
ancenstorId, ancenstorId,
' ', ' ',
@@ -31,17 +31,17 @@ const isDecendant = (id, ancenstorId) => {
}; };
const edgeInCluster = (edge, clusterId) => { const edgeInCluster = (edge, clusterId) => {
log.info('Decendants of ', clusterId, ' is ', decendants[clusterId]); logger.info('Decendants of ', clusterId, ' is ', decendants[clusterId]);
log.info('Edge is ', edge); logger.info('Edge is ', edge);
// Edges to/from the cluster is not in the cluster, they are in the parent // Edges to/from the cluster is not in the cluster, they are in the parent
if (edge.v === clusterId) return false; if (edge.v === clusterId) return false;
if (edge.w === clusterId) return false; if (edge.w === clusterId) return false;
if (!decendants[clusterId]) { if (!decendants[clusterId]) {
log.debug('Tilt, ', clusterId, ',not in decendants'); logger.debug('Tilt, ', clusterId, ',not in decendants');
return false; return false;
} }
log.info('Here '); logger.info('Here ');
if (decendants[clusterId].indexOf(edge.v) >= 0) return true; if (decendants[clusterId].indexOf(edge.v) >= 0) return true;
if (isDecendant(edge.v, clusterId)) return true; if (isDecendant(edge.v, clusterId)) return true;
@@ -52,7 +52,7 @@ const edgeInCluster = (edge, clusterId) => {
}; };
const copy = (clusterId, graph, newGraph, rootId) => { const copy = (clusterId, graph, newGraph, rootId) => {
log.warn( logger.warn(
'Copying children of ', 'Copying children of ',
clusterId, clusterId,
'root', 'root',
@@ -68,26 +68,26 @@ const copy = (clusterId, graph, newGraph, rootId) => {
nodes.push(clusterId); nodes.push(clusterId);
} }
log.warn('Copying (nodes) clusterId', clusterId, 'nodes', nodes); logger.warn('Copying (nodes) clusterId', clusterId, 'nodes', nodes);
nodes.forEach(node => { nodes.forEach(node => {
if (graph.children(node).length > 0) { if (graph.children(node).length > 0) {
copy(node, graph, newGraph, rootId); copy(node, graph, newGraph, rootId);
} else { } else {
const data = graph.node(node); const data = graph.node(node);
log.info('cp ', node, ' to ', rootId, ' with parent ', clusterId); //,node, data, ' parent is ', clusterId); logger.info('cp ', node, ' to ', rootId, ' with parent ', clusterId); //,node, data, ' parent is ', clusterId);
newGraph.setNode(node, data); newGraph.setNode(node, data);
if (rootId !== graph.parent(node)) { if (rootId !== graph.parent(node)) {
log.warn('Setting parent', node, graph.parent(node)); logger.warn('Setting parent', node, graph.parent(node));
newGraph.setParent(node, graph.parent(node)); newGraph.setParent(node, graph.parent(node));
} }
if (clusterId !== rootId && node !== clusterId) { if (clusterId !== rootId && node !== clusterId) {
log.debug('Setting parent', node, clusterId); logger.debug('Setting parent', node, clusterId);
newGraph.setParent(node, clusterId); newGraph.setParent(node, clusterId);
} else { } else {
log.info('In copy ', clusterId, 'root', rootId, 'data', graph.node(clusterId), rootId); logger.info('In copy ', clusterId, 'root', rootId, 'data', graph.node(clusterId), rootId);
log.debug( logger.debug(
'Not Setting parent for node=', 'Not Setting parent for node=',
node, node,
'cluster!==rootId', 'cluster!==rootId',
@@ -97,19 +97,19 @@ const copy = (clusterId, graph, newGraph, rootId) => {
); );
} }
const edges = graph.edges(node); const edges = graph.edges(node);
log.debug('Copying Edges', edges); logger.debug('Copying Edges', edges);
edges.forEach(edge => { edges.forEach(edge => {
log.info('Edge', edge); logger.info('Edge', edge);
const data = graph.edge(edge.v, edge.w, edge.name); const data = graph.edge(edge.v, edge.w, edge.name);
log.info('Edge data', data, rootId); logger.info('Edge data', data, rootId);
try { try {
// Do not copy edges in and out of the root cluster, they belong to the parent graph // Do not copy edges in and out of the root cluster, they belong to the parent graph
if (edgeInCluster(edge, rootId)) { if (edgeInCluster(edge, rootId)) {
log.info('Copying as ', edge.v, edge.w, data, edge.name); logger.info('Copying as ', edge.v, edge.w, data, edge.name);
newGraph.setEdge(edge.v, edge.w, data, edge.name); newGraph.setEdge(edge.v, edge.w, data, edge.name);
log.info('newGraph edges ', newGraph.edges(), newGraph.edge(newGraph.edges()[0])); logger.info('newGraph edges ', newGraph.edges(), newGraph.edge(newGraph.edges()[0]));
} else { } else {
log.info( logger.info(
'Skipping copy of edge ', 'Skipping copy of edge ',
edge.v, edge.v,
'-->', '-->',
@@ -121,16 +121,16 @@ const copy = (clusterId, graph, newGraph, rootId) => {
); );
} }
} catch (e) { } catch (e) {
log.error(e); logger.error(e);
} }
}); });
} }
log.debug('Removing node', node); logger.debug('Removing node', node);
graph.removeNode(node); graph.removeNode(node);
}); });
}; };
export const extractDecendants = (id, graph) => { export const extractDecendants = (id, graph) => {
// log.debug('Extracting ', id); // logger.debug('Extracting ', id);
const children = graph.children(id); const children = graph.children(id);
let res = [].concat(children); let res = [].concat(children);
@@ -149,14 +149,14 @@ export const extractDecendants = (id, graph) => {
*/ */
export const validate = graph => { export const validate = graph => {
const edges = graph.edges(); const edges = graph.edges();
log.trace('Edges: ', edges); logger.trace('Edges: ', edges);
for (let i = 0; i < edges.length; i++) { for (let i = 0; i < edges.length; i++) {
if (graph.children(edges[i].v).length > 0) { if (graph.children(edges[i].v).length > 0) {
log.trace('The node ', edges[i].v, ' is part of and edge even though it has children'); logger.trace('The node ', edges[i].v, ' is part of and edge even though it has children');
return false; return false;
} }
if (graph.children(edges[i].w).length > 0) { if (graph.children(edges[i].w).length > 0) {
log.trace('The node ', edges[i].w, ' is part of and edge even though it has children'); logger.trace('The node ', edges[i].w, ' is part of and edge even though it has children');
return false; return false;
} }
} }
@@ -170,18 +170,18 @@ export const validate = graph => {
*/ */
export const findNonClusterChild = (id, graph) => { export const findNonClusterChild = (id, graph) => {
// const node = graph.node(id); // const node = graph.node(id);
log.trace('Searching', id); logger.trace('Searching', id);
// const children = graph.children(id).reverse(); // const children = graph.children(id).reverse();
const children = graph.children(id); //.reverse(); const children = graph.children(id); //.reverse();
log.trace('Searching children of id ', id, children); logger.trace('Searching children of id ', id, children);
if (children.length < 1) { if (children.length < 1) {
log.trace('This is a valid node', id); logger.trace('This is a valid node', id);
return id; return id;
} }
for (let i = 0; i < children.length; i++) { for (let i = 0; i < children.length; i++) {
const _id = findNonClusterChild(children[i], graph); const _id = findNonClusterChild(children[i], graph);
if (_id) { if (_id) {
log.trace('Found replacement for', id, ' => ', _id); logger.trace('Found replacement for', id, ' => ', _id);
return _id; return _id;
} }
} }
@@ -205,17 +205,17 @@ const getAnchorId = id => {
export const adjustClustersAndEdges = (graph, depth) => { export const adjustClustersAndEdges = (graph, depth) => {
if (!graph || depth > 10) { if (!graph || depth > 10) {
log.debug('Opting out, no graph '); logger.debug('Opting out, no graph ');
return; return;
} else { } else {
log.debug('Opting in, graph '); logger.debug('Opting in, graph ');
} }
// Go through the nodes and for each cluster found, save a replacment node, this can be used when // Go through the nodes and for each cluster found, save a replacment node, this can be used when
// faking a link to a cluster // faking a link to a cluster
graph.nodes().forEach(function(id) { graph.nodes().forEach(function(id) {
const children = graph.children(id); const children = graph.children(id);
if (children.length > 0) { if (children.length > 0) {
log.warn( logger.warn(
'Cluster identified', 'Cluster identified',
id, id,
' Replacement id in edges: ', ' Replacement id in edges: ',
@@ -231,9 +231,9 @@ export const adjustClustersAndEdges = (graph, depth) => {
const children = graph.children(id); const children = graph.children(id);
const edges = graph.edges(); const edges = graph.edges();
if (children.length > 0) { if (children.length > 0) {
log.debug('Cluster identified', id, decendants); logger.debug('Cluster identified', id, decendants);
edges.forEach(edge => { edges.forEach(edge => {
// log.debug('Edge, decendants: ', edge, decendants[id]); // logger.debug('Edge, decendants: ', edge, decendants[id]);
// Check if any edge leaves the cluster (not the actual cluster, thats a link from the box) // 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 (edge.v !== id && edge.w !== id) {
@@ -245,14 +245,14 @@ export const adjustClustersAndEdges = (graph, depth) => {
// d1 xor d2 - if either d1 is true and d2 is false or the other way around // d1 xor d2 - if either d1 is true and d2 is false or the other way around
if (d1 ^ d2) { if (d1 ^ d2) {
log.warn('Edge: ', edge, ' leaves cluster ', id); logger.warn('Edge: ', edge, ' leaves cluster ', id);
log.warn('Decendants of XXX ', id, ': ', decendants[id]); logger.warn('Decendants of XXX ', id, ': ', decendants[id]);
clusterDb[id].externalConnections = true; clusterDb[id].externalConnections = true;
} }
} }
}); });
} else { } else {
log.debug('Not a cluster ', id, decendants); logger.debug('Not a cluster ', id, decendants);
} }
}); });
@@ -260,13 +260,13 @@ export const adjustClustersAndEdges = (graph, depth) => {
// in the cluster inorder to fake the edge // in the cluster inorder to fake the edge
graph.edges().forEach(function(e) { graph.edges().forEach(function(e) {
const edge = graph.edge(e); const edge = graph.edge(e);
log.warn('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e)); logger.warn('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
log.warn('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(graph.edge(e))); logger.warn('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(graph.edge(e)));
let v = e.v; let v = e.v;
let w = e.w; let w = e.w;
// Check if link is either from or to a cluster // Check if link is either from or to a cluster
log.warn( logger.warn(
'Fix XXX', 'Fix XXX',
clusterDb, clusterDb,
'ids:', 'ids:',
@@ -278,20 +278,20 @@ export const adjustClustersAndEdges = (graph, depth) => {
clusterDb[e.w] clusterDb[e.w]
); );
if (clusterDb[e.v] || clusterDb[e.w]) { if (clusterDb[e.v] || clusterDb[e.w]) {
log.warn('Fixing and trixing - removing XXX', e.v, e.w, e.name); logger.warn('Fixing and trixing - removing XXX', e.v, e.w, e.name);
v = getAnchorId(e.v); v = getAnchorId(e.v);
w = getAnchorId(e.w); w = getAnchorId(e.w);
graph.removeEdge(e.v, e.w, e.name); graph.removeEdge(e.v, e.w, e.name);
if (v !== e.v) edge.fromCluster = e.v; if (v !== e.v) edge.fromCluster = e.v;
if (w !== e.w) edge.toCluster = e.w; if (w !== e.w) edge.toCluster = e.w;
log.warn('Fix Replacing with XXX', v, w, e.name); logger.warn('Fix Replacing with XXX', v, w, e.name);
graph.setEdge(v, w, edge, e.name); graph.setEdge(v, w, edge, e.name);
} }
}); });
log.warn('Adjusted Graph', graphlib.json.write(graph)); logger.warn('Adjusted Graph', graphlib.json.write(graph));
extractor(graph, 0); extractor(graph, 0);
log.trace(clusterDb); logger.trace(clusterDb);
// Remove references to extracted cluster // Remove references to extracted cluster
// graph.edges().forEach(edge => { // graph.edges().forEach(edge => {
@@ -302,9 +302,9 @@ export const adjustClustersAndEdges = (graph, depth) => {
}; };
export const extractor = (graph, depth) => { export const extractor = (graph, depth) => {
log.warn('extractor - ', depth, graphlib.json.write(graph), graph.children('D')); logger.warn('extractor - ', depth, graphlib.json.write(graph), graph.children('D'));
if (depth > 10) { if (depth > 10) {
log.error('Bailing out'); logger.error('Bailing out');
return; return;
} }
// For clusters without incoming and/or outgoing edges, create a new cluster-node // For clusters without incoming and/or outgoing edges, create a new cluster-node
@@ -319,16 +319,16 @@ export const extractor = (graph, depth) => {
} }
if (!hasChildren) { if (!hasChildren) {
log.debug('Done, no node has children', graph.nodes()); logger.debug('Done, no node has children', graph.nodes());
return; return;
} }
// const clusters = Object.keys(clusterDb); // const clusters = Object.keys(clusterDb);
// clusters.forEach(clusterId => { // clusters.forEach(clusterId => {
log.debug('Nodes = ', nodes, depth); logger.debug('Nodes = ', nodes, depth);
for (let i = 0; i < nodes.length; i++) { for (let i = 0; i < nodes.length; i++) {
const node = nodes[i]; const node = nodes[i];
log.debug( logger.debug(
'Extracting node', 'Extracting node',
node, node,
clusterDb, clusterDb,
@@ -343,7 +343,7 @@ export const extractor = (graph, depth) => {
// that it still is in the game // that it still is in the game
if (!clusterDb[node]) { if (!clusterDb[node]) {
// Skip if the node is not a cluster // Skip if the node is not a cluster
log.debug('Not a cluster', node, depth); logger.debug('Not a cluster', node, depth);
// break; // break;
} else if ( } else if (
!clusterDb[node].externalConnections && !clusterDb[node].externalConnections &&
@@ -351,7 +351,7 @@ export const extractor = (graph, depth) => {
graph.children(node) && graph.children(node) &&
graph.children(node).length > 0 graph.children(node).length > 0
) { ) {
log.warn( logger.warn(
'Cluster without external connections, without a parent and with children', 'Cluster without external connections, without a parent and with children',
node, node,
depth depth
@@ -375,7 +375,7 @@ export const extractor = (graph, depth) => {
return {}; return {};
}); });
log.warn('Old graph before copy', graphlib.json.write(graph)); logger.warn('Old graph before copy', graphlib.json.write(graph));
copy(node, graph, clusterGraph, node); copy(node, graph, clusterGraph, node);
graph.setNode(node, { graph.setNode(node, {
clusterNode: true, clusterNode: true,
@@ -384,10 +384,10 @@ export const extractor = (graph, depth) => {
labelText: clusterDb[node].labelText, labelText: clusterDb[node].labelText,
graph: clusterGraph graph: clusterGraph
}); });
log.warn('New graph after copy node: (', node, ')', graphlib.json.write(clusterGraph)); logger.warn('New graph after copy node: (', node, ')', graphlib.json.write(clusterGraph));
log.debug('Old graph after copy', graphlib.json.write(graph)); logger.debug('Old graph after copy', graphlib.json.write(graph));
} else { } else {
log.warn( logger.warn(
'Cluster ** ', 'Cluster ** ',
node, node,
' **not meeting the criteria !externalConnections:', ' **not meeting the criteria !externalConnections:',
@@ -399,16 +399,16 @@ export const extractor = (graph, depth) => {
graph.children('D'), graph.children('D'),
depth depth
); );
log.debug(clusterDb); logger.debug(clusterDb);
} }
} }
nodes = graph.nodes(); nodes = graph.nodes();
log.warn('New list of nodes', nodes); logger.warn('New list of nodes', nodes);
for (let i = 0; i < nodes.length; i++) { for (let i = 0; i < nodes.length; i++) {
const node = nodes[i]; const node = nodes[i];
const data = graph.node(node); const data = graph.node(node);
log.warn(' Now next level', node, data); logger.warn(' Now next level', node, data);
if (data.clusterNode) { if (data.clusterNode) {
extractor(data.graph, depth + 1); extractor(data.graph, depth + 1);
} }