10710202893

Committed 04 Sep 2024 10:04PM UTC coverage: 31.854% (-0.02%) from 31.878%

Build # 10710202893

Build Type

Pull #9701

github

Committed by

b0b3rt

Commit Message

go back to resolverArgs in input

Pull Request Pull Request #9701: fix graphql resolver args

Run Details

5025 of 41185 branches covered (12.2%)

Branch coverage included in aggregate %.

11 of 21 new or added lines in 7 files covered. (52.38%)

610 existing lines in 24 files now uncovered.

29353 of 66740 relevant lines covered (43.98%)

187.82 hits per line

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

62.03

/packages/lesswrong/lib/tableOfContents.ts

import { commentsTableOfContentsEnabled } from "./betas";
import * as _ from 'underscore';
import { answerTocExcerptFromHTML, truncate } from "./editor/ellipsize";
import { htmlToTextDefault } from "./htmlToText";
import type { WindowType } from "./domParser";
import { PostWithCommentCounts, postGetCommentCountStr } from "./collections/posts/helpers";
import { isLWorAF } from "./instanceSettings";

export interface ToCAnswer {
  baseScore: number,
  voteCount: number,
  postedAt: Date | string, // Date on server, string on client
  author: string | null,
  highlight: string,
  shortHighlight: string,
}

export interface AnchorOffset {
  anchorHref: string | null,
  offset: number
}

export interface ToCSection {
  title?: string,
  answer?: ToCAnswer,
  anchor: string,
  level: number,
  divider?: boolean,
  offset?: number,
}

export interface ToCSectionWithOffset extends ToCSection {
  offset: number,
}

export interface ToCData {
  html: string | null,
  sections: ToCSection[],
}

// Number of headings below which a table of contents won't be generated.
// If comments-ToC is enabled, this is 0 because we need a post-ToC (even if
// it's empty) to keep the horizontal position of things on the page from
// being imbalanced.
const MIN_HEADINGS_FOR_TOC = commentsTableOfContentsEnabled ? 0 : 1;

// Tags which define headings. Currently <h1>-<h4>, <strong>, and <b>. Excludes
// <h5> and <h6> because their usage in historical (HTML) wasn't as a ToC-
// worthy heading.
const headingTags = {
  h1: 1,
  h2: 2,
  h3: 3,
  h4: 4,
  // <b> and <strong> are at the same level
  strong: 7,
  b: 7,
}

const headingIfWholeParagraph = {
  strong: true,
  b: true,
};

const headingSelector = _.keys(headingTags).join(",");

/**
 * Given an HTML document, extract a list of sections for a table of contents
 * from it, and add anchors. The result is modified HTML with added anchors,
 * plus a JSON array of sections, where each section has a
 * `title`, `anchor`, and `level`, like this:
 *   {
 *     html: "<a anchor=...">,
 *     sections: [
 *       {title: "Preamble", anchor: "preamble", level: 1},
 *       {title: "My Cool Idea", anchor: "mycoolidea", level: 1},
 *         {title: "An Aspect of My Cool Idea", anchor:"anaspectofmycoolidea", level: 2},
 *         {title: "Why This Is Neat", anchor:"whythisisneat", level: 2},
 *       {title: "Conclusion", anchor: "conclusion", level: 1},
 *     ]
 *   }
 */
