3963897734

Build Type

github

Committed by GitHub

Commit Message

Merge 16044b998 into ecec6c403

Pull Request Pull Request #34: Typescript

Run Details

662 of 741 branches covered (89.34%)

Branch coverage included in aggregate %.

753 of 761 new or added lines in 9 files covered. (98.95%)

2 existing lines in 1 file now uncovered.

3586 of 3816 relevant lines covered (93.97%)

636.18 hits per line

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

97.47

/lib/driver.js

/* eslint-disable class-methods-use-this */
import * as ast from './ast.js'
import * as pjson from '../package.js'
import {Point, Position} from './point.js'
import l4js from 'log4js'
const log = l4js.getLogger()

export default class Driver {
  /**
   * @param {import('./ast.js').Diagram} diag
   * @param {import('./index.js').DrawOptions} argv
   */
  constructor(diag, argv) {
    this.diag = diag
    this.props = diag.props
    this.top = null
    this.argv = argv
    this.argv.property?.forEach(opt => {
      const [k, v] = opt.split('=').map(s => s.trim())

      /**
       * @type {string|boolean|number}
       */
      let value = v
      if (v === undefined || v === 'true') {
        value = true
      } else if (v === 'false') {
        value = false
      } else if (typeof diag.props[k] === 'number') {
        value = parseInt(v, 10)
        if (Number.isNaN(value)) {
          throw new Error(`"${v}" not a valid number, required for "${k}"`)
        }
      }
      diag.setProp(k, value)
    })

    this.width = this.columnx(diag.parts.length)
    this.height = this.timey(diag.max_time + 5)
  }

  /**
   * @abstract
   */
  clear() {
    // Default is a no-op
  }

  /**
   * @param {string} [name]
   * @returns {any} The group object, specific to driver type
   * @abstract
   */
  draw_group(name) {
    // Default is a no-op
  }

  /**
   * @param {Point} p The center of the text
   * @param {string} str The text
   * @param {string} klass Spaces-separated CSS classes
   * @param {number} [angle] Angle in radians
   * @abstract
   */
  draw_label(p, str, klass, angle) {
    // Default is a no-op
  }

  /**
   * Group some stuff together.  Everything created inside the callback is
   * inside the group.
   *
   * @param {string} name
   * @param {(group: any) => void} func
   */
  group(name, func) {
    const old = this.top
    this.top = this.draw_group(name)

    if (name) {
      log.debug('group:', name)
    }
    func.call(this, this.top)
    this.top = old
  }

  /**
   * Write out the metadata associated with this quence version.
   *
   * @param {typeof pjson} json
   * @abstract
   */
  meta(json) {
    // Pure virtual
    throw new Error('meta() not implemented')
  }

  /**
   * Add a link to the quence home page
   *
   * @param {typeof pjson} json
   * @abstract
   */
  home_link(json) {
    // Pure virtual
    throw new Error('home_link() not implemented')
  }

  /**
   * Draw the diagram to the given stream.
   *
   * @param {import('stream').Writable} outstream
   * @returns {import('stream').Writable} The same outstream
   */
  draw(outstream) {
    this.meta(pjson)
    if (!this.props.no_clear) {
      this.clear()
    }

    if (this.diag.title) {
      this.draw_label(
        new Position(this, (this.diag.parts.length - 1) / 2, -4),
        this.diag.title,
        'title'
      )
    }

    if (!this.props.no_link && !this.argv.nolink) {
      this.home_link(pjson)
    }

    this.group('participants', () => {
      this.diag.parts.forEach((part, i) => {
        this.group(`Paricipant: ${part.desc}`, () => {
          this.draw_label(new Position(this, part.col, -2), part.desc, 'rung_label')
          this.draw_line(
            new Position(this, part.col, -1),
            new Position(this, part.col, this.diag.max_time + 1),
            'rung'
          )
          if (!this.props.no_feet) {
            this.draw_label(
              new Position(this, part.col, this.diag.max_time + 3),
              part.desc,
              'rung_label'
            )
          }
        })
      }, this)
    })

    this.diag.data.forEach(x => {
      switch (x.kind) {
        case ast.Kind.SELF:
          this.draw_self_arrow(/** @type {ast.SelfMessage} */ (x))
          break
        case ast.Kind.MESSAGE:
          this.draw_arrow(/** @type {ast.Message} */ (x))
          break
        case ast.Kind.BLOCK:
          this.draw_block(/** @type {ast.Block} */ (x))
          break
        case ast.Kind.NOTE:
          this.draw_note(/** @type {ast.Note} */ (x))
          break
      }
    }, this)
    return outstream
  }

