0d821c0e38a5a6e26746f13664a6a079255502ae-PR-1230

Build # 0d821c0e38a5a6e26746f13664a6a079255502ae-PR-1230

Build Type

github

Committed by GitHub

Commit Message

Merge ec9053718 into 39b873cd5

Pull Request Pull Request #1230: Bug/1223 multiple transitions in statediagram

Run Details

1502 of 2918 branches covered (51.47%)

Branch coverage included in aggregate %.

0 of 7 new or added lines in 2 files covered. (0.0%)

2 existing lines in 2 files now uncovered.

3271 of 5990 relevant lines covered (54.61%)

9190.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

5.03

/src/diagrams/state/stateRenderer.js

import * as d3 from 'd3';
import dagre from 'dagre';
import graphlib from 'graphlib';
import { logger } from '../../logger';
import stateDb from './stateDb';
import { parser } from './parser/stateDiagram';
// import idCache from './id-cache';
import { drawState, addTitleAndBox, drawEdge } from './shapes';
import { getConfig } from '../../config';

parser.yy = stateDb;

// TODO Move conf object to main conf in mermaidAPI
let conf;

const transformationLog = {};

export const setConf = function() {};

// Todo optimize

/**
 * Setup arrow head and define the marker. The result is appended to the svg.
 */
const insertMarkers = function(elem) {
  elem
    .append('defs')
    .append('marker')
    .attr('id', 'dependencyEnd')
    .attr('refX', 19)
    .attr('refY', 7)
    .attr('markerWidth', 20)
    .attr('markerHeight', 28)
    .attr('orient', 'auto')
    .append('path')
    .attr('d', 'M 19,7 L9,13 L14,7 L9,1 Z');
};

/**
 * Draws a flowchart in the tag with id: id based on the graph definition in text.
 * @param text
 * @param id
 */
export const draw = function(text, id) {
  conf = getConfig().state;
  parser.yy.clear();
  parser.parse(text);
  logger.debug('Rendering diagram ' + text);

  // Fetch the default direction, use TD if none was found
  const diagram = d3.select(`[id='${id}']`);
  insertMarkers(diagram);

  // Layout graph, Create a new directed graph
  const graph = new graphlib.Graph({
    multigraph: true,
    compound: true,
    // acyclicer: 'greedy',
    rankdir: 'RL'
    // ranksep: '20'
  });

  // Default to assigning a new object as a label for each new edge.
  graph.setDefaultEdgeLabel(function() {
    return {};
  });

  const rootDoc = stateDb.getRootDoc();
  renderDoc(rootDoc, diagram, undefined, false);

  const padding = conf.padding;
  const bounds = diagram.node().getBBox();

  const width = bounds.width + padding * 2;
  const height = bounds.height + padding * 2;

  // diagram.attr('height', '100%');
  // diagram.attr('style', `width: ${bounds.width * 3 + conf.padding * 2};`);
  // diagram.attr('height', height);

  // Zoom in a bit
  diagram.attr('width', width * 1.75);
  // diagram.attr('height', bounds.height * 3 + conf.padding * 2);
  diagram.attr(
    'viewBox',
    `${bounds.x - conf.padding}  ${bounds.y - conf.padding} ` + width + ' ' + height
  );
  // diagram.attr('transform', `translate(, 0)`);

  // diagram.attr(
  //   'viewBox',
  //   `${conf.padding * -1} ${conf.padding * -1} ` +
  //     (bounds.width * 1.5 + conf.padding * 2) +
  //     ' ' +
  //     (bounds.height + conf.padding * 5)
  // );
};
const getLabelWidth = text => {
  return text ? text.length * conf.fontSizeFactor : 1;
};

/* TODO: REMOVE DUPLICATION, SEE SHAPES */
const getRows = s => {
  if (!s) return 1;
  let str = s.replace(/<br\s*\/?>/gi, '#br#');
  str = str.replace(/\\n/g, '#br#');
  return str.split('#br#');
};