export function extractTableOfContents({
  document,
  window,
}: {
  document: Document;
  window: WindowType;
}): ToCData | null {
  if (!document.body.innerHTML) return null;

  let headings: Array<ToCSection> = [];
  let usedAnchors: Record<string, boolean> = {};

  // First, find the headings in the document, create a linear list of them,
  // and insert anchors at each one.
  let headingElements = document.querySelectorAll(headingSelector);
  for (const element of Array.from(headingElements)) {
    if (!(element instanceof window.HTMLElement)) {
      continue;
    }
    let tagName = element.tagName.toLowerCase();
    if (tagIsHeadingIfWholeParagraph(tagName) && !tagIsWholeParagraph({ element, window })) {
      continue;
    }

    // Get title from element text
    let title = elementToToCTitle(element);
    // Cap the length at 300 chars
    if (title.length > 300) {
      title = title.substring(0, 300) + '...';
    }

    if (title && title.trim() !== "") {
      let anchor = titleToAnchor(title, usedAnchors);
      usedAnchors[anchor] = true;
      element.id = anchor;
      headings.push({
        title: title,
        anchor: anchor,
        level: tagToHeadingLevel(tagName),
      });
    }
  }

  // Filter out unused heading levels, mapping the heading levels to consecutive
  // numbers starting from 1.
  let headingLevelsUsedDict: Partial<Record<number, boolean>> = {};
  for (const heading of headings) {
    headingLevelsUsedDict[heading.level] = true;
  }

  let headingLevelsUsed = Object.keys(headingLevelsUsedDict).map(Number).sort();
  let headingLevelMap: Record<number, number> = {};
  for (const [i, level] of headingLevelsUsed.entries()) {
    headingLevelMap[level] = i + 1;
  }

  for (const heading of headings) {
    heading.level = headingLevelMap[heading.level];
  }

  if (headings.length) {
    headings.push({ divider: true, level: 0, anchor: "postHeadingsDivider" });
  }

  return {
    html: document.body.innerHTML,
    sections: headings,
  };
}

/**
 * Generate a (string) section heading from a heading element. This means
 * taking text from text nodes (with element.textContent), except with a
 * special case to make sure `<style>` nodes aren't included. This comes up
 * if the MathJax stylesheet happens to be in the same block as the heading,
 * which happens if the heading contains the first usage of LaTeX in the post.
 * (eg: https://www.lesswrong.com/s/Gmc7vtnpyKZRHWdt5/p/tCex9F9YptGMpk2sT)
 */
function elementToToCTitle(element: HTMLElement): string {
  // Check whether there's a <style> element. Usually there isn't.
  const styleSelector = element.querySelector("style");
  if (styleSelector) {
    // If there's a <style>, clone the subtree, then remove style nodes from the clone
    const elementClone: HTMLElement = element.cloneNode(true) as HTMLElement; //pass true to make the copy be deep
    const cloneStyleSelector = elementClone.querySelectorAll("style");
    cloneStyleSelector.forEach(i => i.remove());
    return elementClone.textContent ?? "";
  } else {
    return element.textContent ?? "";
  }
}

type CommentType = CommentsList | DbComment
export function getTocAnswers({ post, answers }: { post: { question: boolean }; answers: CommentType[] }) {
  if (!post.question) return []

  const answerSections: ToCSection[] = answers.map((answer: CommentType): ToCSection => {
    const { html = "" } = answer.contents || {};
    const highlight = truncate(html, 900);
    let shortHighlight = htmlToTextDefault(answerTocExcerptFromHTML(html));
    const author = ("user" in answer ? answer.user?.displayName : answer.author) ?? null;

    return {
      title: `${answer.baseScore} ${author}`,
      answer: {
        baseScore: answer.baseScore,
        voteCount: answer.voteCount,
        postedAt: answer.postedAt,
        author: author,
        highlight,
        shortHighlight,
      },
      anchor: answer._id,
      level: 2,
    };
  });

  if (answerSections.length) {
    return [
      { anchor: "answers", level: 1, title: "Answers" },
      ...answerSections,
      { divider: true, level: 0, anchor: "postAnswersDivider" },
    ];
  } else {
    return [];
  }
}

export function getTocComments({
  post,
  commentCount,
}: { post?: PostWithCommentCounts | null; commentCount?: number | undefined } = {}) {
  return [{ anchor: "comments", level: 0, title: postGetCommentCountStr(post, commentCount) }];
}

export function shouldShowTableOfContents({
  sections,
  post,
}: {
  sections: ToCSection[];
  post?: { question: boolean } | null;
}): boolean {
  
  if (isLWorAF) return true;
  return sections.length > MIN_HEADINGS_FOR_TOC || (post?.question ?? false);
}

/**
 * `<b>` and `<strong>` tags are considered headings if and only if they are the only element within their paragraph.
 */
