harper.js 0.18.0 → 0.19.0

package/docs.sh

@@ -14,7 +14,7 @@ for file in ./markdown/*.md
 do 
   BASE=$(basename $file .md)
   pandoc $file -o html/$BASE.html
-  sed -i 's/"\(.*\).md"/"\1.html"/g' html/$BASE.html
+  perl -pi -e 's/"\K([^"]+)\.md(?=")/\1.html/g' html/$BASE.html
 
   echo '<link rel="stylesheet" href="https://unpkg.com/mvp.css">' >> html/$BASE.html
 done

package/examples/commonjs-simple/index.js

@@ -1,6 +1,5 @@
-import * as harper from 'harper.js';
-
 async function main() {
+	const harper = await import('harper.js');
 	// We cannot use `WorkerLinter` on Node.js since it relies on web-specific APIs.
 	let linter = new harper.LocalLinter();
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "harper.js",
-	"version": "0.18.0",
+	"version": "0.19.0",
 	"license": "Apache-2.0",
 	"author": "Elijah Potter",
 	"description": "The grammar checker for developers.",

package/src/Linter.test.ts

@@ -131,6 +131,44 @@ for (const [linterName, Linter] of Object.entries(linters)) {
 			expect(value).not.toBeNull();
 		}
 	});
+
+	test(`${linterName} can ignore lints`, async () => {
+		const linter = new Linter();
+		const source = 'This is an test.';
+
+		const firstRound = await linter.lint(source);
+
+		expect(firstRound.length).toBeGreaterThanOrEqual(1);
+
+		await linter.ignoreLint(firstRound[0]);
+
+		const secondRound = await linter.lint(source);
+
+		expect(secondRound.length).toBeLessThan(firstRound.length);
+	});
+
+	test(`${linterName} can reimport ignored lints.`, async () => {
+		const source = 'This is an test of xporting lints.';
+
+		const firstLinter = new Linter();
+
+		const firstLints = await firstLinter.lint(source);
+
+		for (const lint of firstLints) {
+			await firstLinter.ignoreLint(lint);
+		}
+
+		const exported = await firstLinter.exportIgnoredLints();
+
+		/// Create a new instance and reimport the lints.
+		const secondLinter = new Linter();
+		await secondLinter.importIgnoredLints(exported);
+
+		const secondLints = await secondLinter.lint(source);
+
+		expect(firstLints.length).toBeGreaterThan(secondLints.length);
+		expect(secondLints.length).toBe(0);
+	});
 }
 
 test('Linters have the same config format', async () => {

package/src/Linter.ts

@@ -50,4 +50,17 @@ export default interface Linter {
 
 	/** Convert a string to Chicago-style title case. */
 	toTitleCase(text: string): Promise<string>;
+
+	/** Ignore future instances of a lint from a previous linting run in future invocations. */
+	ignoreLint(lint: Lint): Promise<void>;
+
+	/** Export the ignored lints to a JSON list of privacy-respecting hashes. */
+	exportIgnoredLints(): Promise<string>;
+
+	/** Import ignored lints from a JSON list to the linter.
+	 * This function appends to the existing lints, if any. */
+	importIgnoredLints(json: string): Promise<void>;
+
+	/** Clear records of all previously ignored lints. */
+	clearIgnoredLints(): Promise<void>;
 }

package/src/LocalLinter.ts

@@ -97,4 +97,28 @@ export default class LocalLinter implements Linter {
 		await this.initialize();
 		return this.inner!.get_lint_descriptions_as_json();
 	}
+
+	async ignoreLint(lint: Lint): Promise<void> {
+		await this.initialize();
+
+		this.inner!.ignore_lint(lint);
+	}
+
+	async exportIgnoredLints(): Promise<string> {
+		await this.initialize();
+
+		return this.inner!.export_ignored_lints();
+	}
+
+	async importIgnoredLints(json: string): Promise<void> {
+		await this.initialize();
+
+		return this.inner!.import_ignored_lints(json);
+	}
+
+	async clearIgnoredLints(): Promise<void> {
+		await this.initialize();
+
+		return this.inner!.clear_ignored_lints();
+	}
 }

package/src/WorkerLinter/index.ts

@@ -113,6 +113,22 @@ export default class WorkerLinter implements Linter {
 		return JSON.parse(await this.getDefaultLintConfigAsJSON()) as LintConfig;
 	}
 
+	async ignoreLint(lint: Lint): Promise<void> {
+		return this.rpc('ignoreLint', [lint]);
+	}
+
+	async exportIgnoredLints(): Promise<string> {
+		return this.rpc('exportIgnoredLints', []);
+	}
+
+	async importIgnoredLints(json: string): Promise<void> {
+		return this.rpc('importIgnoredLints', [json]);
+	}
+
+	async clearIgnoredLints(): Promise<void> {
+		return this.rpc('clearIgnoredLints', []);
+	}
+
 	/** Run a procedure on the remote worker. */
 	private async rpc(procName: string, args: any[]): Promise<any> {
 		const promise = new Promise((resolve, reject) => {