3969508165

Build Type

github

Committed by GitHub

Commit Message

Merge f412cff1f into ecec6c403

Pull Request Pull Request #34: Typescript

Run Details

660 of 738 branches covered (89.43%)

Branch coverage included in aggregate %.

780 of 788 new or added lines in 9 files covered. (98.98%)

2 existing lines in 1 file now uncovered.

3575 of 3805 relevant lines covered (93.96%)

637.49 hits per line

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

97.01

/lib/PDFDriver.js

import Driver from './driver.js'
import PDF from 'pdfkit'
import {Point} from './point.js'
import l4js from 'log4js'
const log = l4js.getLogger()

export default class PDFDriver extends Driver {
  /**
   * @param {import('./ast.js').Diagram} diag
   * @param {import('./index.js').DrawOptions} argv
   */
  constructor(diag, argv) {
    super(diag, argv)
    const p = this.props
    this.styles = {
      text: {
        font: p.font,
        fontSize: p.text_size,
        fillColor: p.text_color,
      },
      title: {},
      rung_label: {},
      path: {
        strokeColor: p.line_color,
        lineWidth: p.line_width,
      },
      rung: {
        strokeColor: p.rung_color,
        lineWidth: p.rung_width,
      },
      start: {
        align: 'left',
      },
      end: {
        align: 'right',
      },
      center: {
        font: p.font,
        fontSize: p.text_size,
        fillColor: p.text_color,
        align: 'center',
      },
      open: {
        strokeColor: p.arrow_color,
        lineCap: 'round',
      },
      closed: {
        fillColor: p.arrow_color,
        strokeColor: p.arrow_color,
        drawStyle: 'fillAndStroke',
      },
      dashed: {
        dash: [6, {space: 2}],
      },
      solid: {
        undash: true,
      },
      block: {
        strokeColor: p.block_stroke,
        dash: [2, {space: 1}],
        lineJoin: 'round',
      },
      block_tab: {
        fill: p.block_tab_fill,
        drawStyle: 'fill',
      },
      closed_forward: {},
      open_forward: {},
      closed_back: {},
      open_back: {},
      self: {},
      link: {
        fillColor: 'blue',
        align: 'end',
      },
      version: {
        fillColor: p.text_color,
        align: 'end',
      },
    }

    this.path_count = 0
    this.doc = new PDF({size: [this.width, this.height]})
  }

  /**
   * Apply a css-like set of classes to the current document state
   *
   * @param  {String} klasses Space-separated list of class names
   * @return {object} Extra options that can't be set on doc, to
   *     apply to the draw routine that follows.
   */
  style(klasses) {
    const extras = {}
    if (klasses) {
      klasses.split(' ').forEach(klass => {
        const style = this.styles[klass]
        if (!style) {
          log.warn('Unknown class:', klass)
          return
        }
        Object.keys(style).forEach(key => {
          const val = style[key]
          if (key in this.doc) {
            if (Array.isArray(val)) {
              this.doc[key](...val)
            } else {
              this.doc[key](val)
            }
          } else {
            extras[key] = val
          }
        })
      })
    }
    return extras
  }

  /**
   * @param {import('stream').Writable} outstream
   * @returns {import('stream').Writable}
   */
  draw(outstream) {
    this.doc.pipe(outstream, {end: true})
    super.draw(outstream)
    this.doc.end()
    return outstream
  }

  clear() {
    this.doc.rect(0, 0, this.width, this.height).fill(this.props.background)
  }

  /**
   * @param {import('../package.js')} pjson
   */
  meta(pjson) {
    if (this.diag.title) {
      this.doc.info.Title = this.diag.title
    }
    this.doc.info.Creator = `${pjson.name}: ${pjson.homepage}`
  }

  /**
   * @param {import('../package.js')} pjson
   */
  home_link(pjson) {
    this.doc.save()
    let p = new Point(this.width, this.height).adjust(-5, -5)

    const wh = this.draw_string(p, `v${pjson.version}`, this.style('version'))
    p = p.adjust(-wh[0] - 3, 0)
    const extra = {
      ...this.style('link'),
      link: pjson.homepage,
      underline: 'blue',
      wordCount: 1,
      textWidth: this.doc.widthOfString(pjson.name),
    }
    this.draw_string(p, pjson.name, extra)
    this.doc.restore()
  }