function tagIsWholeParagraph({ element, window }: { element: HTMLElement; window: WindowType }): boolean {
  if (!(element instanceof window.HTMLElement)) {
    throw new Error("element must be HTMLElement");
  }

  const parent = element.parentNode;
  if (!parent) {
    return false;
  }

  // Check if the element is the only significant content within the paragraph
  const selfAndSiblings = Array.from(parent.childNodes);
  // TODO only count as an alien if there is text content in a sibling that is not under a <strong> tag
  // E.g. in <p><strong>Visit our </strong><a href="..."><strong>website</strong></a> the whole thing
  // should count as a heading because it's a continuous block of bold text making up a full paragraph.
  // Supporting this naturally would require refactoring for this function to be paragraph level, rather than
  // tag-level (as the two <strongs> in the above example would currently trigger separate invokations).
  const alienFound = selfAndSiblings.some((sibling) => {
    if (sibling.nodeType === window.Node.ELEMENT_NODE && sibling !== element) {
      const siblingElement = sibling as HTMLElement;
      // Check if the sibling is of a different type
      if (siblingElement.tagName !== element.tagName) {
        return true;
      }
      // Check if the sibling contains significant text that is not part of the element
      if (siblingElement.textContent?.trim() && !element.contains(siblingElement)) {
        return true;
      }
    } else if (sibling.nodeType === window.Node.TEXT_NODE && sibling.textContent?.trim()) {
      // Check if it's a text node with non-whitespace content
      return true;
    }
    return false;
  });

  // If an alien element was found, it's not a whole paragraph tag
  if (alienFound) {
    return false;
  }

  // Ensure that all the text in the paragraph is within elements of the same type as our element
  const para = element.closest('p');
  return !!para && para.textContent?.trim() === element.textContent?.trim();
};

/**
 * `<b>` and `<strong>` tags are headings iff they are the only thing in their
 * paragraph. Return whether the given tag name is a tag with that property
 * (ie, is `<strong>` or `<b>`).
 * See tagIsWholeParagraph
 */
function tagIsHeadingIfWholeParagraph(tagName: string): boolean
{
  return tagName.toLowerCase() in headingIfWholeParagraph;
}

const reservedAnchorNames = ["top", "comments"];

/**
 * Given the text in a heading block and a dict of anchors that have been used
 * in the post so far, generate an anchor, and return it. An anchor is a
 * URL-safe string that can be used for within-document links, and which is
 * not one of a few reserved anchor names.
 */
function titleToAnchor(title: string, usedAnchors: Record<string,boolean>): string
{
  let charsToUse = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789";
  let sb: Array<string> = [];

  for(let i=0; i<title.length; i++) {
    let ch = title.charAt(i);
    if(charsToUse.indexOf(ch) >= 0) {
      sb.push(ch);
    } else {
      sb.push('_');
    }
  }

  let anchor = sb.join('');
  if(!usedAnchors[anchor] && !_.find(reservedAnchorNames, x=>x===anchor))
    return anchor;

  let anchorSuffix = 1;
  while(usedAnchors[anchor + anchorSuffix])
    anchorSuffix++;
  return anchor+anchorSuffix;
}

function tagToHeadingLevel(tagName: string): number
{
  let lowerCaseTagName = tagName.toLowerCase();
  if (lowerCaseTagName in headingTags)
    return headingTags[lowerCaseTagName as keyof typeof headingTags];
  else if (lowerCaseTagName in headingIfWholeParagraph)
    // Comment below from Robert, ported from server/tableOfContents:
    // TODO: this seems wrong??? It's returning a boolean when it should be returning a number
    // @ts-ignore
    return headingIfWholeParagraph[lowerCaseTagName as keyof typeof headingIfWholeParagraph];
  else
    return 0;
}

