Skip to content

Commit fd7a896

Browse files
boneskullboneskull
committed
fix: allow traversal of symlinks in glob
Closes #2130 This adds a `followSymlinks` option to the `glob()` function, and enables it when searching for entry points. If `true`, and a symbolic link is encountered, a stat will be taken of the symlink's target. If a dir or file, the symlink is handled like any other dir or file. If a symbolic link itself (symlink to a symlink), we take a stat of the next until we find a dir or file, then handle it. There is a little bit of caching to avoid extra I/O, and protection from recursive symlinks. However, it's possible (though unlikely) that the FS could cause a "max call stack exceeded" exception. If someone runs into this, we can change the implementation to a loop instead of a recursive function. Apologies for blasting the `do..while`. I love a good `do` myself, but splitting out the lambda functions make it untenable.
1 parent 56813c0 commit fd7a896

File tree

3 files changed

+159
-24
lines changed

3 files changed

+159
-24
lines changed

Diff for: ‎src/lib/utils/entry-point.ts

+1-1
Original file line numberDiff line numberDiff line change
@@ -203,7 +203,7 @@ export function getExpandedEntryPointsForPaths(
203203
function expandGlobs(inputFiles: string[]) {
204204
const base = getCommonDirectory(inputFiles);
205205
const result = inputFiles.flatMap((entry) =>
206-
glob(entry, base, { includeDirectories: true })
206+
glob(entry, base, { includeDirectories: true, followSymlinks: true })
207207
);
208208
return result;
209209
}

Diff for: ‎src/lib/utils/fs.ts

+72-21
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
import * as fs from "fs";
22
import { promises as fsp } from "fs";
33
import { Minimatch } from "minimatch";
4-
import { dirname, join } from "path";
4+
import { dirname, join, relative } from "path";
55

66
/**
77
* Get the longest directory path common to all files.
@@ -139,41 +139,92 @@ export function copySync(src: string, dest: string): void {
139139
export function glob(
140140
pattern: string,
141141
root: string,
142-
options?: { includeDirectories?: boolean }
142+
options: { includeDirectories?: boolean; followSymlinks?: boolean } = {}
143143
): string[] {
144144
const result: string[] = [];
145145
const mini = new Minimatch(normalizePath(pattern));
146146
const dirs: string[][] = [normalizePath(root).split("/")];
147+
// cache of real paths to avoid infinite recursion
148+
const symlinkTargetsSeen: Set<string> = new Set();
149+
// cache of fs.realpathSync results to avoid extra I/O
150+
const realpathCache: Map<string, string> = new Map();
151+
const { includeDirectories = false, followSymlinks = false } = options;
152+
153+
let dir = dirs.shift();
154+
155+
const handleFile = (path: string) => {
156+
const childPath = [...dir!, path].join("/");
157+
if (mini.match(childPath)) {
158+
result.push(childPath);
159+
}
160+
};
161+
162+
const handleDirectory = (path: string) => {
163+
const childPath = [...dir!, path];
164+
if (
165+
mini.set.some((row) =>
166+
mini.matchOne(childPath, row, /* partial */ true)
167+
)
168+
) {
169+
dirs.push(childPath);
170+
}
171+
};
172+
173+
const handleSymlink = (path: string) => {
174+
const childPath = [...dir!, path].join("/");
175+
let realpath: string;
176+
try {
177+
realpath =
178+
realpathCache.get(childPath) ?? fs.realpathSync(childPath);
179+
realpathCache.set(childPath, realpath);
180+
} catch {
181+
return;
182+
}
147183

148-
do {
149-
const dir = dirs.shift()!;
184+
if (symlinkTargetsSeen.has(realpath)) {
185+
return;
186+
}
187+
symlinkTargetsSeen.add(realpath);
188+
189+
try {
190+
const stats = fs.statSync(realpath);
191+
if (stats.isDirectory()) {
192+
handleDirectory(path);
193+
} else if (stats.isFile()) {
194+
handleFile(path);
195+
} else if (stats.isSymbolicLink()) {
196+
const dirpath = dir!.join("/");
197+
if (dirpath === realpath) {
198+
// special case: real path of symlink is the directory we're currently traversing
199+
return;
200+
}
201+
const targetPath = relative(dirpath, realpath);
202+
handleSymlink(targetPath);
203+
} // everything else should be ignored
204+
} catch (e) {
205+
// invalid symbolic link; ignore
206+
}
207+
};
150208

151-
if (options?.includeDirectories && mini.match(dir.join("/"))) {
209+
while (dir) {
210+
if (includeDirectories && mini.match(dir.join("/"))) {
152211
result.push(dir.join("/"));
153212
}
154213

155214
for (const child of fs.readdirSync(dir.join("/"), {
156215
withFileTypes: true,
157216
})) {
158217
if (child.isFile()) {
159-
const childPath = [...dir, child.name].join("/");
160-
if (mini.match(childPath)) {
161-
result.push(childPath);
162-
}
163-
}
164-
165-
if (child.isDirectory() && child.name !== "node_modules") {
166-
const childPath = dir.concat(child.name);
167-
if (
168-
mini.set.some((row) =>
169-
mini.matchOne(childPath, row, /* partial */ true)
170-
)
171-
) {
172-
dirs.push(childPath);
173-
}
218+
handleFile(child.name);
219+
} else if (child.isDirectory() && child.name !== "node_modules") {
220+
handleDirectory(child.name);
221+
} else if (followSymlinks && child.isSymbolicLink()) {
222+
handleSymlink(child.name);
174223
}
175224
}
176-
} while (dirs.length);
225+
226+
dir = dirs.shift();
227+
}
177228

178229
return result;
179230
}

