6984382717

Committed 24 Nov 2023 07:48PM UTC coverage: 83.086% (+0.5%) from 82.591%

Build # 6984382717

Build Type

Pull #661

github

Committed by

pmcelhaney

Commit Message

fix minor TypeScript error

Pull Request Pull Request #661: fix edge case where a file shadows a directory

Run Details

774 of 866 branches covered (0.0%)

Branch coverage included in aggregate %.

231 of 245 new or added lines in 2 files covered. (94.29%)

2 existing lines in 1 file now uncovered.

2473 of 3042 relevant lines covered (81.3%)

39.83 hits per line

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

91.64

/src/server/module-tree.ts

import type { Module } from "./registry.js";

interface File {
  isWildcard: boolean;
  module: Module;
  name: string;
  rawName: string;
}

interface Directory {
  directories: { [key: string]: Directory };
  files: { [key: string]: File };
  isWildcard: boolean;
  name: string;
  rawName: string;
}

interface Match {
  matchedPath: string;
  module: Module;
  pathVariables: { [key: string]: string };
}

function isDirectory(test: Directory | undefined): test is Directory {
  return test !== undefined;
}

export class ModuleTree {
  public readonly root: Directory = {
    directories: {},
    files: {},
    isWildcard: false,
    name: "",
    rawName: "",
  };

  private addModuleToDirectory(
    directory: Directory | undefined,
    segments: string[],
    module: Module,
  ) {
    if (directory === undefined) {
      return;
    }

    const [segment, ...remainingSegments] = segments;

    if (segment === undefined) {
      throw new Error("segments array is empty");
    }

    if (remainingSegments.length === 0) {
      directory.files[segment.toLowerCase()] = {
        isWildcard: segment.startsWith("{"),
        module,
        name: segment.replace(/^\{(?<name>.*)\}$/u, "$<name>"),
        rawName: segment,
      };
      return;
    }

    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
    directory.directories[segment.toLowerCase()] ??= {
      directories: {},
      files: {},
      isWildcard: segment.startsWith("{"),
      name: segment.replace(/^\{(?<name>.*)\}$/u, "$<name>"),
      rawName: segment,
    };
    this.addModuleToDirectory(
      directory.directories[segment.toLocaleLowerCase()],
      remainingSegments,
      module,
    );
  }

  public add(url: string, module: Module) {
    this.addModuleToDirectory(this.root, url.split("/").slice(1), module);
  }

  private removeModuleFromDirectory(
    directory: Directory | undefined,
    segments: string[],
  ) {
    if (!isDirectory(directory)) {
      return;
    }
    const [segment, ...remainingSegments] = segments;

    if (segment === undefined) {
      return;
    }

    if (remainingSegments.length === 0) {
      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
      delete directory.files[segment.toLowerCase()];
      return;
    }
    this.removeModuleFromDirectory(
      directory.directories[segment.toLowerCase()],
      remainingSegments,
    );
  }

  public remove(url: string) {
    const segments = url.split("/").slice(1);

    this.removeModuleFromDirectory(this.root, segments);
  }

  // eslint-disable-next-line max-params
  private buildMatch(
    directory: Directory,
    segment: string,
    pathVariables: { [key: string]: string },
    matchedPath: string,
  ) {
    const match =
      directory.files[segment.toLowerCase()] ??
      Object.values(directory.files).find((file) => file.isWildcard);

    if (match === undefined) {
      return undefined;
    }

    if (match.isWildcard) {
      return {
        ...match,

        matchedPath: `${matchedPath}/${match.rawName}`,

        pathVariables: {
          ...pathVariables,
          [match.name]: segment,
        },
      };
    }

    return {
      ...match,

      matchedPath: `${matchedPath}/${match.rawName}`,

      pathVariables,
    };
  }

  // eslint-disable-next-line max-statements, max-params
  private matchWithinDirectory(
    directory: Directory,
    segments: string[],
    pathVariables: { [key: string]: string },
    matchedPath: string,
  ): Match | undefined {
    if (segments.length === 0) {
      return undefined;
    }
    const [segment, ...remainingSegments] = segments;

    if (segment === undefined) {
      throw new Error(
        "segment cannot be undefined but TypeScript doesn't know that",
      );
    }

    if (remainingSegments.length === 0) {
      return this.buildMatch(directory, segment, pathVariables, matchedPath);
    }

    const exactMatch = directory.directories[segment.toLowerCase()];

    if (isDirectory(exactMatch)) {
      return this.matchWithinDirectory(
        exactMatch,
        remainingSegments,
        pathVariables,
        `${matchedPath}/${segment}`,
      );
    }

    const wildcardDirectory = Object.values(directory.directories).find(
      (subdirectory) => subdirectory.isWildcard,
    );

    if (wildcardDirectory) {
      return this.matchWithinDirectory(
        wildcardDirectory,
        remainingSegments,
        {
          ...pathVariables,
          [wildcardDirectory.name]: segment,
        },
        `${matchedPath}/${wildcardDirectory.rawName}`,
      );
    }

    return undefined;
  }