1	import { commentsTableOfContentsEnabled } from "./betas";	77✔
2	import * as _ from 'underscore';	21✔
3	import { answerTocExcerptFromHTML, truncate } from "./editor/ellipsize";	21✔
4	import { htmlToTextDefault } from "./htmlToText";	21✔
5	import type { WindowType } from "./domParser";
6	import { PostWithCommentCounts, postGetCommentCountStr } from "./collections/posts/helpers";	21✔
7	import { isLWorAF } from "./instanceSettings";	21✔
8
9	export interface ToCAnswer {
10	baseScore: number,
11	voteCount: number,
12	postedAt: Date \| string, // Date on server, string on client
13	author: string \| null,
14	highlight: string,
15	shortHighlight: string,
16	}
17
18	export interface AnchorOffset {
19	anchorHref: string \| null,
20	offset: number
21	}
22
23	export interface ToCSection {
24	title?: string,
25	answer?: ToCAnswer,
26	anchor: string,
27	level: number,
28	divider?: boolean,
29	offset?: number,
30	}
31
32	export interface ToCSectionWithOffset extends ToCSection {
33	offset: number,
34	}
35
36	export interface ToCData {
37	html: string \| null,
38	sections: ToCSection[],
39	}
40
41	// Number of headings below which a table of contents won't be generated.
42	// If comments-ToC is enabled, this is 0 because we need a post-ToC (even if
43	// it's empty) to keep the horizontal position of things on the page from
44	// being imbalanced.
45	const MIN_HEADINGS_FOR_TOC = commentsTableOfContentsEnabled ? 0 : 1;	21!
46
47	// Tags which define headings. Currently <h1>-<h4>, <strong>, and <b>. Excludes
48	// <h5> and <h6> because their usage in historical (HTML) wasn't as a ToC-
49	// worthy heading.
50	const headingTags = {	21✔
51	h1: 1,
52	h2: 2,
53	h3: 3,
54	h4: 4,
55	// <b> and <strong> are at the same level
56	strong: 7,
57	b: 7,
58	}
59
60	const headingIfWholeParagraph = {	21✔
61	strong: true,
62	b: true,
63	};
64
65	const headingSelector = _.keys(headingTags).join(",");	21✔
66
67	/**
68	* Given an HTML document, extract a list of sections for a table of contents
69	* from it, and add anchors. The result is modified HTML with added anchors,
70	* plus a JSON array of sections, where each section has a
71	* `title`, `anchor`, and `level`, like this:
72	* {
73	* html: "<a anchor=...">,
74	* sections: [
75	* {title: "Preamble", anchor: "preamble", level: 1},
76	* {title: "My Cool Idea", anchor: "mycoolidea", level: 1},
77	* {title: "An Aspect of My Cool Idea", anchor:"anaspectofmycoolidea", level: 2},
78	* {title: "Why This Is Neat", anchor:"whythisisneat", level: 2},
79	* {title: "Conclusion", anchor: "conclusion", level: 1},
80	* ]
81	* }
82	*/
83	export function extractTableOfContents({
84	document,
85	window,
86	}: {
87	document: Document;
88	window: WindowType;
89	}): ToCData \| null {
90	if (!document.body.innerHTML) return null;	14✔
91
92	let headings: Array<ToCSection> = [];	13✔
93	let usedAnchors: Record<string, boolean> = {};	13✔
94
95	// First, find the headings in the document, create a linear list of them,
96	// and insert anchors at each one.
97	let headingElements = document.querySelectorAll(headingSelector);	13✔
98	for (const element of Array.from(headingElements)) {	13✔
99	if (!(element instanceof window.HTMLElement)) {	28!
UNCOV 100	continue;	×
101	}
102	let tagName = element.tagName.toLowerCase();	28✔
103	if (tagIsHeadingIfWholeParagraph(tagName) && !tagIsWholeParagraph({ element, window })) {	28✔
104	continue;	20✔
105	}
106
107	// Get title from element text
108	let title = elementToToCTitle(element);	8✔
109	// Cap the length at 300 chars
110	if (title.length > 300) {	8!
UNCOV 111	title = title.substring(0, 300) + '...';	×
112	}
113
114	if (title && title.trim() !== "") {	8!
115	let anchor = titleToAnchor(title, usedAnchors);	8✔
116	usedAnchors[anchor] = true;	8✔
117	element.id = anchor;	8✔
118	headings.push({	8✔
119	title: title,
120	anchor: anchor,
121	level: tagToHeadingLevel(tagName),
122	});
123	}
124	}
125
126	// Filter out unused heading levels, mapping the heading levels to consecutive
127	// numbers starting from 1.
128	let headingLevelsUsedDict: Partial<Record<number, boolean>> = {};	13✔
129	for (const heading of headings) {	13✔
130	headingLevelsUsedDict[heading.level] = true;	8✔
131	}
132
133	let headingLevelsUsed = Object.keys(headingLevelsUsedDict).map(Number).sort();	13✔
134	let headingLevelMap: Record<number, number> = {};	13✔
135	for (const [i, level] of headingLevelsUsed.entries()) {	13✔
136	headingLevelMap[level] = i + 1;	7✔
137	}
138
139	for (const heading of headings) {	13✔
140	heading.level = headingLevelMap[heading.level];	8✔
141	}
142
143	if (headings.length) {	13✔
144	headings.push({ divider: true, level: 0, anchor: "postHeadingsDivider" });	5✔
145	}
146
147	return {	13✔
148	html: document.body.innerHTML,
149	sections: headings,
150	};
151	}
152
153	/**
154	* Generate a (string) section heading from a heading element. This means
155	* taking text from text nodes (with element.textContent), except with a
156	* special case to make sure `<style>` nodes aren't included. This comes up
157	* if the MathJax stylesheet happens to be in the same block as the heading,
158	* which happens if the heading contains the first usage of LaTeX in the post.
159	* (eg: https://www.lesswrong.com/s/Gmc7vtnpyKZRHWdt5/p/tCex9F9YptGMpk2sT)
160	*/
161	function elementToToCTitle(element: HTMLElement): string {
162	// Check whether there's a <style> element. Usually there isn't.
163	const styleSelector = element.querySelector("style");	8✔
164	if (styleSelector) {	8!
165	// If there's a <style>, clone the subtree, then remove style nodes from the clone
UNCOV 166	const elementClone: HTMLElement = element.cloneNode(true) as HTMLElement; //pass true to make the copy be deep	×
UNCOV 167	const cloneStyleSelector = elementClone.querySelectorAll("style");	×
UNCOV 168	cloneStyleSelector.forEach(i => i.remove());	×
UNCOV 169	return elementClone.textContent ?? "";	×
170	} else {
171	return element.textContent ?? "";	8!
172	}
173	}
174
175	type CommentType = CommentsList \| DbComment
176	export function getTocAnswers({ post, answers }: { post: { question: boolean }; answers: CommentType[] }) {
UNCOV 177	if (!post.question) return []	×
178
UNCOV 179	const answerSections: ToCSection[] = answers.map((answer: CommentType): ToCSection => {	×
UNCOV 180	const { html = "" } = answer.contents \|\| {};	×
181	const highlight = truncate(html, 900);	×
182	let shortHighlight = htmlToTextDefault(answerTocExcerptFromHTML(html));	×
183	const author = ("user" in answer ? answer.user?.displayName : answer.author) ?? null;	×
184
UNCOV 185	return {	×
186	title: `${answer.baseScore} ${author}`,
187	answer: {
188	baseScore: answer.baseScore,
189	voteCount: answer.voteCount,
190	postedAt: answer.postedAt,
191	author: author,
192	highlight,
193	shortHighlight,
194	},
195	anchor: answer._id,
196	level: 2,
197	};
198	});
199
200	if (answerSections.length) {	×
UNCOV 201	return [	×
202	{ anchor: "answers", level: 1, title: "Answers" },
203	...answerSections,
204	{ divider: true, level: 0, anchor: "postAnswersDivider" },
205	];
206	} else {
UNCOV 207	return [];	×
208	}
209	}
210
211	export function getTocComments({
212	post,
213	commentCount,
214	}: { post?: PostWithCommentCounts \| null; commentCount?: number \| undefined } = {}) {	×
215	return [{ anchor: "comments", level: 0, title: postGetCommentCountStr(post, commentCount) }];	×
216	}
217
218	export function shouldShowTableOfContents({
219	sections,
220	post,
221	}: {
222	sections: ToCSection[];
223	post?: { question: boolean } \| null;
224	}): boolean {
225
UNCOV 226	if (isLWorAF) return true;	×
UNCOV 227	return sections.length > MIN_HEADINGS_FOR_TOC \|\| (post?.question ?? false);	×
228	}
229
230	/**
231	* `<b>` and `<strong>` tags are considered headings if and only if they are the only element within their paragraph.
232	*/
233	function tagIsWholeParagraph({ element, window }: { element: HTMLElement; window: WindowType }): boolean {
234	if (!(element instanceof window.HTMLElement)) {	23!
UNCOV 235	throw new Error("element must be HTMLElement");	×
236	}
237
238	const parent = element.parentNode;	23✔
239	if (!parent) {	23!
UNCOV 240	return false;	×
241	}
242
243	// Check if the element is the only significant content within the paragraph
244	const selfAndSiblings = Array.from(parent.childNodes);	23✔
245	// TODO only count as an alien if there is text content in a sibling that is not under a <strong> tag
246	// E.g. in <p><strong>Visit our </strong><a href="..."><strong>website</strong></a> the whole thing
247	// should count as a heading because it's a continuous block of bold text making up a full paragraph.
248	// Supporting this naturally would require refactoring for this function to be paragraph level, rather than
249	// tag-level (as the two <strongs> in the above example would currently trigger separate invokations).
250	const alienFound = selfAndSiblings.some((sibling) => {	23✔
251	if (sibling.nodeType === window.Node.ELEMENT_NODE && sibling !== element) {	30✔
252	const siblingElement = sibling as HTMLElement;	13✔
253	// Check if the sibling is of a different type
254	if (siblingElement.tagName !== element.tagName) {	13✔
255	return true;	10✔
256	}
257	// Check if the sibling contains significant text that is not part of the element
258	if (siblingElement.textContent?.trim() && !element.contains(siblingElement)) {	3!
259	return true;	2✔
260	}
261	} else if (sibling.nodeType === window.Node.TEXT_NODE && sibling.textContent?.trim()) {	17!
262	// Check if it's a text node with non-whitespace content
UNCOV 263	return true;	×
264	}
265	return false;	18✔
266	});
267
268	// If an alien element was found, it's not a whole paragraph tag
269	if (alienFound) {	23✔
270	return false;	12✔
271	}
272
273	// Ensure that all the text in the paragraph is within elements of the same type as our element
274	const para = element.closest('p');	11✔
275	return !!para && para.textContent?.trim() === element.textContent?.trim();	11!
276	};
277
278	/**
279	* `<b>` and `<strong>` tags are headings iff they are the only thing in their
280	* paragraph. Return whether the given tag name is a tag with that property
281	* (ie, is `<strong>` or `<b>`).
282	* See tagIsWholeParagraph
283	*/
284	function tagIsHeadingIfWholeParagraph(tagName: string): boolean
285	{
286	return tagName.toLowerCase() in headingIfWholeParagraph;	28✔
287	}
288
289	const reservedAnchorNames = ["top", "comments"];	21✔
290
291	/**
292	* Given the text in a heading block and a dict of anchors that have been used
293	* in the post so far, generate an anchor, and return it. An anchor is a
294	* URL-safe string that can be used for within-document links, and which is
295	* not one of a few reserved anchor names.
296	*/
297	function titleToAnchor(title: string, usedAnchors: Record<string,boolean>): string
298	{
299	let charsToUse = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789";	8✔
300	let sb: Array<string> = [];	8✔
301
302	for(let i=0; i<title.length; i++) {	8✔
303	let ch = title.charAt(i);	164✔
304	if(charsToUse.indexOf(ch) >= 0) {	164✔
305	sb.push(ch);	134✔
306	} else {
307	sb.push('_');	30✔
308	}
309	}
310
311	let anchor = sb.join('');	8✔
312	if(!usedAnchors[anchor] && !_.find(reservedAnchorNames, x=>x===anchor))	16!
313	return anchor;	8✔
314
UNCOV 315	let anchorSuffix = 1;	×
UNCOV 316	while(usedAnchors[anchor + anchorSuffix])	×
UNCOV 317	anchorSuffix++;	×
UNCOV 318	return anchor+anchorSuffix;	×
319	}
320
321	function tagToHeadingLevel(tagName: string): number
322	{
323	let lowerCaseTagName = tagName.toLowerCase();	8✔
324	if (lowerCaseTagName in headingTags)	8!
325	return headingTags[lowerCaseTagName as keyof typeof headingTags];	8!
326	else if (lowerCaseTagName in headingIfWholeParagraph)
327	// Comment below from Robert, ported from server/tableOfContents:
328	// TODO: this seems wrong??? It's returning a boolean when it should be returning a number
329	// @ts-ignore
330	return headingIfWholeParagraph[lowerCaseTagName as keyof typeof headingIfWholeParagraph];	×
331	else
332	return 0;	×
333	}

ForumMagnum / ForumMagnum / 10710202893

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