  /**
   * Get the x coordinate associated with a given column.
   *
   * @param {number} col
   * @returns {number} x
   */
  columnx(col) {
    // TODO: make left margin configurable
    return (col + 0.5) * this.diag.props.column_width
  }

  /**
   * Get the y coordinate associated with a given timestamp.  Negative numbers
   * are valid for headers, titile, etc.
   *
   * @param {number} time
   * @returns {number} x
   */
  timey(time) {
    // TODO: make top margin configurable
    return (time + 5) * this.diag.props.time_height
  }

  /**
   * @param {string|(string|Point)[]} cmds
   * @param {string} klasses
   * @virtual
   */
  draw_path(cmds, klasses) {
    let d = null
    if (typeof cmds === 'string') {
      d = cmds
    } else {
      d = cmds
        .map(c => {
          if (typeof c === 'string') {
            return c
          }
          return `${c.x} ${c.y}`
        })
        .join(' ')
    }
    return d
  }

  /**
   * Draw a line from p1 to p2.
   *
   * @param {Point} p1
   * @param {Point} p2
   * @param {string} klass CSS classes, space-separated
   */
  draw_line(p1, p2, klass) {
    this.draw_path(['M', p1, 'L', p2], klass)
  }

  /**
   * @param {ast.Block} block
   */
  draw_block(block) {
    const pad = ((block.depth + 1) * 5) + (this.props.rung_width / 2)
    const lt = new Position(this, 0, block.start).adjust(-pad, 0)
    this.group(`${block.typ}: ${block.msg}`, () => {
      this.draw_path(
        [
          'M',
          lt.adjust(0, -15),
          'L',
          lt.adjust(35, -15),
          'L',
          lt.adjust(35, 0),
          'L',
          lt,
          'Z',
        ],
        'block_tab'
      )

      this.draw_label(lt.adjust(5, -2), block.typ, 'start')

      if (block.msg) {
        this.draw_label(lt.adjust(40, -2), block.msg, 'start')
      }

      const right = this.diag.parts.length - 1
      this.draw_path(
        [
          'M',
          lt.adjust(0, -15),
          'L',
          lt.adjust(35, -15),
          'L',
          lt.adjust(35, 0),
          'L',
          new Position(this, right, block.start).adjust(pad, 0),
          'L',
          new Position(this, right, block.end).adjust(pad, 0),
          'L',
          new Position(this, 0, block.end).adjust(-pad, 0),
          'Z',
        ],
        'block'
      )
    })
  }

  /**
   * @param {ast.Note} note
   */
  draw_note(note) {
    const p = new Position(this, note.from)
    let adjust_dir = 1
    let align = 'start'

    if (note.from.col === this.diag.parts.length - 1) {
      adjust_dir = -1
      align = 'end'
    }

    this.draw_label(p.adjust(adjust_dir * (3 + (this.props.rung_width / 2)),
      this.diag.props.time_height / 4), note.msg, align)
  }

  /**
   * @param {ast.SelfMessage} start
   */
  draw_self_arrow(start) {
    const p1 = new Position(this, start.from)
    const p2 = new Position(this, start.to)
    let end = p2
    const self_width = this.props.column_width / 4
    const half_rung = this.props.rung_width / 2
    let begin_adj = 0
    let end_adj = 1
    if (start.arrow.begin) {
      begin_adj = 1
    }

    if (start.arrow.end === '#') {
      end = p2.adjust(self_width / 2, 0)
      end_adj *= 5
    }
    this.group(`message: ${start}`, () => {
      this.draw_path(
        [
          'M',
          p1.adjust(half_rung + begin_adj, 0),
          'L',
          p1.adjust(self_width, 0),
          'L',
          p2.adjust(self_width, 0),
          'L',
          end.adjust(half_rung + end_adj, 0),
        ],
        `${start.arrow.classes()} self`
      )

      this.arrow_head(end.adjust(half_rung, 0), Math.PI, start.arrow.end)
      if (start.arrow.begin) {
        this.arrow_head(p1.adjust(half_rung, 0), Math.PI, start.arrow.begin)
      }

      if (start.msg) {
        const text_anchor = Point.midpoint(p1, p2).adjust(
          self_width + this.props.label_space_x,
          -this.props.label_space_y
        )
        this.draw_label(text_anchor, start.msg, 'start')
      }
    })
  }