  public match(url: string) {
    return this.matchWithinDirectory(
      this.root,
      url.split("/").slice(1),
      {},
      "",
    );
  }

  public get routes(): string[] {
    const routes: string[] = [];

    function traverse(directory: Directory, path: string) {
      Object.values(directory.directories).forEach((subdirectory) => {
        traverse(subdirectory, `${path}/${subdirectory.rawName}`);
      });

      Object.values(directory.files).forEach((file) => {
        routes.push(`${path}/${file.rawName}`);
      });
    }

    // eslint-disable-next-line unicorn/consistent-function-scoping
    function stripBrackets(string: string) {
      return string.replaceAll(/\{|\}/gu, "");
    }

    traverse(this.root, "");

    // eslint-disable-next-line etc/no-assign-mutated-array
    return routes.sort((first, second) =>
      stripBrackets(first).localeCompare(stripBrackets(second)),
    );
  }
}

1	import type { Module } from "./registry.js";	2✔
2		2✔
3	interface File {	2✔
4	isWildcard: boolean;	2✔
5	module: Module;	2✔
6	name: string;	2✔
7	rawName: string;	2✔
8	}	2✔
9		2✔
10	interface Directory {	2✔
11	directories: { [key: string]: Directory };	2✔
12	files: { [key: string]: File };	2✔
13	isWildcard: boolean;	2✔
14	name: string;	2✔
15	rawName: string;	2✔
16	}	2✔
17		2✔
18	interface Match {	2✔
19	matchedPath: string;	2✔
20	module: Module;	2✔
21	pathVariables: { [key: string]: string };	2✔
22	}	2✔
23		2✔
24	function isDirectory(test: Directory \| undefined): test is Directory {	104✔
25	return test !== undefined;	104✔
26	}	104✔
27		2✔
28	export class ModuleTree {	2✔
29	public readonly root: Directory = {	108✔
30	directories: {},	108✔
31	files: {},	108✔
32	isWildcard: false,	108✔
33	name: "",	108✔
34	rawName: "",	108✔
35	};	108✔
36		108✔
37	private addModuleToDirectory(	108✔
38	directory: Directory \| undefined,	238✔
39	segments: string[],	238✔
40	module: Module,	238✔
41	) {	238✔
42	if (directory === undefined) {	238!
NEW 43	return;	×
NEW 44	}	×
45		238✔
46	const [segment, ...remainingSegments] = segments;	238✔
47		238✔
48	if (segment === undefined) {	238!
NEW 49	throw new Error("segments array is empty");	×
NEW 50	}	×
51		238✔
52	if (remainingSegments.length === 0) {	238✔
53	directory.files[segment.toLowerCase()] = {	140✔
54	isWildcard: segment.startsWith("{"),	140✔
55	module,	140✔
56	name: segment.replace(/^\{(?<name>.*)\}$/u, "$<name>"),	140✔
57	rawName: segment,	140✔
58	};	140✔
59	return;	140✔
60	}	140✔
61		98✔
62	// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition	98✔
63	directory.directories[segment.toLowerCase()] ??= {	98✔
64	directories: {},	98✔
65	files: {},	98✔
66	isWildcard: segment.startsWith("{"),	98✔
67	name: segment.replace(/^\{(?<name>.*)\}$/u, "$<name>"),	98✔
68	rawName: segment,	98✔
69	};	98✔
70	this.addModuleToDirectory(	98✔
71	directory.directories[segment.toLocaleLowerCase()],	98✔
72	remainingSegments,	98✔
73	module,	98✔
74	);	98✔
75	}	98✔
76		108✔
77	public add(url: string, module: Module) {	108✔
78	this.addModuleToDirectory(this.root, url.split("/").slice(1), module);	140✔
79	}	140✔
80		108✔
81	private removeModuleFromDirectory(	108✔
82	directory: Directory \| undefined,	8✔
83	segments: string[],	8✔
84	) {	8✔
85	if (!isDirectory(directory)) {	8!
NEW 86	return;	×
NEW 87	}	×
88	const [segment, ...remainingSegments] = segments;	8✔
89		8✔
90	if (segment === undefined) {	8!
NEW 91	return;	×
NEW 92	}	×
93		8✔
94	if (remainingSegments.length === 0) {	8✔
95	// eslint-disable-next-line @typescript-eslint/no-dynamic-delete	6✔
96	delete directory.files[segment.toLowerCase()];	6✔
97	return;	6✔
98	}	6✔
99	this.removeModuleFromDirectory(	2✔
100	directory.directories[segment.toLowerCase()],	2✔
101	remainingSegments,	2✔
102	);	2✔
103	}	2✔
104		108✔
105	public remove(url: string) {	108✔
106	const segments = url.split("/").slice(1);	6✔
107		6✔
108	this.removeModuleFromDirectory(this.root, segments);	6✔
109	}	6✔
110		108✔
111	// eslint-disable-next-line max-params	108✔
112	private buildMatch(	108✔
113	directory: Directory,	172✔
114	segment: string,	172✔
115	pathVariables: { [key: string]: string },	172✔
116	matchedPath: string,	172✔
117	) {	172✔
118	const match =	172✔
119	directory.files[segment.toLowerCase()] ??	172✔
120	Object.values(directory.files).find((file) => file.isWildcard);	44✔
121		172✔
122	if (match === undefined) {	172✔
123	return undefined;	18✔
124	}	18✔
125		154✔
126	if (match.isWildcard) {	172✔
127	return {	26✔
128	...match,	26✔
129		26✔
130	matchedPath: `${matchedPath}/${match.rawName}`,	26✔
131		26✔
132	pathVariables: {	26✔
133	...pathVariables,	26✔
134	[match.name]: segment,	26✔
135	},	26✔
136	};	26✔
137	}	26✔
138		128✔
139	return {	128✔
140	...match,	128✔
141		128✔
142	matchedPath: `${matchedPath}/${match.rawName}`,	128✔
143		128✔
144	pathVariables,	128✔
145	};	128✔
146	}	128✔
147		108✔
148	// eslint-disable-next-line max-statements, max-params	108✔
149	private matchWithinDirectory(	108✔
150	directory: Directory,	268✔
151	segments: string[],	268✔
152	pathVariables: { [key: string]: string },	268✔
153	matchedPath: string,	268✔
154	): Match \| undefined {	268✔
155	if (segments.length === 0) {	268!
NEW 156	return undefined;	×
NEW 157	}	×
158	const [segment, ...remainingSegments] = segments;	268✔
159		268✔
160	if (segment === undefined) {	268!
NEW 161	throw new Error(	×
NEW 162	"segment cannot be undefined but TypeScript doesn't know that",	×
NEW 163	);	×
NEW 164	}	×
165		268✔
166	if (remainingSegments.length === 0) {	268✔
167	return this.buildMatch(directory, segment, pathVariables, matchedPath);	172✔
168	}	172✔
169		96✔
170	const exactMatch = directory.directories[segment.toLowerCase()];	96✔
171		96✔
172	if (isDirectory(exactMatch)) {	240✔
173	return this.matchWithinDirectory(	64✔
174	exactMatch,	64✔
175	remainingSegments,	64✔
176	pathVariables,	64✔
177	`${matchedPath}/${segment}`,	64✔
178	);	64✔
179	}	64✔
180		32✔
181	const wildcardDirectory = Object.values(directory.directories).find(	32✔
182	(subdirectory) => subdirectory.isWildcard,	32✔
183	);	32✔
184		32✔
185	if (wildcardDirectory) {	160✔
186	return this.matchWithinDirectory(	26✔
187	wildcardDirectory,	26✔
188	remainingSegments,	26✔
189	{	26✔
190	...pathVariables,	26✔
191	[wildcardDirectory.name]: segment,	26✔
192	},	26✔
193	`${matchedPath}/${wildcardDirectory.rawName}`,	26✔
194	);	26✔
195	}	26✔
196		6✔
197	return undefined;	6✔
198	}	6✔
199		108✔
200	public match(url: string) {	108✔
201	return this.matchWithinDirectory(	178✔
202	this.root,	178✔
203	url.split("/").slice(1),	178✔
204	{},	178✔
205	"",	178✔
206	);	178✔
207	}	178✔
208		108✔
209	public get routes(): string[] {	108✔
210	const routes: string[] = [];	4✔
211		4✔
212	function traverse(directory: Directory, path: string) {	4✔
213	Object.values(directory.directories).forEach((subdirectory) => {	18✔
214	traverse(subdirectory, `${path}/${subdirectory.rawName}`);	14✔
215	});	14✔
216		18✔
217	Object.values(directory.files).forEach((file) => {	18✔
218	routes.push(`${path}/${file.rawName}`);	26✔
219	});	26✔
220	}	18✔
221		4✔
222	// eslint-disable-next-line unicorn/consistent-function-scoping	4✔
223	function stripBrackets(string: string) {	4✔
224	return string.replaceAll(/\{\|\}/gu, "");	100✔
225	}	100✔
226		4✔
227	traverse(this.root, "");	4✔
228		4✔
229	// eslint-disable-next-line etc/no-assign-mutated-array	4✔
230	return routes.sort((first, second) =>	4✔
231	stripBrackets(first).localeCompare(stripBrackets(second)),	50✔
232	);	4✔
233	}	4✔
234	}	108✔

pmcelhaney / counterfact / 6984382717

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