76e5c72b47722e67b4820d45df03cc1c7f2c5544-PR-1336

Build # 76e5c72b47722e67b4820d45df03cc1c7f2c5544-PR-1336

Build Type

github

Committed by GitHub

Commit Message

Merge d8eba411e into 9f8a0234a

Pull Request Pull Request #1336: #1290 Hide/style today marker in gantt diagram

Run Details

1668 of 3423 branches covered (48.73%)

Branch coverage included in aggregate %.

8 of 16 new or added lines in 3 files covered. (50.0%)

91 existing lines in 2 files now uncovered.

3676 of 7440 relevant lines covered (49.41%)

14905.09 hits per line

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

1.52

/src/diagrams/gantt/ganttRenderer.js

import * as d3 from 'd3';

import { parser } from './parser/gantt';
import ganttDb from './ganttDb';

parser.yy = ganttDb;

const conf = {
  titleTopMargin: 25,
  barHeight: 20,
  barGap: 4,
  topPadding: 50,
  rightPadding: 75,
  leftPadding: 75,
  gridLineStartPadding: 35,
  fontSize: 11,
  fontFamily: '"Open-Sans", "sans-serif"'
};
export const setConf = function(cnf) {
  const keys = Object.keys(cnf);

  keys.forEach(function(key) {
    conf[key] = cnf[key];
  });
};
let w;
export const draw = function(text, id) {
  parser.yy.clear();
  parser.parse(text);

  const elem = document.getElementById(id);
  w = elem.parentElement.offsetWidth;

  if (typeof w === 'undefined') {
    w = 1200;
  }

  if (typeof conf.useWidth !== 'undefined') {
    w = conf.useWidth;
  }

  const taskArray = parser.yy.getTasks();

  // Set height based on number of tasks
  const h = taskArray.length * (conf.barHeight + conf.barGap) + 2 * conf.topPadding;

  elem.setAttribute('height', '100%');
  // Set viewBox
  elem.setAttribute('viewBox', '0 0 ' + w + ' ' + h);
  const svg = d3.select(`[id="${id}"]`);

  // Set timescale
  const timeScale = d3
    .scaleTime()
    .domain([
      d3.min(taskArray, function(d) {
        return d.startTime;
      }),
      d3.max(taskArray, function(d) {
        return d.endTime;
      })
    ])
    .rangeRound([0, w - conf.leftPadding - conf.rightPadding]);

  let categories = [];

  for (let i = 0; i < taskArray.length; i++) {
    categories.push(taskArray[i].type);
  }

  const catsUnfiltered = categories; // for vert labels

  categories = checkUnique(categories);

  makeGant(taskArray, w, h);
  if (typeof conf.useWidth !== 'undefined') {
    elem.setAttribute('width', w);
  }

  svg
    .append('text')
    .text(parser.yy.getTitle())
    .attr('x', w / 2)
    .attr('y', conf.titleTopMargin)
    .attr('class', 'titleText');

  function makeGant(tasks, pageWidth, pageHeight) {
    const barHeight = conf.barHeight;
    const gap = barHeight + conf.barGap;
    const topPadding = conf.topPadding;
    const leftPadding = conf.leftPadding;

    const colorScale = d3
      .scaleLinear()
      .domain([0, categories.length])
      .range(['#00B9FA', '#F95002'])
      .interpolate(d3.interpolateHcl);

    makeGrid(leftPadding, topPadding, pageWidth, pageHeight);
    drawRects(tasks, gap, topPadding, leftPadding, barHeight, colorScale, pageWidth, pageHeight);
    vertLabels(gap, topPadding, leftPadding, barHeight, colorScale);
    drawToday(leftPadding, topPadding, pageWidth, pageHeight);
  }

  function drawRects(theArray, theGap, theTopPad, theSidePad, theBarHeight, theColorScale, w) {
    // Draw background rects covering the entire width of the graph, these form the section rows.
    svg
      .append('g')
      .selectAll('rect')
      .data(theArray)
      .enter()
      .append('rect')
      .attr('x', 0)
      .attr('y', function(d, i) {
        return i * theGap + theTopPad - 2;
      })
      .attr('width', function() {
        return w - conf.rightPadding / 2;
      })
      .attr('height', theGap)
      .attr('class', function(d) {
        for (let i = 0; i < categories.length; i++) {
          if (d.type === categories[i]) {
            return 'section section' + (i % conf.numberSectionStyles);
          }
        }
        return 'section section0';
      });

    // Draw the rects representing the tasks
    const rectangles = svg
      .append('g')
      .selectAll('rect')
      .data(theArray)
      .enter();

    rectangles
      .append('rect')
      .attr('id', function(d) {
        return d.id;
      })
      .attr('rx', 3)
      .attr('ry', 3)
      .attr('x', function(d) {
        if (d.milestone) {
          return (
            timeScale(d.startTime) +
            theSidePad +
            0.5 * (timeScale(d.endTime) - timeScale(d.startTime)) -
            0.5 * theBarHeight
          );
        }
        return timeScale(d.startTime) + theSidePad;
      })
      .attr('y', function(d, i) {
        return i * theGap + theTopPad;
      })
      .attr('width', function(d) {
        if (d.milestone) {
          return theBarHeight;
        }
        return timeScale(d.renderEndTime || d.endTime) - timeScale(d.startTime);
      })
      .attr('height', theBarHeight)
      .attr('transform-origin', function(d, i) {
        return (
          (
            timeScale(d.startTime) +
            theSidePad +
            0.5 * (timeScale(d.endTime) - timeScale(d.startTime))
          ).toString() +
          'px ' +
          (i * theGap + theTopPad + 0.5 * theBarHeight).toString() +
          'px'
        );
      })
      .attr('class', function(d) {
        const res = 'task';

        let classStr = '';
        if (d.classes.length > 0) {
          classStr = d.classes.join(' ');
        }

        let secNum = 0;
        for (let i = 0; i < categories.length; i++) {
          if (d.type === categories[i]) {
            secNum = i % conf.numberSectionStyles;
          }
        }

        let taskClass = '';
        if (d.active) {
          if (d.crit) {
            taskClass += ' activeCrit';
          } else {
            taskClass = ' active';
          }
        } else if (d.done) {
          if (d.crit) {
            taskClass = ' doneCrit';
          } else {
            taskClass = ' done';
          }
        } else {
          if (d.crit) {
            taskClass += ' crit';
          }
        }

        if (taskClass.length === 0) {
          taskClass = ' task';
        }

        if (d.milestone) {
          taskClass = ' milestone ' + taskClass;
        }

        taskClass += secNum;

        taskClass += ' ' + classStr;

        return res + taskClass;
      });

    // Append task labels
    rectangles
      .append('text')
      .attr('id', function(d) {
        return d.id + '-text';
      })
      .text(function(d) {
        return d.task;
      })
      .attr('font-size', conf.fontSize)
      .attr('x', function(d) {
        let startX = timeScale(d.startTime);
        let endX = timeScale(d.renderEndTime || d.endTime);
        if (d.milestone) {
          startX += 0.5 * (timeScale(d.endTime) - timeScale(d.startTime)) - 0.5 * theBarHeight;
        }
        if (d.milestone) {
          endX = startX + theBarHeight;
        }
        const textWidth = this.getBBox().width;

        // Check id text width > width of rectangle
        if (textWidth > endX - startX) {
          if (endX + textWidth + 1.5 * conf.leftPadding > w) {
            return startX + theSidePad - 5;
          } else {
            return endX + theSidePad + 5;
          }
        } else {
          return (endX - startX) / 2 + startX + theSidePad;
        }
      })
      .attr('y', function(d, i) {
        return i * theGap + conf.barHeight / 2 + (conf.fontSize / 2 - 2) + theTopPad;
      })
      .attr('text-height', theBarHeight)
      .attr('class', function(d) {
        const startX = timeScale(d.startTime);
        let endX = timeScale(d.endTime);
        if (d.milestone) {
          endX = startX + theBarHeight;
        }
        const textWidth = this.getBBox().width;

        let classStr = '';
        if (d.classes.length > 0) {
          classStr = d.classes.join(' ');
        }

        let secNum = 0;
        for (let i = 0; i < categories.length; i++) {
          if (d.type === categories[i]) {
            secNum = i % conf.numberSectionStyles;
          }
        }

        let taskType = '';
        if (d.active) {
          if (d.crit) {
            taskType = 'activeCritText' + secNum;
          } else {
            taskType = 'activeText' + secNum;
          }
        }

        if (d.done) {
          if (d.crit) {
            taskType = taskType + ' doneCritText' + secNum;
          } else {
            taskType = taskType + ' doneText' + secNum;
          }
        } else {
          if (d.crit) {
            taskType = taskType + ' critText' + secNum;
          }
        }

        if (d.milestone) {
          taskType += ' milestoneText';
        }

        // Check id text width > width of rectangle
        if (textWidth > endX - startX) {
          if (endX + textWidth + 1.5 * conf.leftPadding > w) {
            return classStr + ' taskTextOutsideLeft taskTextOutside' + secNum + ' ' + taskType;
          } else {
            return (
              classStr +
              ' taskTextOutsideRight taskTextOutside' +
              secNum +
              ' ' +
              taskType +
              ' width-' +
              textWidth
            );
          }
        } else {
          return classStr + ' taskText taskText' + secNum + ' ' + taskType + ' width-' + textWidth;
        }
      });
  }

  function makeGrid(theSidePad, theTopPad, w, h) {
    let xAxis = d3
      .axisBottom(timeScale)
      .tickSize(-h + theTopPad + conf.gridLineStartPadding)
      .tickFormat(d3.timeFormat(parser.yy.getAxisFormat() || conf.axisFormat || '%Y-%m-%d'));

    svg
      .append('g')
      .attr('class', 'grid')
      .attr('transform', 'translate(' + theSidePad + ', ' + (h - 50) + ')')
      .call(xAxis)
      .selectAll('text')
      .style('text-anchor', 'middle')
      .attr('fill', '#000')
      .attr('stroke', 'none')
      .attr('font-size', 10)
      .attr('dy', '1em');
  }

  function vertLabels(theGap, theTopPad) {
    const numOccurances = [];
    let prevGap = 0;

    for (let i = 0; i < categories.length; i++) {
      numOccurances[i] = [categories[i], getCount(categories[i], catsUnfiltered)];
    }

    svg
      .append('g') // without doing this, impossible to put grid lines behind text
      .selectAll('text')
      .data(numOccurances)
      .enter()
      .append(function(d) {
        const rows = d[0].split(/<br\s*\/?>/gi);
        const dy = -(rows.length - 1) / 2;

        const svgLabel = document.createElementNS('http://www.w3.org/2000/svg', 'text');
        svgLabel.setAttribute('dy', dy + 'em');

        for (let j = 0; j < rows.length; j++) {
          const tspan = document.createElementNS('http://www.w3.org/2000/svg', 'tspan');
          tspan.setAttribute('alignment-baseline', 'central');
          tspan.setAttribute('x', '10');
          if (j > 0) tspan.setAttribute('dy', '1em');
          tspan.textContent = rows[j];
          svgLabel.appendChild(tspan);
        }
        return svgLabel;
      })
      .attr('x', 10)
      .attr('y', function(d, i) {
        if (i > 0) {
          for (let j = 0; j < i; j++) {
            prevGap += numOccurances[i - 1][1];
            return (d[1] * theGap) / 2 + prevGap * theGap + theTopPad;
          }
        } else {
          return (d[1] * theGap) / 2 + theTopPad;
        }
      })
      .attr('class', function(d) {
        for (let i = 0; i < categories.length; i++) {
          if (d[0] === categories[i]) {
            return 'sectionTitle sectionTitle' + (i % conf.numberSectionStyles);
          }
        }
        return 'sectionTitle';
      });
  }

  function drawToday(theSidePad, theTopPad, w, h) {
    const todayMarker = ganttDb.getTodayMarker();
    if (todayMarker === 'off') {
      return;
    }

    const todayG = svg.append('g').attr('class', 'today');
    const today = new Date();
    const todayLine = todayG.append('line');

    todayLine
      .attr('x1', timeScale(today) + theSidePad)
      .attr('x2', timeScale(today) + theSidePad)
      .attr('y1', conf.titleTopMargin)
      .attr('y2', h - conf.titleTopMargin)
      .attr('class', 'today');

    if (todayMarker !== '') {
      todayLine.attr('style', todayMarker.replace(/,/g, ';'));
    }
  }

  // from this stackexchange question: http://stackoverflow.com/questions/1890203/unique-for-arrays-in-javascript
  function checkUnique(arr) {
    const hash = {};
    const result = [];
    for (let i = 0, l = arr.length; i < l; ++i) {
      if (!hash.hasOwnProperty(arr[i])) { // eslint-disable-line
        // it works with objects! in FF, at least
        hash[arr[i]] = true;
        result.push(arr[i]);
      }
    }
    return result;
  }

  // from this stackexchange question: http://stackoverflow.com/questions/14227981/count-how-many-strings-in-an-array-have-duplicates-in-the-same-array
  function getCounts(arr) {
    let i = arr.length; // const to loop over
    const obj = {}; // obj to store results
    while (i) {
      obj[arr[--i]] = (obj[arr[i]] || 0) + 1; // count occurrences
    }
    return obj;
  }

  // get specific from everything
  function getCount(word, arr) {
    return getCounts(arr)[word] || 0;
  }
};