  /**
   * @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
   * @abstract
   */
  transform(x, y, theta, func) {
    // Pure virtual
    throw new Error('transform() not implemented')
  }

  /**
   * @param {Point} p Position of the point of the arrow
   * @param {number} theta Angle in Radians
   * @param {string} type Arrowhead type, e.g. ">"
   */
  arrow_head(p, theta, type) {
    this.transform(p.x, p.y, theta, () => {
      if (type === '>' || type === '<') {
        this.draw_path('M -10 4 L -1 0 L -10 -4 L -9 0 Z', 'closed')
      } else if (type === '#') {
        this.draw_path('M -10 4 L -1 -4', 'open')
        this.draw_path('M -10 -4 L -1 4', 'open')
      } else {
        this.draw_path('M -10 4 L -1 0 L -10 -4', 'open')
      }
    })
  }

  /**
   * @param {ast.Message} msg
   */
  draw_arrow(msg) {
    let p1 = new Position(this, msg.from)
    let p2 = new Position(this, msg.to)
    const half_rung = this.props.rung_width / 2

    let begin_adj = 0
    let end_adj = 0
    let end_angle = 0
    let text_anchor = null
    let text_align = ''
    const l2r = p2.col > p1.col

    if (msg.arrow.end === '#') {
      p2 = Point.midpoint(p1, p2)
    }

    // Bring each end of the line to the edge of the rung
    if (l2r) {
      // Left-to-right
      p1 = p1.adjust(half_rung, 0)
      p2 = p2.adjust(-half_rung, 0)
      end_adj = -1

      // Move over from the left a little
      text_align = 'start'
      text_anchor = p1.adjust(this.props.label_space_x, 0)
      end_angle = 0
    } else {
      // Right-to-left
      p1 = p1.adjust(-half_rung, 0)
      p2 = p2.adjust(half_rung, 0)
      end_adj = 1

      // Move over from the right a little
      text_align = 'end'
      text_anchor = p1.adjust(-this.props.label_space_x, 0)
      end_angle = Math.PI
    }
    if (msg.arrow.end === '#') {
      end_adj *= 5
    }

    if (msg.arrow.begin) {
      begin_adj = 1
      text_align = 'center'
      text_anchor = Point.midpoint(p1, p2)
    }

    const rangle = Point.angle(p1, p2)

    this.draw_line(
      p1.adjust(begin_adj * Math.cos(rangle), begin_adj * Math.sin(rangle)),
      p2.adjust(end_adj * Math.cos(rangle), end_adj * Math.sin(rangle)),
      msg.arrow.classes()
    )

    this.arrow_head(p2, rangle + end_angle, msg.arrow.end)

    if (msg.arrow.begin) {
      this.arrow_head(p1, rangle + Math.PI, msg.arrow.begin)
    }

    if (msg.msg) {
      // Ooch this up a few pixels, because baseline-offset doesn't work
      // anymore.  There's certainly a CSS way to do this.
      this.draw_label(text_anchor.adjust(0, -2), msg.msg, text_align, rangle)
    }
  }
}