Diff for: ‎src/test/utils/fs.test.ts

+86-2
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,8 @@
1+
import * as fs from "fs";
2+
import { createServer } from "net";
13
import { Project, tempdirProject } from "@typestrong/fs-fixture-builder";
2-
import { deepStrictEqual as equal } from "assert";
3-
import { basename } from "path";
4+
import { AssertionError, deepStrictEqual as equal } from "assert";
5+
import { basename, dirname, resolve } from "path";
46
import { glob } from "../../lib/utils/fs";
57

68
describe("fs.ts", () => {
@@ -37,5 +39,87 @@ describe("fs.ts", () => {
3739
["test.ts", "test2.ts"]
3840
);
3941
});
42+
43+
describe("when 'followSymlinks' option is true", () => {
44+
it("should navigate symlinked directories", () => {
45+
const target = dirname(fix.dir("a").addFile("test.ts").path);
46+
fix.write();
47+
fs.symlinkSync(target, resolve(fix.cwd, "b"), "junction");
48+
equal(
49+
glob(`${fix.cwd}/b/*.ts`, fix.cwd, {
50+
followSymlinks: true,
51+
}).map((f) => basename(f)),
52+
["test.ts"]
53+
);
54+
});
55+
56+
it("should navigate recursive symlinked directories only once", () => {
57+
fix.addFile("test.ts");
58+
fix.write();
59+
fs.symlinkSync(
60+
fix.cwd,
61+
resolve(fix.cwd, "recursive"),
62+
"junction"
63+
);
64+
equal(
65+
glob(`${fix.cwd}/**/*.ts`, fix.cwd, {
66+
followSymlinks: true,
67+
}).map((f) => basename(f)),
68+
["test.ts", "test.ts"]
69+
);
70+
});
71+
72+
it("should handle symlinked files", function () {
73+
const { path } = fix.addFile("test.ts");
74+
fix.write();
75+
try {
76+
fs.symlinkSync(
77+
path,
78+
resolve(dirname(path), "test-2.ts"),
79+
"file"
80+
);
81+
} catch (err) {
82+
// on windows, you need elevated permissions to create a file symlink.
83+
// maybe we have them! maybe we don't!
84+
if (
85+
(err as NodeJS.ErrnoException).code === "EPERM" &&
86+
process.platform === "win32"
87+
) {
88+
return this.skip();
89+
}
90+
}
91+
equal(
92+
glob(`${fix.cwd}/**/*.ts`, fix.cwd, {
93+
followSymlinks: true,
94+
}).map((f) => basename(f)),
95+
["test-2.ts", "test.ts"]
96+
);
97+
});
98+
});
99+
100+
it("should ignore anything that is not a file, symbolic link, or directory", function (done) {
101+
// Use unix socket for example, because that's easiest to create.
102+
// Skip on Windows because it doesn't support unix sockets
103+
if (process.platform === "win32") {
104+
return this.skip();
105+
}
106+
fix.write();
107+
108+
const sockServer = createServer()
109+
.unref()
110+
.listen(resolve(fix.cwd, "socket.sock"))
111+
.once("listening", () => {
112+
let err: AssertionError | null = null;
113+
try {
114+
equal(glob(`${fix.cwd}/*.sock`, fix.cwd), []);
115+
} catch (e) {
116+
err = e as AssertionError;
117+
} finally {
118+
sockServer.close(() => {
119+
done(err);
120+
});
121+
}
122+
});
123+
});
40124
});
41125
});

0 commit comments

Comments
 (0)