export default {
  setConf,
  draw
};

1	import * as d3 from 'd3';
2
3	import { parser } from './parser/gantt';
4	import ganttDb from './ganttDb';
5
6	parser.yy = ganttDb;	4✔
7
8	const conf = {	4✔
9	titleTopMargin: 25,
10	barHeight: 20,
11	barGap: 4,
12	topPadding: 50,
13	rightPadding: 75,
14	leftPadding: 75,
15	gridLineStartPadding: 35,
16	fontSize: 11,
17	fontFamily: '"Open-Sans", "sans-serif"'
18	};
19	export const setConf = function(cnf) {	4✔
20	const keys = Object.keys(cnf);	×
21
22	keys.forEach(function(key) {	×
23	conf[key] = cnf[key];	×
24	});
25	};
26	let w;
27	export const draw = function(text, id) {	4✔
28	parser.yy.clear();	×
29	parser.parse(text);	×
30
31	const elem = document.getElementById(id);	×
32	w = elem.parentElement.offsetWidth;	×
33
34	if (typeof w === 'undefined') {	×
35	w = 1200;	×
36	}
37
38	if (typeof conf.useWidth !== 'undefined') {	×
39	w = conf.useWidth;	×
40	}
41
42	const taskArray = parser.yy.getTasks();	×
43
44	// Set height based on number of tasks
45	const h = taskArray.length * (conf.barHeight + conf.barGap) + 2 * conf.topPadding;	×
46
47	elem.setAttribute('height', '100%');	×
48	// Set viewBox
49	elem.setAttribute('viewBox', '0 0 ' + w + ' ' + h);	×
50	const svg = d3.select(`[id="${id}"]`);	×
51
52	// Set timescale
53	const timeScale = d3	×
54	.scaleTime()
55	.domain([
56	d3.min(taskArray, function(d) {
57	return d.startTime;	×
58	}),
59	d3.max(taskArray, function(d) {
60	return d.endTime;	×
61	})
62	])
63	.rangeRound([0, w - conf.leftPadding - conf.rightPadding]);
64
65	let categories = [];	×
66
67	for (let i = 0; i < taskArray.length; i++) {	×
68	categories.push(taskArray[i].type);	×
69	}
70
71	const catsUnfiltered = categories; // for vert labels	×
72
73	categories = checkUnique(categories);	×
74
75	makeGant(taskArray, w, h);	×
76	if (typeof conf.useWidth !== 'undefined') {	×
77	elem.setAttribute('width', w);	×
78	}
79
80	svg	×
81	.append('text')
82	.text(parser.yy.getTitle())
83	.attr('x', w / 2)
84	.attr('y', conf.titleTopMargin)
85	.attr('class', 'titleText');
86
87	function makeGant(tasks, pageWidth, pageHeight) {
88	const barHeight = conf.barHeight;	×
89	const gap = barHeight + conf.barGap;	×
90	const topPadding = conf.topPadding;	×
91	const leftPadding = conf.leftPadding;	×
92
93	const colorScale = d3	×
94	.scaleLinear()
95	.domain([0, categories.length])
96	.range(['#00B9FA', '#F95002'])
97	.interpolate(d3.interpolateHcl);
98
99	makeGrid(leftPadding, topPadding, pageWidth, pageHeight);	×
100	drawRects(tasks, gap, topPadding, leftPadding, barHeight, colorScale, pageWidth, pageHeight);	×
101	vertLabels(gap, topPadding, leftPadding, barHeight, colorScale);	×
102	drawToday(leftPadding, topPadding, pageWidth, pageHeight);	×
103	}
104
105	function drawRects(theArray, theGap, theTopPad, theSidePad, theBarHeight, theColorScale, w) {
106	// Draw background rects covering the entire width of the graph, these form the section rows.
107	svg	×
108	.append('g')
109	.selectAll('rect')
110	.data(theArray)
111	.enter()
112	.append('rect')
113	.attr('x', 0)
114	.attr('y', function(d, i) {
115	return i * theGap + theTopPad - 2;	×
116	})
117	.attr('width', function() {
118	return w - conf.rightPadding / 2;	×
119	})
120	.attr('height', theGap)
121	.attr('class', function(d) {
122	for (let i = 0; i < categories.length; i++) {	×
123	if (d.type === categories[i]) {	×
124	return 'section section' + (i % conf.numberSectionStyles);	×
125	}
126	}
127	return 'section section0';	×
128	});
129
130	// Draw the rects representing the tasks
131	const rectangles = svg	×
132	.append('g')
133	.selectAll('rect')
134	.data(theArray)
135	.enter();
136
137	rectangles	×
138	.append('rect')
139	.attr('id', function(d) {
140	return d.id;	×
141	})
142	.attr('rx', 3)
143	.attr('ry', 3)
144	.attr('x', function(d) {
145	if (d.milestone) {	×
146	return (	×
147	timeScale(d.startTime) +
148	theSidePad +
149	0.5 * (timeScale(d.endTime) - timeScale(d.startTime)) -
150	0.5 * theBarHeight
151	);
152	}
153	return timeScale(d.startTime) + theSidePad;	×
154	})
155	.attr('y', function(d, i) {
156	return i * theGap + theTopPad;	×
157	})
158	.attr('width', function(d) {
159	if (d.milestone) {	×
160	return theBarHeight;	×
161	}
162	return timeScale(d.renderEndTime \|\| d.endTime) - timeScale(d.startTime);	×
163	})
164	.attr('height', theBarHeight)
165	.attr('transform-origin', function(d, i) {
166	return (	×
167	(
168	timeScale(d.startTime) +
169	theSidePad +
170	0.5 * (timeScale(d.endTime) - timeScale(d.startTime))
171	).toString() +
172	'px ' +
173	(i * theGap + theTopPad + 0.5 * theBarHeight).toString() +
174	'px'
175	);
176	})
177	.attr('class', function(d) {
178	const res = 'task';	×
179
180	let classStr = '';	×
181	if (d.classes.length > 0) {	×
182	classStr = d.classes.join(' ');	×
183	}
184
185	let secNum = 0;	×
186	for (let i = 0; i < categories.length; i++) {	×
187	if (d.type === categories[i]) {	×
188	secNum = i % conf.numberSectionStyles;	×
189	}
190	}
191
192	let taskClass = '';	×
193	if (d.active) {	×
194	if (d.crit) {	×
195	taskClass += ' activeCrit';	×
196	} else {
197	taskClass = ' active';	×
198	}
199	} else if (d.done) {	×
200	if (d.crit) {	×
201	taskClass = ' doneCrit';	×
202	} else {
203	taskClass = ' done';	×
204	}
205	} else {
206	if (d.crit) {	×
207	taskClass += ' crit';	×
208	}
209	}
210
211	if (taskClass.length === 0) {	×
212	taskClass = ' task';	×
213	}
214
215	if (d.milestone) {	×
216	taskClass = ' milestone ' + taskClass;	×
217	}
218
219	taskClass += secNum;	×
220
221	taskClass += ' ' + classStr;	×
222
223	return res + taskClass;	×
224	});
225
226	// Append task labels
227	rectangles	×
228	.append('text')
229	.attr('id', function(d) {
230	return d.id + '-text';	×
231	})
232	.text(function(d) {
233	return d.task;	×
234	})
235	.attr('font-size', conf.fontSize)
236	.attr('x', function(d) {
237	let startX = timeScale(d.startTime);	×
238	let endX = timeScale(d.renderEndTime \|\| d.endTime);	×
239	if (d.milestone) {	×
240	startX += 0.5 * (timeScale(d.endTime) - timeScale(d.startTime)) - 0.5 * theBarHeight;	×
241	}
242	if (d.milestone) {	×
243	endX = startX + theBarHeight;	×
244	}
245	const textWidth = this.getBBox().width;	×
246
247	// Check id text width > width of rectangle
248	if (textWidth > endX - startX) {	×
249	if (endX + textWidth + 1.5 * conf.leftPadding > w) {	×
250	return startX + theSidePad - 5;	×
251	} else {
252	return endX + theSidePad + 5;	×
253	}
254	} else {
255	return (endX - startX) / 2 + startX + theSidePad;	×
256	}
257	})
258	.attr('y', function(d, i) {
259	return i * theGap + conf.barHeight / 2 + (conf.fontSize / 2 - 2) + theTopPad;	×
260	})
261	.attr('text-height', theBarHeight)
262	.attr('class', function(d) {
263	const startX = timeScale(d.startTime);	×
264	let endX = timeScale(d.endTime);	×
265	if (d.milestone) {	×
266	endX = startX + theBarHeight;	×
267	}
268	const textWidth = this.getBBox().width;	×
269
270	let classStr = '';	×
271	if (d.classes.length > 0) {	×
272	classStr = d.classes.join(' ');	×
273	}
274
275	let secNum = 0;	×
276	for (let i = 0; i < categories.length; i++) {	×
277	if (d.type === categories[i]) {	×
278	secNum = i % conf.numberSectionStyles;	×
279	}
280	}
281
282	let taskType = '';	×
283	if (d.active) {	×
284	if (d.crit) {	×
285	taskType = 'activeCritText' + secNum;	×
286	} else {
287	taskType = 'activeText' + secNum;	×
288	}
289	}
290
291	if (d.done) {	×
292	if (d.crit) {	×
293	taskType = taskType + ' doneCritText' + secNum;	×
294	} else {
295	taskType = taskType + ' doneText' + secNum;	×
296	}
297	} else {
298	if (d.crit) {	×
299	taskType = taskType + ' critText' + secNum;	×
300	}
301	}
302
303	if (d.milestone) {	×
304	taskType += ' milestoneText';	×
305	}
306
307	// Check id text width > width of rectangle
308	if (textWidth > endX - startX) {	×
309	if (endX + textWidth + 1.5 * conf.leftPadding > w) {	×
310	return classStr + ' taskTextOutsideLeft taskTextOutside' + secNum + ' ' + taskType;	×
311	} else {
312	return (	×
313	classStr +
314	' taskTextOutsideRight taskTextOutside' +
315	secNum +
316	' ' +
317	taskType +
318	' width-' +
319	textWidth
320	);
321	}
322	} else {
323	return classStr + ' taskText taskText' + secNum + ' ' + taskType + ' width-' + textWidth;	×
324	}
325	});
326	}
327
328	function makeGrid(theSidePad, theTopPad, w, h) {
329	let xAxis = d3	×
330	.axisBottom(timeScale)
331	.tickSize(-h + theTopPad + conf.gridLineStartPadding)
332	.tickFormat(d3.timeFormat(parser.yy.getAxisFormat() \|\| conf.axisFormat \|\| '%Y-%m-%d'));	×
333
334	svg	×
335	.append('g')
336	.attr('class', 'grid')
337	.attr('transform', 'translate(' + theSidePad + ', ' + (h - 50) + ')')
338	.call(xAxis)
339	.selectAll('text')
340	.style('text-anchor', 'middle')
341	.attr('fill', '#000')
342	.attr('stroke', 'none')
343	.attr('font-size', 10)
344	.attr('dy', '1em');
345	}
346
347	function vertLabels(theGap, theTopPad) {
348	const numOccurances = [];	×
349	let prevGap = 0;	×
350
351	for (let i = 0; i < categories.length; i++) {	×
352	numOccurances[i] = [categories[i], getCount(categories[i], catsUnfiltered)];	×
353	}
354
355	svg	×
356	.append('g') // without doing this, impossible to put grid lines behind text
357	.selectAll('text')
358	.data(numOccurances)
359	.enter()
360	.append(function(d) {
361	const rows = d[0].split(/<br\s*\/?>/gi);	×
362	const dy = -(rows.length - 1) / 2;	×
363
364	const svgLabel = document.createElementNS('http://www.w3.org/2000/svg', 'text');	×
365	svgLabel.setAttribute('dy', dy + 'em');	×
366
367	for (let j = 0; j < rows.length; j++) {	×
368	const tspan = document.createElementNS('http://www.w3.org/2000/svg', 'tspan');	×
369	tspan.setAttribute('alignment-baseline', 'central');	×
370	tspan.setAttribute('x', '10');	×
371	if (j > 0) tspan.setAttribute('dy', '1em');	×
372	tspan.textContent = rows[j];	×
373	svgLabel.appendChild(tspan);	×
374	}
375	return svgLabel;	×
376	})
377	.attr('x', 10)
378	.attr('y', function(d, i) {
379	if (i > 0) {	×
380	for (let j = 0; j < i; j++) {	×
381	prevGap += numOccurances[i - 1][1];	×
382	return (d[1] * theGap) / 2 + prevGap * theGap + theTopPad;	×
383	}
384	} else {
385	return (d[1] * theGap) / 2 + theTopPad;	×
386	}
387	})
388	.attr('class', function(d) {
389	for (let i = 0; i < categories.length; i++) {	×
390	if (d[0] === categories[i]) {	×
391	return 'sectionTitle sectionTitle' + (i % conf.numberSectionStyles);	×
392	}
393	}
394	return 'sectionTitle';	×
395	});
396	}
397
398	function drawToday(theSidePad, theTopPad, w, h) {
NEW 399	const todayMarker = ganttDb.getTodayMarker();	×
NEW 400	if (todayMarker === 'off') {	×
NEW 401	return;	×
402	}
403
NEW 404	const todayG = svg.append('g').attr('class', 'today');	×
UNCOV 405	const today = new Date();	×
NEW 406	const todayLine = todayG.append('line');	×
407
NEW 408	todayLine	×
409	.attr('x1', timeScale(today) + theSidePad)
410	.attr('x2', timeScale(today) + theSidePad)
411	.attr('y1', conf.titleTopMargin)
412	.attr('y2', h - conf.titleTopMargin)
413	.attr('class', 'today');
414
NEW 415	if (todayMarker !== '') {	×
NEW 416	todayLine.attr('style', todayMarker.replace(/,/g, ';'));	×
417	}
418	}
419
420	// from this stackexchange question: http://stackoverflow.com/questions/1890203/unique-for-arrays-in-javascript
421	function checkUnique(arr) {
422	const hash = {};	×
423	const result = [];	×
424	for (let i = 0, l = arr.length; i < l; ++i) {	×
425	if (!hash.hasOwnProperty(arr[i])) { // eslint-disable-line	×
426	// it works with objects! in FF, at least
427	hash[arr[i]] = true;	×
428	result.push(arr[i]);	×
429	}
430	}
431	return result;	×
432	}
433
434	// from this stackexchange question: http://stackoverflow.com/questions/14227981/count-how-many-strings-in-an-array-have-duplicates-in-the-same-array
435	function getCounts(arr) {
436	let i = arr.length; // const to loop over	×
437	const obj = {}; // obj to store results	×
438	while (i) {	×
439	obj[arr[--i]] = (obj[arr[i]] \|\| 0) + 1; // count occurrences	×
440	}
441	return obj;	×
442	}
443
444	// get specific from everything
445	function getCount(word, arr) {
446	return getCounts(arr)[word] \|\| 0;	×
447	}
448	};
449
450	export default {
451	setConf,
452	draw
453	};

mermaid-js / mermaid / 76e5c72b47722e67b4820d45df03cc1c7f2c5544-PR-1336

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