1	/* eslint-disable class-methods-use-this */	16✔
2	import * as ast from './ast.js'	16✔
3	import * as pjson from '../package.js'	16✔
4	import {Point, Position} from './point.js'	16✔
5	import l4js from 'log4js'	16✔
6	const log = l4js.getLogger()	16✔
7		16✔
8	export default class Driver {	16✔
9	/**	16✔
10	* @param {import('./ast.js').Diagram} diag	16✔
11	* @param {import('./index.js').DrawOptions} argv	16✔
12	*/	16✔
13	constructor(diag, argv) {	16✔
14	this.diag = diag	32✔
15	this.props = diag.props	32✔
16	this.top = null	32✔
17	this.argv = argv	32✔
18	this.argv.property?.forEach(opt => {	32✔
19	const [k, v] = opt.split('=').map(s => s.trim())	8✔
20		8✔
21	/**	8✔
22	* @type {string\|boolean\|number}	8✔
23	*/	8✔
24	let value = v	8✔
25	if (v === undefined \|\| v === 'true') {	8!
26	value = true	×
27	} else if (v === 'false') {	8!
28	value = false	×
29	} else if (typeof diag.props[k] === 'number') {	8✔
30	value = parseInt(v, 10)	4✔
31	if (Number.isNaN(value)) {	4!
32	throw new Error(`"${v}" not a valid number, required for "${k}"`)	×
33	}	×
34	}	4✔
35	diag.setProp(k, value)	8✔
36	})	32✔
37		32✔
38	this.width = this.columnx(diag.parts.length)	32✔
39	this.height = this.timey(diag.max_time + 5)	32✔
40	}	32✔
41		16✔
42	/**	16✔
43	* @abstract	16✔
44	*/	16✔
45	clear() {	16✔
UNCOV 46	// Default is a no-op	×
UNCOV 47	}	×
48		16✔
49	/**	16✔
50	* @param {string} [name]	16✔
51	* @returns {any} The group object, specific to driver type	16✔
52	* @abstract	16✔
53	*/	16✔
54	draw_group(name) {	16✔
55	// Default is a no-op	92✔
56	}	92✔
57		16✔
58	/**	16✔
59	* @param {Point} p The center of the text	16✔
60	* @param {string} str The text	16✔
61	* @param {string} klass Spaces-separated CSS classes	16✔
62	* @param {number} [angle] Angle in radians	16✔
63	* @abstract	16✔
64	*/	16✔
65	draw_label(p, str, klass, angle) {	16✔
NEW 66	// Default is a no-op	×
NEW 67	}	×
68		16✔
69	/**	16✔
70	* Group some stuff together. Everything created inside the callback is	16✔
71	* inside the group.	16✔
72	*	16✔
73	* @param {string} name	16✔
74	* @param {(group: any) => void} func	16✔
75	*/	16✔
76	group(name, func) {	16✔
77	const old = this.top	644✔
78	this.top = this.draw_group(name)	644✔
79		644✔
80	if (name) {	644✔
81	log.debug('group:', name)	276✔
82	}	276✔
83	func.call(this, this.top)	644✔
84	this.top = old	644✔
85	}	644✔
86		16✔
87	/**	16✔
88	* Write out the metadata associated with this quence version.	16✔
89	*	16✔
90	* @param {typeof pjson} json	16✔
91	* @abstract	16✔
92	*/	16✔
93	meta(json) {	16✔
94	// Pure virtual	4✔
95	throw new Error('meta() not implemented')	4✔
96	}	4✔
97		16✔
98	/**	16✔
99	* Add a link to the quence home page	16✔
100	*	16✔
101	* @param {typeof pjson} json	16✔
102	* @abstract	16✔
103	*/	16✔
104	home_link(json) {	16✔
105	// Pure virtual	4✔
106	throw new Error('home_link() not implemented')	4✔
107	}	4✔
108		16✔
109	/**	16✔
110	* Draw the diagram to the given stream.	16✔
111	*	16✔
112	* @param {import('stream').Writable} outstream	16✔
113	* @returns {import('stream').Writable} The same outstream	16✔
114	*/	16✔
115	draw(outstream) {	16✔
116	this.meta(pjson)	12✔
117	if (!this.props.no_clear) {	12✔
118	this.clear()	12✔
119	}	12✔
120		12✔
121	if (this.diag.title) {	12✔
122	this.draw_label(	12✔
123	new Position(this, (this.diag.parts.length - 1) / 2, -4),	12✔
124	this.diag.title,	12✔
125	'title'	12✔
126	)	12✔
127	}	12✔
128		12✔
129	if (!this.props.no_link && !this.argv.nolink) {	12✔
130	this.home_link(pjson)	12✔
131	}	12✔
132		12✔
133	this.group('participants', () => {	12✔
134	this.diag.parts.forEach((part, i) => {	12✔
135	this.group(`Paricipant: ${part.desc}`, () => {	60✔
136	this.draw_label(new Position(this, part.col, -2), part.desc, 'rung_label')	60✔
137	this.draw_line(	60✔
138	new Position(this, part.col, -1),	60✔
139	new Position(this, part.col, this.diag.max_time + 1),	60✔
140	'rung'	60✔
141	)	60✔
142	if (!this.props.no_feet) {	60✔
143	this.draw_label(	60✔
144	new Position(this, part.col, this.diag.max_time + 3),	60✔
145	part.desc,	60✔
146	'rung_label'	60✔
147	)	60✔
148	}	60✔
149	})	60✔
150	}, this)	12✔
151	})	12✔
152		12✔
153	this.diag.data.forEach(x => {	12✔
154	switch (x.kind) {	720✔
155	case ast.Kind.SELF:	720✔
156	this.draw_self_arrow(/** @type {ast.SelfMessage} */ (x))	72✔
157	break	72✔
158	case ast.Kind.MESSAGE:	720✔
159	this.draw_arrow(/** @type {ast.Message} */ (x))	348✔
160	break	348✔
161	case ast.Kind.BLOCK:	720✔
162	this.draw_block(/** @type {ast.Block} */ (x))	132✔
163	break	132✔
164	case ast.Kind.NOTE:	720✔
165	this.draw_note(/** @type {ast.Note} */ (x))	24✔
166	break	24✔
167	}	720✔
168	}, this)	12✔
169	return outstream	12✔
170	}	12✔
171		16✔
172	/**	16✔
173	* Get the x coordinate associated with a given column.	16✔
174	*	16✔
175	* @param {number} col	16✔
176	* @returns {number} x	16✔
177	*/	16✔
178	columnx(col) {	16✔
179	// TODO: make left margin configurable	1,676✔
180	return (col + 0.5) * this.diag.props.column_width	1,676✔
181	}	1,676✔
182		16✔
183	/**	16✔
184	* Get the y coordinate associated with a given timestamp. Negative numbers	16✔
185	* are valid for headers, titile, etc.	16✔
186	*	16✔
187	* @param {number} time	16✔
188	* @returns {number} x	16✔
189	*/	16✔
190	timey(time) {	16✔
191	// TODO: make top margin configurable	1,676✔
192	return (time + 5) * this.diag.props.time_height	1,676✔
193	}	1,676✔
194		16✔
195	/**	16✔
196	* @param {string\|(string\|Point)[]} cmds	16✔
197	* @param {string} klasses	16✔
198	* @virtual	16✔
199	*/	16✔
200	draw_path(cmds, klasses) {	16✔
201	let d = null	1,380✔
202	if (typeof cmds === 'string') {	1,380✔
203	d = cmds	636✔
204	} else {	1,380✔
205	d = cmds	744✔
206	.map(c => {	744✔
207	if (typeof c === 'string') {	5,112✔
208	return c	2,688✔
209	}	2,688✔
210	return `${c.x} ${c.y}`	2,424✔
211	})	744✔
212	.join(' ')	744✔
213	}	744✔
214	return d	1,380✔
215	}	1,380✔
216		16✔
217	/**	16✔
218	* Draw a line from p1 to p2.	16✔
219	*	16✔
220	* @param {Point} p1	16✔
221	* @param {Point} p2	16✔
222	* @param {string} klass CSS classes, space-separated	16✔
223	*/	16✔
224	draw_line(p1, p2, klass) {	16✔
225	this.draw_path(['M', p1, 'L', p2], klass)	408✔
226	}	408✔
227		16✔
228	/**	16✔
229	* @param {ast.Block} block	16✔
230	*/	16✔
231	draw_block(block) {	16✔
232	const pad = ((block.depth + 1) * 5) + (this.props.rung_width / 2)	132✔
233	const lt = new Position(this, 0, block.start).adjust(-pad, 0)	132✔
234	this.group(`${block.typ}: ${block.msg}`, () => {	132✔
235	this.draw_path(	132✔
236	[	132✔
237	'M',	132✔
238	lt.adjust(0, -15),	132✔
239	'L',	132✔
240	lt.adjust(35, -15),	132✔
241	'L',	132✔
242	lt.adjust(35, 0),	132✔
243	'L',	132✔
244	lt,	132✔
245	'Z',	132✔
246	],	132✔
247	'block_tab'	132✔
248	)	132✔
249		132✔
250	this.draw_label(lt.adjust(5, -2), block.typ, 'start')	132✔
251		132✔
252	if (block.msg) {	132✔
253	this.draw_label(lt.adjust(40, -2), block.msg, 'start')	132✔
254	}	132✔
255		132✔
256	const right = this.diag.parts.length - 1	132✔
257	this.draw_path(	132✔
258	[	132✔
259	'M',	132✔
260	lt.adjust(0, -15),	132✔
261	'L',	132✔
262	lt.adjust(35, -15),	132✔
263	'L',	132✔
264	lt.adjust(35, 0),	132✔
265	'L',	132✔
266	new Position(this, right, block.start).adjust(pad, 0),	132✔
267	'L',	132✔
268	new Position(this, right, block.end).adjust(pad, 0),	132✔
269	'L',	132✔
270	new Position(this, 0, block.end).adjust(-pad, 0),	132✔
271	'Z',	132✔
272	],	132✔
273	'block'	132✔
274	)	132✔
275	})	132✔
276	}	132✔
277		16✔
278	/**	16✔
279	* @param {ast.Note} note	16✔
280	*/	16✔
281	draw_note(note) {	16✔
282	const p = new Position(this, note.from)	24✔
283	let adjust_dir = 1	24✔
284	let align = 'start'	24✔
285		24✔
286	if (note.from.col === this.diag.parts.length - 1) {	24✔
287	adjust_dir = -1	12✔
288	align = 'end'	12✔
289	}	12✔
290		24✔
291	this.draw_label(p.adjust(adjust_dir * (3 + (this.props.rung_width / 2)),	24✔
292	this.diag.props.time_height / 4), note.msg, align)	24✔
293	}	24✔
294		16✔
295	/**	16✔
296	* @param {ast.SelfMessage} start	16✔
297	*/	16✔
298	draw_self_arrow(start) {	16✔
299	const p1 = new Position(this, start.from)	72✔
300	const p2 = new Position(this, start.to)	72✔
301	let end = p2	72✔
302	const self_width = this.props.column_width / 4	72✔
303	const half_rung = this.props.rung_width / 2	72✔
304	let begin_adj = 0	72✔
305	let end_adj = 1	72✔
306	if (start.arrow.begin) {	72✔
307	begin_adj = 1	12✔
308	}	12✔
309		72✔
310	if (start.arrow.end === '#') {	72✔
311	end = p2.adjust(self_width / 2, 0)	24✔
312	end_adj *= 5	24✔
313	}	24✔
314	this.group(`message: ${start}`, () => {	72✔
315	this.draw_path(	72✔
316	[	72✔
317	'M',	72✔
318	p1.adjust(half_rung + begin_adj, 0),	72✔
319	'L',	72✔
320	p1.adjust(self_width, 0),	72✔
321	'L',	72✔
322	p2.adjust(self_width, 0),	72✔
323	'L',	72✔
324	end.adjust(half_rung + end_adj, 0),	72✔
325	],	72✔
326	`${start.arrow.classes()} self`	72✔
327	)	72✔
328		72✔
329	this.arrow_head(end.adjust(half_rung, 0), Math.PI, start.arrow.end)	72✔
330	if (start.arrow.begin) {	72✔
331	this.arrow_head(p1.adjust(half_rung, 0), Math.PI, start.arrow.begin)	12✔
332	}	12✔
333		72✔
334	if (start.msg) {	72✔
335	const text_anchor = Point.midpoint(p1, p2).adjust(	72✔
336	self_width + this.props.label_space_x,	72✔
337	-this.props.label_space_y	72✔
338	)	72✔
339	this.draw_label(text_anchor, start.msg, 'start')	72✔
340	}	72✔
341	})	72✔
342	}	72✔
343		16✔
344	/**	16✔
345	* @param {number} x	16✔
346	* @param {number} y	16✔
347	* @param {number} theta Angle in radians	16✔
348	* @param {() => void} func All of the things created in the func are	16✔
349	* transformed	16✔
350	* @abstract	16✔
351	*/	16✔
352	transform(x, y, theta, func) {	16✔
353	// Pure virtual	4✔
354	throw new Error('transform() not implemented')	4✔
355	}	4✔
356		16✔
357	/**	16✔
358	* @param {Point} p Position of the point of the arrow	16✔
359	* @param {number} theta Angle in Radians	16✔
360	* @param {string} type Arrowhead type, e.g. ">"	16✔
361	*/	16✔
362	arrow_head(p, theta, type) {	16✔
363	this.transform(p.x, p.y, theta, () => {	552✔
364	if (type === '>' \|\| type === '<') {	552✔
365	this.draw_path('M -10 4 L -1 0 L -10 -4 L -9 0 Z', 'closed')	300✔
366	} else if (type === '#') {	552✔
367	this.draw_path('M -10 4 L -1 -4', 'open')	84✔
368	this.draw_path('M -10 -4 L -1 4', 'open')	84✔
369	} else {	252✔
370	this.draw_path('M -10 4 L -1 0 L -10 -4', 'open')	168✔
371	}	168✔
372	})	552✔
373	}	552✔
374		16✔
375	/**	16✔
376	* @param {ast.Message} msg	16✔
377	*/	16✔
378	draw_arrow(msg) {	16✔
379	let p1 = new Position(this, msg.from)	348✔
380	let p2 = new Position(this, msg.to)	348✔
381	const half_rung = this.props.rung_width / 2	348✔
382		348✔
383	let begin_adj = 0	348✔
384	let end_adj = 0	348✔
385	let end_angle = 0	348✔
386	let text_anchor = null	348✔
387	let text_align = ''	348✔
388	const l2r = p2.col > p1.col	348✔
389		348✔
390	if (msg.arrow.end === '#') {	348✔
391	p2 = Point.midpoint(p1, p2)	60✔
392	}	60✔
393		348✔
394	// Bring each end of the line to the edge of the rung	348✔
395	if (l2r) {	348✔
396	// Left-to-right	240✔
397	p1 = p1.adjust(half_rung, 0)	240✔
398	p2 = p2.adjust(-half_rung, 0)	240✔
399	end_adj = -1	240✔
400		240✔
401	// Move over from the left a little	240✔
402	text_align = 'start'	240✔
403	text_anchor = p1.adjust(this.props.label_space_x, 0)	240✔
404	end_angle = 0	240✔
405	} else {	348✔
406	// Right-to-left	108✔
407	p1 = p1.adjust(-half_rung, 0)	108✔
408	p2 = p2.adjust(half_rung, 0)	108✔
409	end_adj = 1	108✔
410		108✔
411	// Move over from the right a little	108✔
412	text_align = 'end'	108✔
413	text_anchor = p1.adjust(-this.props.label_space_x, 0)	108✔
414	end_angle = Math.PI	108✔
415	}	108✔
416	if (msg.arrow.end === '#') {	348✔
417	end_adj *= 5	60✔
418	}	60✔
419		348✔
420	if (msg.arrow.begin) {	348✔
421	begin_adj = 1	120✔
422	text_align = 'center'	120✔
423	text_anchor = Point.midpoint(p1, p2)	120✔
424	}	120✔
425		348✔
426	const rangle = Point.angle(p1, p2)	348✔
427		348✔
428	this.draw_line(	348✔
429	p1.adjust(begin_adj * Math.cos(rangle), begin_adj * Math.sin(rangle)),	348✔
430	p2.adjust(end_adj * Math.cos(rangle), end_adj * Math.sin(rangle)),	348✔
431	msg.arrow.classes()	348✔
432	)	348✔
433		348✔
434	this.arrow_head(p2, rangle + end_angle, msg.arrow.end)	348✔
435		348✔
436	if (msg.arrow.begin) {	348✔
437	this.arrow_head(p1, rangle + Math.PI, msg.arrow.begin)	120✔
438	}	120✔
439		348✔
440	if (msg.msg) {	348✔
441	// Ooch this up a few pixels, because baseline-offset doesn't work	288✔
442	// anymore. There's certainly a CSS way to do this.	288✔
443	this.draw_label(text_anchor.adjust(0, -2), msg.msg, text_align, rangle)	288✔
444	}	288✔
445	}	348✔
446	}	16✔

hildjj / quence / 3963897734

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