9008354341

Committed 08 May 2024 08:47PM UTC coverage: 86.891% (-0.3%) from 87.217%

Build # 9008354341

Build Type

Pull #886

github

Committed by

dethell

Commit Message

feat(docs): Update documentation

Pull Request Pull Request #886: feat(counterfact): Add command new line options

Run Details

941 of 1044 branches covered (90.13%)

Branch coverage included in aggregate %.

88 of 118 new or added lines in 5 files covered. (74.58%)

4 existing lines in 1 file now uncovered.

3089 of 3594 relevant lines covered (85.95%)

43.94 hits per line

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

94.14

/src/typescript-generator/repository.js

/* eslint-disable max-statements */
import { existsSync } from "node:fs";
import fs from "node:fs/promises";
import nodePath, { dirname } from "node:path";
import { fileURLToPath } from "node:url";

import createDebug from "debug";

import { ensureDirectoryExists } from "../util/ensure-directory-exists.js";
import { CONTEXT_FILE_TOKEN } from "./context-file-token.js";
import { Script } from "./script.js";

const debug = createDebug("counterfact:server:repository");

// eslint-disable-next-line no-underscore-dangle
const __dirname = dirname(fileURLToPath(import.meta.url)).replaceAll("\\", "/");

debug("dirname is %s", __dirname);

export class Repository {
  constructor() {
    this.scripts = new Map();
  }

  get(path) {
    debug("getting script at %s", path);

    if (this.scripts.has(path)) {
      debug("already have script %s, returning it", path);

      return this.scripts.get(path);
    }

    debug("don't have %s, creating it", path);

    const script = new Script(this, path);

    this.scripts.set(path, script);

    return script;
  }

  async finished() {
    while (
      Array.from(this.scripts.values()).some((script) => script.isInProgress())
    ) {
      debug("waiting for %i scripts to finish", this.scripts.size);
      // eslint-disable-next-line no-await-in-loop
      await Promise.all(
        Array.from(this.scripts.values(), (script) => script.finished()),
      );
    }
  }

  async copyCoreFiles(destination) {
    const sourcePath = nodePath.join(__dirname, "../../dist/server/types.d.ts");
    const destinationPath = nodePath.join(destination, "types.d.ts");

    if (!existsSync(sourcePath)) {
      return false;
    }

    await ensureDirectoryExists(destination);

    return fs.copyFile(sourcePath, destinationPath);
  }

  async writeFiles(destination, { routes, types }) {
    debug(
      "waiting for %i or more scripts to finish before writing files",
      this.scripts.size,
    );
    await this.finished();
    debug("all %i scripts are finished", this.scripts.size);

    const writeFiles = Array.from(
      this.scripts.entries(),
      async ([path, script]) => {
        const contents = await script.contents();

        const fullPath = nodePath.join(destination, path).replaceAll("\\", "/");

        await ensureDirectoryExists(fullPath);

        const shouldWriteRoutes = routes && path.startsWith("paths");
        const shouldWriteTypes = types && !path.startsWith("paths");

        if (
          shouldWriteRoutes &&
          (await fs
            .stat(fullPath)
            .then((stat) => stat.isFile())
            .catch(() => false))
        ) {
          debug(`not overwriting ${fullPath}\n`);

          return;
        }

        if (shouldWriteRoutes || shouldWriteTypes) {
          debug("about to write", fullPath);
          await fs.writeFile(
            fullPath,
            contents.replaceAll(
              CONTEXT_FILE_TOKEN,
              this.findContextPath(destination, path),
            ),
          );
          debug("did write", fullPath);
        }
      },
    );

    await Promise.all(writeFiles);

    await this.copyCoreFiles(destination);

    if (routes) {
      await this.createDefaultContextFile(destination);
    }
  }