  /**
   * @param {import('./point.js').Point} p Center bottom of the text
   * @param {string} str
   * @param {PDFKit.Mixins.TextOptions} opts
   * @returns {[number, number]} width, height
   */
  draw_string(p, str, opts = {}) {
    const align = opts.align || 'center'
    opts.lineBreak = false

    const w = this.doc.widthOfString(str)
    const h = this.doc.currentLineHeight()
    let dx = 0
    switch (align) {
      case 'center':
        dx = -w / 2
        break
      case 'end':
      case 'right':
        dx = -w
        break
    }
    p = p.adjust(dx, -h)

    this.doc.text(str, p.x, p.y, opts)
    if (opts.underline) {
      this.doc.underline(
        p.x,
        p.y,
        w,
        h,
        // @ts-ignore: go back and rethink PDF option type safety
        {color: opts.underline, ...opts}
      )
    }
    if (opts.link) {
      this.doc.link(p.x, p.y, w, h, opts.link)
    }
    return [w, h]
  }

  /**
   * @param {import('./point.js').Point} p Center
   * @param {string} str
   * @param {string} klasses
   * @param {number} theta
   */
  draw_label(p, str, klasses, theta) {
    if (!str || str.length === 0) {
      return
    }
    const angle = theta * 180 / Math.PI % 360
    this.doc.save()
    if (angle) {
      this.doc.rotate(angle, {origin: [p.x, p.y]})
    }
    this.draw_string(p, str, this.style(`text ${klasses}`))
    this.doc.restore()
  }

  /**
   * @param {number} x
   * @param {number} y
   * @param {number} theta Angle in radians
   * @param {() => void} func All of the things created in the func are
   *   transformed
   */
  transform(x, y, theta, func) {
    this.doc.save()
    if (x || y) {
      this.doc.translate(x, y)
    }
    if (theta) {
      // Clockwise in degrees
      const angle = theta * 180 / Math.PI % 360
      this.doc.rotate(angle, {origin: [0, 0]})
    }
    func.call(this)
    this.doc.restore()
  }

  /**
   * @param {string|(string|import('./point.js').Point)[]} cmds
   * @param {string} klasses
   */
  draw_path(cmds, klasses) {
    const d = super.draw_path(cmds, klasses)

    this.doc.save()
    const extra = this.style(`path ${klasses}`) || {}
    this.doc.path(d)
    switch (extra.drawStyle) {
      case 'fill':
        this.doc.fill()
        break
      case 'fillAndStroke':
        this.doc.fillAndStroke()
        break
      default:
        this.doc.stroke()
        break
    }
    this.doc.restore()
    return ''
  }
}

1	import Driver from './driver.js'	12✔
2	import PDF from 'pdfkit'	12✔
3	import {Point} from './point.js'	12✔
4	import l4js from 'log4js'	12✔
5	const log = l4js.getLogger()	12✔
6		12✔
7	export default class PDFDriver extends Driver {	12✔
8	/**	12✔
9	* @param {import('./ast.js').Diagram} diag	12✔
10	* @param {import('./index.js').DrawOptions} argv	12✔
11	*/	12✔
12	constructor(diag, argv) {	12✔
13	super(diag, argv)	4✔
14	const p = this.props	4✔
15	this.styles = {	4✔
16	text: {	4✔
17	font: p.font,	4✔
18	fontSize: p.text_size,	4✔
19	fillColor: p.text_color,	4✔
20	},	4✔
21	title: {},	4✔
22	rung_label: {},	4✔
23	path: {	4✔
24	strokeColor: p.line_color,	4✔
25	lineWidth: p.line_width,	4✔
26	},	4✔
27	rung: {	4✔
28	strokeColor: p.rung_color,	4✔
29	lineWidth: p.rung_width,	4✔
30	},	4✔
31	start: {	4✔
32	align: 'left',	4✔
33	},	4✔
34	end: {	4✔
35	align: 'right',	4✔
36	},	4✔
37	center: {	4✔
38	font: p.font,	4✔
39	fontSize: p.text_size,	4✔
40	fillColor: p.text_color,	4✔
41	align: 'center',	4✔
42	},	4✔
43	open: {	4✔
44	strokeColor: p.arrow_color,	4✔
45	lineCap: 'round',	4✔
46	},	4✔
47	closed: {	4✔
48	fillColor: p.arrow_color,	4✔
49	strokeColor: p.arrow_color,	4✔
50	drawStyle: 'fillAndStroke',	4✔
51	},	4✔
52	dashed: {	4✔
53	dash: [6, {space: 2}],	4✔
54	},	4✔
55	solid: {	4✔
56	undash: true,	4✔
57	},	4✔
58	block: {	4✔
59	strokeColor: p.block_stroke,	4✔
60	dash: [2, {space: 1}],	4✔
61	lineJoin: 'round',	4✔
62	},	4✔
63	block_tab: {	4✔
64	fill: p.block_tab_fill,	4✔
65	drawStyle: 'fill',	4✔
66	},	4✔
67	closed_forward: {},	4✔
68	open_forward: {},	4✔
69	closed_back: {},	4✔
70	open_back: {},	4✔
71	self: {},	4✔
72	link: {	4✔
73	fillColor: 'blue',	4✔
74	align: 'end',	4✔
75	},	4✔
76	version: {	4✔
77	fillColor: p.text_color,	4✔
78	align: 'end',	4✔
79	},	4✔
80	}	4✔
81		4✔
82	this.path_count = 0	4✔
83	this.doc = new PDF({size: [this.width, this.height]})	4✔
84	}	4✔
85		12✔
86	/**	12✔
87	* Apply a css-like set of classes to the current document state	12✔
88	*	12✔
89	* @param {String} klasses Space-separated list of class names	12✔
90	* @return {object} Extra options that can't be set on doc, to	12✔
91	* apply to the draw routine that follows.	12✔
92	*/	12✔
93	style(klasses) {	12✔
94	const extras = {}	728✔
95	if (klasses) {	728✔
96	klasses.split(' ').forEach(klass => {	728✔
97	const style = this.styles[klass]	1,628✔
98	if (!style) {	1,628!
99	log.warn('Unknown class:', klass)	×
100	return	×
101	}	×
102	Object.keys(style).forEach(key => {	1,628✔
103	const val = style[key]	2,964✔
104	if (key in this.doc) {	2,964✔
105	if (Array.isArray(val)) {	2,596✔
106	this.doc[key](...val)	88✔
107	} else {	2,596✔
108	this.doc[key](val)	2,508✔
109	}	2,508✔
110	} else {	2,964✔
111	extras[key] = val	368✔
112	}	368✔
113	})	1,628✔
114	})	728✔
115	}	728✔
116	return extras	728✔
117	}	728✔
118		12✔
119	/**	12✔
120	* @param {import('stream').Writable} outstream	12✔
121	* @returns {import('stream').Writable}	12✔
122	*/	12✔
123	draw(outstream) {	12✔
124	this.doc.pipe(outstream, {end: true})	4✔
125	super.draw(outstream)	4✔
126	this.doc.end()	4✔
127	return outstream	4✔
128	}	4✔
129		12✔
130	clear() {	12✔
131	this.doc.rect(0, 0, this.width, this.height).fill(this.props.background)	4✔
132	}	4✔
133		12✔
134	/**	12✔
135	* @param {import('../package.js')} pjson	12✔
136	*/	12✔
137	meta(pjson) {	12✔
138	if (this.diag.title) {	4✔
139	this.doc.info.Title = this.diag.title	4✔
140	}	4✔
141	this.doc.info.Creator = `${pjson.name}: ${pjson.homepage}`	4✔
142	}	4✔
143		12✔
144	/**	12✔
145	* @param {import('../package.js')} pjson	12✔
146	*/	12✔
147	home_link(pjson) {	12✔
148	this.doc.save()	4✔
149	let p = new Point(this.width, this.height).adjust(-5, -5)	4✔
150		4✔
151	const wh = this.draw_string(p, `v${pjson.version}`, this.style('version'))	4✔
152	p = p.adjust(-wh[0] - 3, 0)	4✔
153	const extra = {	4✔
154	...this.style('link'),	4✔
155	link: pjson.homepage,	4✔
156	underline: 'blue',	4✔
157	wordCount: 1,	4✔
158	textWidth: this.doc.widthOfString(pjson.name),	4✔
159	}	4✔
160	this.draw_string(p, pjson.name, extra)	4✔
161	this.doc.restore()	4✔
162	}	4✔
163		12✔
164	/**	12✔
165	* @param {import('./point.js').Point} p Center bottom of the text	12✔
166	* @param {string} str	12✔
167	* @param {PDFKit.Mixins.TextOptions} opts	12✔
168	* @returns {[number, number]} width, height	12✔
169	*/	12✔
170	draw_string(p, str, opts = {}) {	12✔
171	const align = opts.align \|\| 'center'	268✔
172	opts.lineBreak = false	268✔
173		268✔
174	const w = this.doc.widthOfString(str)	268✔
175	const h = this.doc.currentLineHeight()	268✔
176	let dx = 0	268✔
177	switch (align) {	268✔
178	case 'center':	268✔
179	dx = -w / 2	80✔
180	break	80✔
181	case 'end':	268✔
182	case 'right':	268✔
183	dx = -w	40✔
184	break	40✔
185	}	268✔
186	p = p.adjust(dx, -h)	268✔
187		268✔
188	this.doc.text(str, p.x, p.y, opts)	268✔
189	if (opts.underline) {	268✔
190	this.doc.underline(	4✔
191	p.x,	4✔
192	p.y,	4✔
193	w,	4✔
194	h,	4✔
195	// @ts-ignore: go back and rethink PDF option type safety	4✔
196	{color: opts.underline, ...opts}	4✔
197	)	4✔
198	}	4✔
199	if (opts.link) {	268✔
200	this.doc.link(p.x, p.y, w, h, opts.link)	4✔
201	}	4✔
202	return [w, h]	268✔
203	}	268✔
204		12✔
205	/**	12✔
206	* @param {import('./point.js').Point} p Center	12✔
207	* @param {string} str	12✔
208	* @param {string} klasses	12✔
209	* @param {number} theta	12✔
210	*/	12✔
211	draw_label(p, str, klasses, theta) {	12✔
212	if (!str \|\| str.length === 0) {	260!
NEW 213	return	×
214	}	×
215	const angle = theta * 180 / Math.PI % 360	260✔
216	this.doc.save()	260✔
217	if (angle) {	260✔
218	this.doc.rotate(angle, {origin: [p.x, p.y]})	8✔
219	}	8✔
220	this.draw_string(p, str, this.style(`text ${klasses}`))	260✔
221	this.doc.restore()	260✔
222	}	260✔
223		12✔
224	/**	12✔
225	* @param {number} x	12✔
226	* @param {number} y	12✔
227	* @param {number} theta Angle in radians	12✔
228	* @param {() => void} func All of the things created in the func are	12✔
229	* transformed	12✔
230	*/	12✔
231	transform(x, y, theta, func) {	12✔
232	this.doc.save()	184✔
233	if (x \|\| y) {	184!
234	this.doc.translate(x, y)	184✔
235	}	184✔
236	if (theta) {	184✔
237	// Clockwise in degrees	112✔
238	const angle = theta * 180 / Math.PI % 360	112✔
239	this.doc.rotate(angle, {origin: [0, 0]})	112✔
240	}	112✔
241	func.call(this)	184✔
242	this.doc.restore()	184✔
243	}	184✔
244		12✔
245	/**	12✔
246	* @param {string\|(string\|import('./point.js').Point)[]} cmds	12✔
247	* @param {string} klasses	12✔
248	*/	12✔
249	draw_path(cmds, klasses) {	12✔
250	const d = super.draw_path(cmds, klasses)	460✔
251		460✔
252	this.doc.save()	460✔
253	const extra = this.style(`path ${klasses}`) \|\| {}	460!
254	this.doc.path(d)	460✔
255	switch (extra.drawStyle) {	460✔
256	case 'fill':	460✔
257	this.doc.fill()	44✔
258	break	44✔
259	case 'fillAndStroke':	460✔
260	this.doc.fillAndStroke()	100✔
261	break	100✔
262	default:	460✔
263	this.doc.stroke()	316✔
264	break	316✔
265	}	460✔
266	this.doc.restore()	460✔
267	return ''	460✔
268	}	460✔
269	}	12✔

hildjj / quence / 3969508165

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