const renderDoc = (doc, diagram, parentId, altBkg) => {
  // // Layout graph, Create a new directed graph
  const graph = new graphlib.Graph({
    compound: true,
    multigraph: true
  });

  let i;
  let edgeFreeDoc = true;
  for (i = 0; i < doc.length; i++) {
    if (doc[i].stmt === 'relation') {
      edgeFreeDoc = false;
      break;
    }
  }

  // Set an object for the graph label
  if (parentId)
    graph.setGraph({
      rankdir: 'LR',
      multigraph: true,
      compound: true,
      // acyclicer: 'greedy',
      ranker: 'tight-tree',
      ranksep: edgeFreeDoc ? 1 : conf.edgeLengthFactor,
      nodeSep: edgeFreeDoc ? 1 : 50,
      isMultiGraph: true
      // ranksep: 5,
      // nodesep: 1
    });
  else {
    graph.setGraph({
      rankdir: 'TB',
      multigraph: true,
      compound: true,
      // isCompound: true,
      // acyclicer: 'greedy',
      // ranker: 'longest-path'
      ranksep: edgeFreeDoc ? 1 : conf.edgeLengthFactor,
      nodeSep: edgeFreeDoc ? 1 : 50,
      ranker: 'tight-tree',
      // ranker: 'network-simplex'
      isMultiGraph: true
    });
  }

  // Default to assigning a new object as a label for each new edge.
  graph.setDefaultEdgeLabel(function() {
    return {};
  });

  stateDb.extract(doc);
  const states = stateDb.getStates();
  const relations = stateDb.getRelations();

  const keys = Object.keys(states);

  let first = true;

  for (let i = 0; i < keys.length; i++) {
    const stateDef = states[keys[i]];

    if (parentId) {
      stateDef.parentId = parentId;
    }

    let node;
    if (stateDef.doc) {
      let sub = diagram
        .append('g')
        .attr('id', stateDef.id)
        .attr('class', 'stateGroup');
      node = renderDoc(stateDef.doc, sub, stateDef.id, !altBkg);

      if (first) {
        // first = false;
        sub = addTitleAndBox(sub, stateDef, altBkg);
        let boxBounds = sub.node().getBBox();
        node.width = boxBounds.width;
        node.height = boxBounds.height + conf.padding / 2;
        transformationLog[stateDef.id] = { y: conf.compositTitleSize };
      } else {
        // sub = addIdAndBox(sub, stateDef);
        let boxBounds = sub.node().getBBox();
        node.width = boxBounds.width;
        node.height = boxBounds.height;
        // transformationLog[stateDef.id] = { y: conf.compositTitleSize };
      }
    } else {
      node = drawState(diagram, stateDef, graph);
    }

    if (stateDef.note) {
      // Draw note note
      const noteDef = {
        descriptions: [],
        id: stateDef.id + '-note',
        note: stateDef.note,
        type: 'note'
      };
      const note = drawState(diagram, noteDef, graph);

      // graph.setNode(node.id, node);
      if (stateDef.note.position === 'left of') {
        graph.setNode(node.id + '-note', note);
        graph.setNode(node.id, node);
      } else {
        graph.setNode(node.id, node);
        graph.setNode(node.id + '-note', note);
      }
      // graph.setNode(node.id);
      graph.setParent(node.id, node.id + '-group');
      graph.setParent(node.id + '-note', node.id + '-group');
    } else {
      // Add nodes to the graph. The first argument is the node id. The second is
      // metadata about the node. In this case we're going to add labels to each of
      // our nodes.
      graph.setNode(node.id, node);
    }
  }

  logger.info('Count=', graph.nodeCount(), graph);
  let cnt = 0;
  relations.forEach(function(relation) {
    cnt++;
    logger.debug('Setting edge', relation);
    graph.setEdge(
      relation.id1,
      relation.id2,
      {
        relation: relation,
        width: getLabelWidth(relation.title),
        height: conf.labelHeight * getRows(relation.title).length,
        labelpos: 'c'
      },
      'id' + cnt
    );
  });

  dagre.layout(graph);

  logger.debug('Graph after layout', graph.nodes());
  const svgElem = diagram.node();

  graph.nodes().forEach(function(v) {
    if (typeof v !== 'undefined' && typeof graph.node(v) !== 'undefined') {
      logger.warn('Node ' + v + ': ' + JSON.stringify(graph.node(v)));
      d3.select('#' + svgElem.id + ' #' + v).attr(
        'transform',
        'translate(' +
          (graph.node(v).x - graph.node(v).width / 2) +
          ',' +
          (graph.node(v).y +
            (transformationLog[v] ? transformationLog[v].y : 0) -
            graph.node(v).height / 2) +
          ' )'
      );
      d3.select('#' + svgElem.id + ' #' + v).attr(
        'data-x-shift',
        graph.node(v).x - graph.node(v).width / 2
      );
      const dividers = document.querySelectorAll('#' + svgElem.id + ' #' + v + ' .divider');
      dividers.forEach(divider => {
        const parent = divider.parentElement;
        let pWidth = 0;
        let pShift = 0;
        if (parent) {
          if (parent.parentElement) pWidth = parent.parentElement.getBBox().width;
          pShift = parseInt(parent.getAttribute('data-x-shift'), 10);
          if (Number.isNaN(pShift)) {
            pShift = 0;
          }
        }
        divider.setAttribute('x1', 0 - pShift + 8);
        divider.setAttribute('x2', pWidth - pShift - 8);
      });
    } else {
      logger.debug('No Node ' + v + ': ' + JSON.stringify(graph.node(v)));
    }
  });

  let stateBox = svgElem.getBBox();

  graph.edges().forEach(function(e) {
    if (typeof e !== 'undefined' && typeof graph.edge(e) !== 'undefined') {
      // logger.debug('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(graph.edge(e)));
      logger.debug('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(graph.edge(e).points));
      drawEdge(diagram, graph.edge(e), graph.edge(e).relation);
    }
  });

  stateBox = svgElem.getBBox();

  const stateInfo = {
    id: parentId ? parentId : 'root',
    label: parentId ? parentId : 'root',
    width: 0,
    height: 0
  };

  stateInfo.width = stateBox.width + 2 * conf.padding;
  stateInfo.height = stateBox.height + 2 * conf.padding;

  logger.info('Doc rendered', stateInfo, graph);
  return stateInfo;
};

export default {
  setConf,
  draw
};

1	import * as d3 from 'd3';
2	import dagre from 'dagre';
3	import graphlib from 'graphlib';
4	import { logger } from '../../logger';
5	import stateDb from './stateDb';
6	import { parser } from './parser/stateDiagram';
7	// import idCache from './id-cache';
8	import { drawState, addTitleAndBox, drawEdge } from './shapes';
9	import { getConfig } from '../../config';
10
11	parser.yy = stateDb;	4✔
12
13	// TODO Move conf object to main conf in mermaidAPI
14	let conf;
15
16	const transformationLog = {};	4✔
17
18	export const setConf = function() {};	4✔
19
20	// Todo optimize
21
22	/**
23	* Setup arrow head and define the marker. The result is appended to the svg.
24	*/
25	const insertMarkers = function(elem) {	4✔
26	elem	×
27	.append('defs')
28	.append('marker')
29	.attr('id', 'dependencyEnd')
30	.attr('refX', 19)
31	.attr('refY', 7)
32	.attr('markerWidth', 20)
33	.attr('markerHeight', 28)
34	.attr('orient', 'auto')
35	.append('path')
36	.attr('d', 'M 19,7 L9,13 L14,7 L9,1 Z');
37	};
38
39	/**
40	* Draws a flowchart in the tag with id: id based on the graph definition in text.
41	* @param text
42	* @param id
43	*/
44	export const draw = function(text, id) {	4✔
45	conf = getConfig().state;	×
46	parser.yy.clear();	×
47	parser.parse(text);	×
48	logger.debug('Rendering diagram ' + text);	×
49
50	// Fetch the default direction, use TD if none was found
51	const diagram = d3.select(`[id='${id}']`);	×
52	insertMarkers(diagram);	×
53
54	// Layout graph, Create a new directed graph
55	const graph = new graphlib.Graph({	×
56	multigraph: true,
57	compound: true,
58	// acyclicer: 'greedy',
59	rankdir: 'RL'
60	// ranksep: '20'
61	});
62
63	// Default to assigning a new object as a label for each new edge.
64	graph.setDefaultEdgeLabel(function() {	×
65	return {};	×
66	});
67
68	const rootDoc = stateDb.getRootDoc();	×
69	renderDoc(rootDoc, diagram, undefined, false);	×
70
71	const padding = conf.padding;	×
72	const bounds = diagram.node().getBBox();	×
73
74	const width = bounds.width + padding * 2;	×
75	const height = bounds.height + padding * 2;	×
76
77	// diagram.attr('height', '100%');
78	// diagram.attr('style', `width: ${bounds.width * 3 + conf.padding * 2};`);
79	// diagram.attr('height', height);
80
81	// Zoom in a bit
82	diagram.attr('width', width * 1.75);	×
83	// diagram.attr('height', bounds.height * 3 + conf.padding * 2);
84	diagram.attr(	×
85	'viewBox',
86	`${bounds.x - conf.padding} ${bounds.y - conf.padding} ` + width + ' ' + height
87	);
88	// diagram.attr('transform', `translate(, 0)`);
89
90	// diagram.attr(
91	// 'viewBox',
92	// `${conf.padding * -1} ${conf.padding * -1} ` +
93	// (bounds.width * 1.5 + conf.padding * 2) +
94	// ' ' +
95	// (bounds.height + conf.padding * 5)
96	// );
97	};
98	const getLabelWidth = text => {	4✔
99	return text ? text.length * conf.fontSizeFactor : 1;	×
100	};
101
102	/* TODO: REMOVE DUPLICATION, SEE SHAPES */
103	const getRows = s => {	4✔
104	if (!s) return 1;	×
105	let str = s.replace(/<br\s*\/?>/gi, '#br#');	×
106	str = str.replace(/\\n/g, '#br#');	×
107	return str.split('#br#');	×
108	};
109
110	const renderDoc = (doc, diagram, parentId, altBkg) => {	4✔
111	// // Layout graph, Create a new directed graph
112	const graph = new graphlib.Graph({	×
113	compound: true,
114	multigraph: true
115	});
116
117	let i;
118	let edgeFreeDoc = true;	×
119	for (i = 0; i < doc.length; i++) {	×
120	if (doc[i].stmt === 'relation') {	×
121	edgeFreeDoc = false;	×
122	break;	×
123	}
124	}
125
126	// Set an object for the graph label
127	if (parentId)	×
128	graph.setGraph({	×
129	rankdir: 'LR',
130	multigraph: true,
131	compound: true,
132	// acyclicer: 'greedy',
133	ranker: 'tight-tree',
134	ranksep: edgeFreeDoc ? 1 : conf.edgeLengthFactor,	×
135	nodeSep: edgeFreeDoc ? 1 : 50,	×
136	isMultiGraph: true
137	// ranksep: 5,
138	// nodesep: 1
139	});
140	else {
141	graph.setGraph({	×
142	rankdir: 'TB',
143	multigraph: true,
144	compound: true,
145	// isCompound: true,
146	// acyclicer: 'greedy',
147	// ranker: 'longest-path'
148	ranksep: edgeFreeDoc ? 1 : conf.edgeLengthFactor,	×
149	nodeSep: edgeFreeDoc ? 1 : 50,	×
150	ranker: 'tight-tree',
151	// ranker: 'network-simplex'
152	isMultiGraph: true
153	});
154	}
155
156	// Default to assigning a new object as a label for each new edge.
157	graph.setDefaultEdgeLabel(function() {	×
158	return {};	×
159	});
160
161	stateDb.extract(doc);	×
162	const states = stateDb.getStates();	×
163	const relations = stateDb.getRelations();	×
164
165	const keys = Object.keys(states);	×
166
167	let first = true;	×
168
169	for (let i = 0; i < keys.length; i++) {	×
170	const stateDef = states[keys[i]];	×
171
172	if (parentId) {	×
173	stateDef.parentId = parentId;	×
174	}
175
176	let node;
177	if (stateDef.doc) {	×
178	let sub = diagram	×
179	.append('g')
180	.attr('id', stateDef.id)
181	.attr('class', 'stateGroup');
182	node = renderDoc(stateDef.doc, sub, stateDef.id, !altBkg);	×
183
184	if (first) {	×
185	// first = false;
186	sub = addTitleAndBox(sub, stateDef, altBkg);	×
187	let boxBounds = sub.node().getBBox();	×
188	node.width = boxBounds.width;	×
189	node.height = boxBounds.height + conf.padding / 2;	×
190	transformationLog[stateDef.id] = { y: conf.compositTitleSize };	×
191	} else {
192	// sub = addIdAndBox(sub, stateDef);
193	let boxBounds = sub.node().getBBox();	×
194	node.width = boxBounds.width;	×
195	node.height = boxBounds.height;	×
196	// transformationLog[stateDef.id] = { y: conf.compositTitleSize };
197	}
198	} else {
199	node = drawState(diagram, stateDef, graph);	×
200	}
201
202	if (stateDef.note) {	×
203	// Draw note note
204	const noteDef = {	×
205	descriptions: [],
206	id: stateDef.id + '-note',
207	note: stateDef.note,
208	type: 'note'
209	};
210	const note = drawState(diagram, noteDef, graph);	×
211
212	// graph.setNode(node.id, node);
213	if (stateDef.note.position === 'left of') {	×
214	graph.setNode(node.id + '-note', note);	×
215	graph.setNode(node.id, node);	×
216	} else {
217	graph.setNode(node.id, node);	×
218	graph.setNode(node.id + '-note', note);	×
219	}
220	// graph.setNode(node.id);
221	graph.setParent(node.id, node.id + '-group');	×
222	graph.setParent(node.id + '-note', node.id + '-group');	×
223	} else {
224	// Add nodes to the graph. The first argument is the node id. The second is
225	// metadata about the node. In this case we're going to add labels to each of
226	// our nodes.
227	graph.setNode(node.id, node);	×
228	}
229	}
230
NEW 231	logger.info('Count=', graph.nodeCount(), graph);	×
NEW 232	let cnt = 0;	×
233	relations.forEach(function(relation) {	×
NEW 234	cnt++;	×
NEW 235	logger.debug('Setting edge', relation);	×
NEW 236	graph.setEdge(	×
237	relation.id1,
238	relation.id2,
239	{
240	relation: relation,
241	width: getLabelWidth(relation.title),
242	height: conf.labelHeight * getRows(relation.title).length,
243	labelpos: 'c'
244	},
245	'id' + cnt
246	);
247	});
248
249	dagre.layout(graph);	×
250
251	logger.debug('Graph after layout', graph.nodes());	×
252	const svgElem = diagram.node();	×
253
254	graph.nodes().forEach(function(v) {	×
255	if (typeof v !== 'undefined' && typeof graph.node(v) !== 'undefined') {	×
256	logger.warn('Node ' + v + ': ' + JSON.stringify(graph.node(v)));	×
257	d3.select('#' + svgElem.id + ' #' + v).attr(	×
258	'transform',
259	'translate(' +
260	(graph.node(v).x - graph.node(v).width / 2) +
261	',' +
262	(graph.node(v).y +
263	(transformationLog[v] ? transformationLog[v].y : 0) -	×
264	graph.node(v).height / 2) +
265	' )'
266	);
267	d3.select('#' + svgElem.id + ' #' + v).attr(	×
268	'data-x-shift',
269	graph.node(v).x - graph.node(v).width / 2
270	);
271	const dividers = document.querySelectorAll('#' + svgElem.id + ' #' + v + ' .divider');	×
272	dividers.forEach(divider => {	×
273	const parent = divider.parentElement;	×
274	let pWidth = 0;	×
275	let pShift = 0;	×
276	if (parent) {	×
277	if (parent.parentElement) pWidth = parent.parentElement.getBBox().width;	×
278	pShift = parseInt(parent.getAttribute('data-x-shift'), 10);	×
279	if (Number.isNaN(pShift)) {	×
280	pShift = 0;	×
281	}
282	}
283	divider.setAttribute('x1', 0 - pShift + 8);	×
284	divider.setAttribute('x2', pWidth - pShift - 8);	×
285	});
286	} else {
287	logger.debug('No Node ' + v + ': ' + JSON.stringify(graph.node(v)));	×
288	}
289	});
290
291	let stateBox = svgElem.getBBox();	×
292
293	graph.edges().forEach(function(e) {	×
294	if (typeof e !== 'undefined' && typeof graph.edge(e) !== 'undefined') {	×
295	// logger.debug('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(graph.edge(e)));
NEW 296	logger.debug('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(graph.edge(e).points));	×
UNCOV 297	drawEdge(diagram, graph.edge(e), graph.edge(e).relation);	×
298	}
299	});
300
301	stateBox = svgElem.getBBox();	×
302
303	const stateInfo = {	×
304	id: parentId ? parentId : 'root',	×
305	label: parentId ? parentId : 'root',	×
306	width: 0,
307	height: 0
308	};
309
310	stateInfo.width = stateBox.width + 2 * conf.padding;	×
311	stateInfo.height = stateBox.height + 2 * conf.padding;	×
312
313	logger.info('Doc rendered', stateInfo, graph);	×
314	return stateInfo;	×
315	};
316
317	export default {
318	setConf,
319	draw
320	};

mermaid-js / mermaid / 0d821c0e38a5a6e26746f13664a6a079255502ae-PR-1230

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous