75e2abe24205a7ca564fd36138c8807e8777420d

Build # 75e2abe24205a7ca564fd36138c8807e8777420d

Build Type

push

github

Committed by GitHub

Commit Message

Merge pull request #1166 from GDFaber/feature/flowchart_add_cylindric_shape

Run Details

1430 of 2838 branches covered (50.39%)

Branch coverage included in aggregate %.

14 of 24 new or added lines in 3 files covered. (58.33%)

142 existing lines in 1 file now uncovered.

3125 of 5844 relevant lines covered (53.47%)

215.61 hits per line

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

73.08

/src/diagrams/flowchart/flowChartShapes.js

import dagreD3 from 'dagre-d3';

function question(parent, bbox, node) {
  const w = bbox.width;
  const h = bbox.height;
  const s = (w + h) * 0.9;
  const points = [
    { x: s / 2, y: 0 },
    { x: s, y: -s / 2 },
    { x: s / 2, y: -s },
    { x: 0, y: -s / 2 }
  ];
  const shapeSvg = insertPolygonShape(parent, s, s, points);
  node.intersect = function(point) {
    return dagreD3.intersect.polygon(node, points, point);
  };
  return shapeSvg;
}

function hexagon(parent, bbox, node) {
  const f = 4;
  const h = bbox.height;
  const m = h / f;
  const w = bbox.width + 2 * m;
  const points = [
    { x: m, y: 0 },
    { x: w - m, y: 0 },
    { x: w, y: -h / 2 },
    { x: w - m, y: -h },
    { x: m, y: -h },
    { x: 0, y: -h / 2 }
  ];
  const shapeSvg = insertPolygonShape(parent, w, h, points);
  node.intersect = function(point) {
    return dagreD3.intersect.polygon(node, points, point);
  };
  return shapeSvg;
}

function rect_left_inv_arrow(parent, bbox, node) {
  const w = bbox.width;
  const h = bbox.height;
  const points = [
    { x: -h / 2, y: 0 },
    { x: w, y: 0 },
    { x: w, y: -h },
    { x: -h / 2, y: -h },
    { x: 0, y: -h / 2 }
  ];
  const shapeSvg = insertPolygonShape(parent, w, h, points);
  node.intersect = function(point) {
    return dagreD3.intersect.polygon(node, points, point);
  };
  return shapeSvg;
}

function lean_right(parent, bbox, node) {
  const w = bbox.width;
  const h = bbox.height;
  const points = [
    { x: (-2 * h) / 6, y: 0 },
    { x: w - h / 6, y: 0 },
    { x: w + (2 * h) / 6, y: -h },
    { x: h / 6, y: -h }
  ];
  const shapeSvg = insertPolygonShape(parent, w, h, points);
  node.intersect = function(point) {
    return dagreD3.intersect.polygon(node, points, point);
  };
  return shapeSvg;
}

function lean_left(parent, bbox, node) {
  const w = bbox.width;
  const h = bbox.height;
  const points = [
    { x: (2 * h) / 6, y: 0 },
    { x: w + h / 6, y: 0 },
    { x: w - (2 * h) / 6, y: -h },
    { x: -h / 6, y: -h }
  ];
  const shapeSvg = insertPolygonShape(parent, w, h, points);
  node.intersect = function(point) {
    return dagreD3.intersect.polygon(node, points, point);
  };
  return shapeSvg;
}

function trapezoid(parent, bbox, node) {
  const w = bbox.width;
  const h = bbox.height;
  const points = [
    { x: (-2 * h) / 6, y: 0 },
    { x: w + (2 * h) / 6, y: 0 },
    { x: w - h / 6, y: -h },
    { x: h / 6, y: -h }
  ];
  const shapeSvg = insertPolygonShape(parent, w, h, points);
  node.intersect = function(point) {
    return dagreD3.intersect.polygon(node, points, point);
  };
  return shapeSvg;
}

function inv_trapezoid(parent, bbox, node) {
  const w = bbox.width;
  const h = bbox.height;
  const points = [
    { x: h / 6, y: 0 },
    { x: w - h / 6, y: 0 },
    { x: w + (2 * h) / 6, y: -h },
    { x: (-2 * h) / 6, y: -h }
  ];
  const shapeSvg = insertPolygonShape(parent, w, h, points);
  node.intersect = function(point) {
    return dagreD3.intersect.polygon(node, points, point);
  };
  return shapeSvg;
}

function rect_right_inv_arrow(parent, bbox, node) {
  const w = bbox.width;
  const h = bbox.height;
  const points = [
    { x: 0, y: 0 },
    { x: w + h / 2, y: 0 },
    { x: w, y: -h / 2 },
    { x: w + h / 2, y: -h },
    { x: 0, y: -h }
  ];
  const shapeSvg = insertPolygonShape(parent, w, h, points);
  node.intersect = function(point) {
    return dagreD3.intersect.polygon(node, points, point);
  };
  return shapeSvg;
}

function stadium(parent, bbox, node) {
  const h = bbox.height;
  const w = bbox.width + h / 4;

  const shapeSvg = parent
    .insert('rect', ':first-child')
    .attr('rx', h / 2)
    .attr('ry', h / 2)
    .attr('x', -w / 2)
    .attr('y', -h / 2)
    .attr('width', w)
    .attr('height', h);

  node.intersect = function(point) {
    return dagreD3.intersect.rect(node, point);
  };
  return shapeSvg;
}

function cylinder(parent, bbox, node) {
  const w = bbox.width;
  const rx = w / 2;
  const ry = rx / (2.5 + w / 50);
  const h = bbox.height + ry;

  const shape =
    'M 0,' +
    ry +
    ' a ' +
    rx +
    ',' +
    ry +
    ' 0,0,0 ' +
    w +
    ' 0 a ' +
    rx +
    ',' +
    ry +
    ' 0,0,0 ' +
    -w +
    ' 0 l 0,' +
    h +
    ' a ' +
    rx +
    ',' +
    ry +
    ' 0,0,0 ' +
    w +
    ' 0 l 0,' +
    -h;

  const shapeSvg = parent
    .attr('label-offset-y', ry)
    .insert('path', ':first-child')
    .attr('d', shape)
    .attr('transform', 'translate(' + -w / 2 + ',' + -(h / 2 + ry) + ')');

  node.intersect = function(point) {
    const pos = dagreD3.intersect.rect(node, point);
    const x = pos.x - node.x;

    if (
      rx != 0 &&
      (Math.abs(x) < node.width / 2 ||
        (Math.abs(x) == node.width / 2 && Math.abs(pos.y - node.y) > node.height / 2 - ry))
    ) {
      // ellipsis equation: x*x / a*a + y*y / b*b = 1
      // solve for y to get adjustion value for pos.y
      let y = ry * ry * (1 - (x * x) / (rx * rx));
      if (y != 0) y = Math.sqrt(y);
      y = ry - y;
      if (point.y - node.y > 0) y = -y;

      pos.y += y;
    }

    return pos;
  };

  return shapeSvg;
}

export function addToRender(render) {
  render.shapes().question = question;
  render.shapes().hexagon = hexagon;
  render.shapes().stadium = stadium;
  render.shapes().cylinder = cylinder;

  // Add custom shape for box with inverted arrow on left side
  render.shapes().rect_left_inv_arrow = rect_left_inv_arrow;

  // Add custom shape for box with inverted arrow on left side
  render.shapes().lean_right = lean_right;

  // Add custom shape for box with inverted arrow on left side
  render.shapes().lean_left = lean_left;

  // Add custom shape for box with inverted arrow on left side
  render.shapes().trapezoid = trapezoid;

  // Add custom shape for box with inverted arrow on left side
  render.shapes().inv_trapezoid = inv_trapezoid;

  // Add custom shape for box with inverted arrow on right side
  render.shapes().rect_right_inv_arrow = rect_right_inv_arrow;
}

function insertPolygonShape(parent, w, h, points) {
  return parent
    .insert('polygon', ':first-child')
    .attr(
      'points',
      points
        .map(function(d) {
          return d.x + ',' + d.y;
        })
        .join(' ')
    )
    .attr('transform', 'translate(' + -w / 2 + ',' + h / 2 + ')');
}

export default {
  addToRender
};

1	import dagreD3 from 'dagre-d3';
2
3	function question(parent, bbox, node) {
4	const w = bbox.width;	3✔
5	const h = bbox.height;	3✔
6	const s = (w + h) * 0.9;	3✔
7	const points = [	3✔
8	{ x: s / 2, y: 0 },
9	{ x: s, y: -s / 2 },
10	{ x: s / 2, y: -s },
11	{ x: 0, y: -s / 2 }
12	];
13	const shapeSvg = insertPolygonShape(parent, s, s, points);	3✔
14	node.intersect = function(point) {	3✔
15	return dagreD3.intersect.polygon(node, points, point);	×
16	};
17	return shapeSvg;	3✔
18	}
19
20	function hexagon(parent, bbox, node) {
21	const f = 4;	3✔
22	const h = bbox.height;	3✔
23	const m = h / f;	3✔
24	const w = bbox.width + 2 * m;	3✔
25	const points = [	3✔
26	{ x: m, y: 0 },
27	{ x: w - m, y: 0 },
28	{ x: w, y: -h / 2 },
29	{ x: w - m, y: -h },
30	{ x: m, y: -h },
31	{ x: 0, y: -h / 2 }
32	];
33	const shapeSvg = insertPolygonShape(parent, w, h, points);	3✔
34	node.intersect = function(point) {	3✔
35	return dagreD3.intersect.polygon(node, points, point);	×
36	};
37	return shapeSvg;	3✔
38	}
39
40	function rect_left_inv_arrow(parent, bbox, node) {
41	const w = bbox.width;	3✔
42	const h = bbox.height;	3✔
43	const points = [	3✔
44	{ x: -h / 2, y: 0 },
45	{ x: w, y: 0 },
46	{ x: w, y: -h },
47	{ x: -h / 2, y: -h },
48	{ x: 0, y: -h / 2 }
49	];
50	const shapeSvg = insertPolygonShape(parent, w, h, points);	3✔
51	node.intersect = function(point) {	3✔
52	return dagreD3.intersect.polygon(node, points, point);	×
53	};
54	return shapeSvg;	3✔
55	}
56
57	function lean_right(parent, bbox, node) {
58	const w = bbox.width;	3✔
59	const h = bbox.height;	3✔
60	const points = [	3✔
61	{ x: (-2 * h) / 6, y: 0 },
62	{ x: w - h / 6, y: 0 },
63	{ x: w + (2 * h) / 6, y: -h },
64	{ x: h / 6, y: -h }
65	];
66	const shapeSvg = insertPolygonShape(parent, w, h, points);	3✔
67	node.intersect = function(point) {	3✔
68	return dagreD3.intersect.polygon(node, points, point);	×
69	};
70	return shapeSvg;	3✔
71	}
72
73	function lean_left(parent, bbox, node) {
74	const w = bbox.width;	3✔
75	const h = bbox.height;	3✔
76	const points = [	3✔
77	{ x: (2 * h) / 6, y: 0 },
78	{ x: w + h / 6, y: 0 },
79	{ x: w - (2 * h) / 6, y: -h },
80	{ x: -h / 6, y: -h }
81	];
82	const shapeSvg = insertPolygonShape(parent, w, h, points);	3✔
83	node.intersect = function(point) {	3✔
84	return dagreD3.intersect.polygon(node, points, point);	×
85	};
86	return shapeSvg;	3✔
87	}
88
89	function trapezoid(parent, bbox, node) {
90	const w = bbox.width;	3✔
91	const h = bbox.height;	3✔
92	const points = [	3✔
93	{ x: (-2 * h) / 6, y: 0 },
94	{ x: w + (2 * h) / 6, y: 0 },
95	{ x: w - h / 6, y: -h },
96	{ x: h / 6, y: -h }
97	];
98	const shapeSvg = insertPolygonShape(parent, w, h, points);	3✔
99	node.intersect = function(point) {	3✔
100	return dagreD3.intersect.polygon(node, points, point);	×
101	};
102	return shapeSvg;	3✔
103	}
104
105	function inv_trapezoid(parent, bbox, node) {
106	const w = bbox.width;	3✔
107	const h = bbox.height;	3✔
108	const points = [	3✔
109	{ x: h / 6, y: 0 },
110	{ x: w - h / 6, y: 0 },
111	{ x: w + (2 * h) / 6, y: -h },
112	{ x: (-2 * h) / 6, y: -h }
113	];
114	const shapeSvg = insertPolygonShape(parent, w, h, points);	3✔
115	node.intersect = function(point) {	3✔
116	return dagreD3.intersect.polygon(node, points, point);	×
117	};
118	return shapeSvg;	3✔
119	}
120
121	function rect_right_inv_arrow(parent, bbox, node) {
122	const w = bbox.width;	3✔
123	const h = bbox.height;	3✔
124	const points = [	3✔
125	{ x: 0, y: 0 },
126	{ x: w + h / 2, y: 0 },
127	{ x: w, y: -h / 2 },
128	{ x: w + h / 2, y: -h },
129	{ x: 0, y: -h }
130	];
131	const shapeSvg = insertPolygonShape(parent, w, h, points);	3✔
132	node.intersect = function(point) {	3✔
133	return dagreD3.intersect.polygon(node, points, point);	×
134	};
135	return shapeSvg;	3✔
136	}
137
138	function stadium(parent, bbox, node) {
139	const h = bbox.height;	3✔
140	const w = bbox.width + h / 4;	3✔
141
142	const shapeSvg = parent	3✔
143	.insert('rect', ':first-child')
144	.attr('rx', h / 2)
145	.attr('ry', h / 2)
146	.attr('x', -w / 2)
147	.attr('y', -h / 2)
148	.attr('width', w)
149	.attr('height', h);
150
151	node.intersect = function(point) {	3✔
152	return dagreD3.intersect.rect(node, point);	×
153	};
154	return shapeSvg;	3✔
155	}
156
157	function cylinder(parent, bbox, node) {
158	const w = bbox.width;	3✔
159	const rx = w / 2;	3✔
160	const ry = rx / (2.5 + w / 50);	3✔
161	const h = bbox.height + ry;	3✔
162
163	const shape =
164	'M 0,' +	3✔
165	ry +
166	' a ' +
167	rx +
168	',' +
169	ry +
170	' 0,0,0 ' +
171	w +
172	' 0 a ' +
173	rx +
174	',' +
175	ry +
176	' 0,0,0 ' +
177	-w +
178	' 0 l 0,' +
179	h +
180	' a ' +
181	rx +
182	',' +
183	ry +
184	' 0,0,0 ' +
185	w +
186	' 0 l 0,' +
187	-h;
188
189	const shapeSvg = parent	3✔
190	.attr('label-offset-y', ry)
191	.insert('path', ':first-child')
192	.attr('d', shape)
193	.attr('transform', 'translate(' + -w / 2 + ',' + -(h / 2 + ry) + ')');
194
195	node.intersect = function(point) {	3✔
NEW 196	const pos = dagreD3.intersect.rect(node, point);	×
NEW 197	const x = pos.x - node.x;	×
198
NEW 199	if (	×
200	rx != 0 &&	×
201	(Math.abs(x) < node.width / 2 \|\|
202	(Math.abs(x) == node.width / 2 && Math.abs(pos.y - node.y) > node.height / 2 - ry))
203	) {
204	// ellipsis equation: xx / aa + yy / bb = 1
205	// solve for y to get adjustion value for pos.y
NEW 206	let y = ry * ry * (1 - (x * x) / (rx * rx));	×
NEW 207	if (y != 0) y = Math.sqrt(y);	×
NEW 208	y = ry - y;	×
NEW 209	if (point.y - node.y > 0) y = -y;	×
210
NEW 211	pos.y += y;	×
212	}
213
NEW 214	return pos;	×
215	};
216
217	return shapeSvg;	3✔
218	}
219
220	export function addToRender(render) {
221	render.shapes().question = question;	10✔
222	render.shapes().hexagon = hexagon;	10✔
223	render.shapes().stadium = stadium;	10✔
224	render.shapes().cylinder = cylinder;	10✔
225
226	// Add custom shape for box with inverted arrow on left side
227	render.shapes().rect_left_inv_arrow = rect_left_inv_arrow;	10✔
228
229	// Add custom shape for box with inverted arrow on left side
230	render.shapes().lean_right = lean_right;	10✔
231
232	// Add custom shape for box with inverted arrow on left side
233	render.shapes().lean_left = lean_left;	10✔
234
235	// Add custom shape for box with inverted arrow on left side
236	render.shapes().trapezoid = trapezoid;	10✔
237
238	// Add custom shape for box with inverted arrow on left side
239	render.shapes().inv_trapezoid = inv_trapezoid;	10✔
240
241	// Add custom shape for box with inverted arrow on right side
242	render.shapes().rect_right_inv_arrow = rect_right_inv_arrow;	10✔
243	}
244
245	function insertPolygonShape(parent, w, h, points) {
246	return parent	24✔
247	.insert('polygon', ':first-child')
248	.attr(
249	'points',
250	points
251	.map(function(d) {
252	return d.x + ',' + d.y;	108✔
253	})
254	.join(' ')
255	)
256	.attr('transform', 'translate(' + -w / 2 + ',' + h / 2 + ')');
257	}
258
259	export default {
260	addToRender
261	};

mermaid-js / mermaid / 75e2abe24205a7ca564fd36138c8807e8777420d

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