  async createDefaultContextFile(destination) {
    const contextFilePath = nodePath.join(destination, "paths", "_.context.ts");

    if (existsSync(contextFilePath)) {
      return;
    }

    await ensureDirectoryExists(contextFilePath);

    await fs.writeFile(
      contextFilePath,
      `/**
* This is the default context for Counterfact.
*
* It defines the context object in the REPL 
* and the $.context object in the code.
*
* Add properties and methods to suit your needs.
* 
* See https://counterfact.dev/docs/usage.html#working-with-state-the-codecontextcode-object-and-codecontexttscode
*/
export class Context {

}
`,
    );
  }

  findContextPath(destination, path) {
    return nodePath
      .relative(
        nodePath.join(destination, nodePath.dirname(path)),
        this.nearestContextFile(destination, path),
      )
      .replaceAll("\\", "/");
  }

  nearestContextFile(destination, path) {
    const directory = nodePath.dirname(path).replace("path-types", "paths");

    const candidate = nodePath.join(destination, directory, "_.context.ts");

    if (directory.length <= 1) {
      // No _context.ts was found so import the one that should be in the root
      return nodePath.join(destination, "paths", "_.context.ts");
    }

    if (existsSync(candidate)) {
      return candidate;
    }

    return this.nearestContextFile(destination, nodePath.join(path, ".."));
  }
}

1	/* eslint-disable max-statements */	2✔
2	import { existsSync } from "node:fs";	2✔
3	import fs from "node:fs/promises";	2✔
4	import nodePath, { dirname } from "node:path";	2✔
5	import { fileURLToPath } from "node:url";	2✔
6		2✔
7	import createDebug from "debug";	2✔
8		2✔
9	import { ensureDirectoryExists } from "../util/ensure-directory-exists.js";	2✔
10	import { CONTEXT_FILE_TOKEN } from "./context-file-token.js";	2✔
11	import { Script } from "./script.js";	2✔
12		2✔
13	const debug = createDebug("counterfact:server:repository");	2✔
14		2✔
15	// eslint-disable-next-line no-underscore-dangle	2✔
16	const __dirname = dirname(fileURLToPath(import.meta.url)).replaceAll("\\", "/");	2✔
17		2✔
18	debug("dirname is %s", __dirname);	2✔
19		2✔
20	export class Repository {	2✔
21	constructor() {	2✔
22	this.scripts = new Map();	46✔
23	}	46✔
24		2✔
25	get(path) {	2✔
26	debug("getting script at %s", path);	186✔
27		186✔
28	if (this.scripts.has(path)) {	186✔
29	debug("already have script %s, returning it", path);	60✔
30		60✔
31	return this.scripts.get(path);	60✔
32	}	60✔
33		126✔
34	debug("don't have %s, creating it", path);	126✔
35		126✔
36	const script = new Script(this, path);	126✔
37		126✔
38	this.scripts.set(path, script);	126✔
39		126✔
40	return script;	126✔
41	}	126✔
42		2✔
43	async finished() {	2✔
44	while (	16✔
45	Array.from(this.scripts.values()).some((script) => script.isInProgress())	16✔
46	) {	16✔
47	debug("waiting for %i scripts to finish", this.scripts.size);	10✔
48	// eslint-disable-next-line no-await-in-loop	10✔
49	await Promise.all(	10✔
50	Array.from(this.scripts.values(), (script) => script.finished()),	10✔
51	);	10✔
52	}	10✔
53	}	16✔
54		2✔
55	async copyCoreFiles(destination) {	2✔
56	const sourcePath = nodePath.join(__dirname, "../../dist/server/types.d.ts");	14✔
57	const destinationPath = nodePath.join(destination, "types.d.ts");	14✔
58		14✔
59	if (!existsSync(sourcePath)) {	14✔
60	return false;	14✔
61	}	14!
62		×
63	await ensureDirectoryExists(destination);	×
64		×
65	return fs.copyFile(sourcePath, destinationPath);	×
66	}	×
67		2✔
68	async writeFiles(destination, { routes, types }) {	2✔
69	debug(	14✔
70	"waiting for %i or more scripts to finish before writing files",	14✔
71	this.scripts.size,	14✔
72	);	14✔
73	await this.finished();	14✔
74	debug("all %i scripts are finished", this.scripts.size);	14✔
75		14✔
76	const writeFiles = Array.from(	14✔
77	this.scripts.entries(),	14✔
78	async ([path, script]) => {	14✔
79	const contents = await script.contents();	24✔
80		24✔
81	const fullPath = nodePath.join(destination, path).replaceAll("\\", "/");	24✔
82		24✔
83	await ensureDirectoryExists(fullPath);	24✔
84		24✔
85	const shouldWriteRoutes = routes && path.startsWith("paths");	24✔
86	const shouldWriteTypes = types && !path.startsWith("paths");	24✔
87		24✔
88	if (	24✔
89	shouldWriteRoutes &&	24✔
90	(await fs	8✔
91	.stat(fullPath)	8✔
92	.then((stat) => stat.isFile())	8✔
93	.catch(() => false))	8✔
94	) {	24!
UNCOV 95	debug(`not overwriting ${fullPath}\n`);	×
UNCOV 96		×
UNCOV 97	return;	×
UNCOV 98	}	×
99		24✔
100	if (shouldWriteRoutes \|\| shouldWriteTypes) {	24✔
101	debug("about to write", fullPath);	16✔
102	await fs.writeFile(	16✔
103	fullPath,	16✔
104	contents.replaceAll(	16✔
105	CONTEXT_FILE_TOKEN,	16✔
106	this.findContextPath(destination, path),	16✔
107	),	16✔
108	);	16✔
109	debug("did write", fullPath);	16✔
110	}	16✔
111	},	24✔
112	);	14✔
113		14✔
114	await Promise.all(writeFiles);	14✔
115		14✔
116	await this.copyCoreFiles(destination);	14✔
117		14✔
118	if (routes) {	14✔
119	await this.createDefaultContextFile(destination);	12✔
120	}	12✔
121	}	14✔
122		2✔
123	async createDefaultContextFile(destination) {	2✔
124	const contextFilePath = nodePath.join(destination, "paths", "_.context.ts");	12✔
125		12✔
126	if (existsSync(contextFilePath)) {	12✔
127	return;	2✔
128	}	2✔
129		10✔
130	await ensureDirectoryExists(contextFilePath);	10✔
131		10✔
132	await fs.writeFile(	10✔
133	contextFilePath,	10✔
134	`/**	10✔
135	* This is the default context for Counterfact.	10✔
136	*	10✔
137	* It defines the context object in the REPL	10✔
138	* and the $.context object in the code.	10✔
139	*	10✔
140	* Add properties and methods to suit your needs.	10✔
141	*	10✔
142	* See https://counterfact.dev/docs/usage.html#working-with-state-the-codecontextcode-object-and-codecontexttscode	10✔
143	*/	10✔
144	export class Context {	10✔
145		10✔
146	}	10✔
147	`,	10✔
148	);	10✔
149	}	10✔
150		2✔
151	findContextPath(destination, path) {	2✔
152	return nodePath	24✔
153	.relative(	24✔
154	nodePath.join(destination, nodePath.dirname(path)),	24✔
155	this.nearestContextFile(destination, path),	24✔
156	)	24✔
157	.replaceAll("\\", "/");	24✔
158	}	24✔
159		2✔
160	nearestContextFile(destination, path) {	2✔
161	const directory = nodePath.dirname(path).replace("path-types", "paths");	44✔
162		44✔
163	const candidate = nodePath.join(destination, directory, "_.context.ts");	44✔
164		44✔
165	if (directory.length <= 1) {	44✔
166	// No _context.ts was found so import the one that should be in the root	16✔
167	return nodePath.join(destination, "paths", "_.context.ts");	16✔
168	}	16✔
169		28✔
170	if (existsSync(candidate)) {	44✔
171	return candidate;	8✔
172	}	8✔
173		20✔
174	return this.nearestContextFile(destination, nodePath.join(path, ".."));	20✔
175	}	20✔
176	}	2✔

pmcelhaney / counterfact / 9008354341

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