Implements shell redirection (yarnpkg#245)

Author: arcanis

.pnp.js

@@ -10,6 +10,7 @@ export type CreateReadStreamOptions = Partial<{
 
 export type CreateWriteStreamOptions = Partial<{
   encoding: string,
+  flags: 'a',
 }>;
 
 export type WriteFileOptions = Partial<{

.yarn/cache/@types-tmp-npm-0.1.0-1a3e4dadd4c2326666cf9e0083ca4c150d7c3c19dbf3055de73bff70167d5ca0.zip

@@ -12,6 +12,8 @@
   "devDependencies": {
     "@berry/pnpify": "workspace:0.0.4",
     "@types/cross-spawn": "6.0.0",
+    "@types/tmp": "0.1.0",
+    "tmp": "^0.0.33",
     "typescript": "^3.3.3333"
   },
   "scripts": {

packages/berry-fslib/sources/FakeFS.ts

@@ -86,8 +86,95 @@ const BUILTINS = new Map<string, ShellBuiltin>([
   }],
 
   [`setredirects`, async (args: Array<string>, opts: ShellOptions, state: ShellState) => {
-    state.stderr.write(`Shell redirections aren't implemented yet.\n`);
-    return 1;
+    let stdin = state.stdin;
+    let stdout = state.stdout;
+    let stderr = state.stderr;
+
+    const inputs: Array<() => Readable> = [];
+    const outputs: Array<Writable> = [];
+
+    let t = 0;
+
+    while (args[t] !== `--`) {
+      const type = args[t++];
+
+      const count = Number(args[t++]);
+      const last = t + count;
+
+      for (let u = t; u < last; ++t, ++u) {
+        switch (type) {
+          case `<`: {
+            inputs.push(() => {
+              return xfs.createReadStream(ppath.resolve(state.cwd, NodeFS.toPortablePath(args[u])));
+            });
+          } break;
+          case `<<<`: {
+            inputs.push(() => {
+              const input = new PassThrough();
+              process.nextTick(() => {
+                input.write(`${args[u]}\n`);
+                input.end();
+              });
+              return input;
+            });
+          } break;
+          case `>`: {
+            outputs.push(xfs.createWriteStream(ppath.resolve(state.cwd, NodeFS.toPortablePath(args[u]))));
+          } break;
+          case `>>`: {
+            outputs.push(xfs.createWriteStream(ppath.resolve(state.cwd, NodeFS.toPortablePath(args[u])), {flags: `a`}));
+          } break;
+        }
+      }
+    }
+
+    if (inputs.length > 0) {
+      const pipe = new PassThrough();
+      stdin = pipe;
+
+      const bindInput = (n: number) => {
+        if (n === inputs.length) {
+          pipe.end();
+        } else {
+          const input = inputs[n]();
+          input.pipe(pipe, {end: false});
+          input.on(`end`, () => {
+            bindInput(n + 1);
+          });
+        }
+      };
+
+      bindInput(0);
+    }
+
+    if (outputs.length > 0) {
+      const pipe = new PassThrough();
+      stdout = pipe;
+
+      for (const output of outputs) {
+        pipe.pipe(output);
+      }
+    }
+
+    const exitCode = await start(makeCommandAction(args.slice(t + 1), opts, state), {
+      stdin: new ProtectedStream<Readable>(stdin),
+      stdout: new ProtectedStream<Writable>(stdout),
+      stderr: new ProtectedStream<Writable>(stderr),
+    }).run();
+
+    // Close all the outputs (since the shell never closes the output stream)
+    await Promise.all(outputs.map(output => {
+      output.end();
+
+      // Wait until the output got flushed to the disk
+      return new Promise(resolve => {
+        output.on(`close`, () => {
+          resolve();
+        });
+      });
+    }));
+
+    return exitCode;
   }],
 ]);
 

packages/berry-shell/package.json

@@ -1,5 +1,7 @@
+import {NodeFS, xfs} from '@berry/fslib';
 import {execute}     from '@berry/shell';
 import {PassThrough} from 'stream';
+import {fileSync}    from 'tmp';
 
 const ifNotWin32It = process.platform !== `win32`
   ? it
@@ -404,51 +406,83 @@ describe(`Simple shell features`, () => {
     });
   });
 
+  it(`should support empty default arguments`, async () => {
+    await expect(bufferResult(
+      `echo "foo\${DOESNT_EXIST:-}bar"`,
+    )).resolves.toMatchObject({
+      stdout: `foobar\n`,
+    });
+  });
+
   it(`should support input redirections (file)`, async () => {
+    const file = NodeFS.toPortablePath(fileSync({discardDescriptor: true}).name);
+    await xfs.writeFilePromise(file, `hello world\n`);
+
     await expect(bufferResult(
-      `echo foo < bar`,
+      `cat < "${file}"`,
     )).resolves.toMatchObject({
-      stderr: `Shell redirections aren't implemented yet.\n`,
+      stdout: `hello world\n`,
     });
   });
 
   it(`should support input redirections (string)`, async () => {
     await expect(bufferResult(
-      `echo foo <<< bar`,
+      `cat <<< "hello world"`,
     )).resolves.toMatchObject({
-      stderr: `Shell redirections aren't implemented yet.\n`,
+      stdout: `hello world\n`,
     });
   });
 
   it(`should support output redirections (overwrite)`, async () => {
+    const file = NodeFS.toPortablePath(fileSync({discardDescriptor: true}).name);
+
     await expect(bufferResult(
-      `echo foo > bar`,
+      `echo "hello world" > "${file}"`,
     )).resolves.toMatchObject({
-      stderr: `Shell redirections aren't implemented yet.\n`,
+      stdout: ``,
     });
+
+    await expect(xfs.readFilePromise(file, `utf8`)).resolves.toEqual(`hello world\n`);
   });
 
   it(`should support output redirections (append)`, async () => {
+    const file = NodeFS.toPortablePath(fileSync({discardDescriptor: true}).name);
+    await xfs.writeFilePromise(file, `foo bar baz\n`);
+
     await expect(bufferResult(
-      `echo foo >> bar`,
+      `echo "hello world" >> "${file}"`,
     )).resolves.toMatchObject({
-      stderr: `Shell redirections aren't implemented yet.\n`,
+      stdout: ``,
     });
+
+    await expect(xfs.readFilePromise(file, `utf8`)).resolves.toEqual(`foo bar baz\nhello world\n`);
   });
 
   it(`should support multiple outputs`, async () => {
+    const file1 = NodeFS.toPortablePath(fileSync({discardDescriptor: true}).name);
+    const file2 = NodeFS.toPortablePath(fileSync({discardDescriptor: true}).name);
+
     await expect(bufferResult(
-      `echo foo > bar > baz`,
+      `echo "hello world" > "${file1}" > "${file2}"`,
     )).resolves.toMatchObject({
-      stderr: `Shell redirections aren't implemented yet.\n`,
+      stdout: ``,
     });
+
+    await expect(xfs.readFilePromise(file1, `utf8`)).resolves.toEqual(`hello world\n`);
+    await expect(xfs.readFilePromise(file2, `utf8`)).resolves.toEqual(`hello world\n`);
   });
 
   it(`should support multiple inputs`, async () => {
+    const file1 = NodeFS.toPortablePath(fileSync({discardDescriptor: true}).name);
+    await xfs.writeFilePromise(file1, `foo bar baz\n`);
+
+    const file2 = NodeFS.toPortablePath(fileSync({discardDescriptor: true}).name);
+    await xfs.writeFilePromise(file2, `hello world\n`);
+
     await expect(bufferResult(
-      `echo foo < bar < baz`,
+      `cat < "${file1}" < "${file2}"`,
     )).resolves.toMatchObject({
-      stderr: `Shell redirections aren't implemented yet.\n`,
+      stdout: `foo bar baz\nhello world\n`,
     });
   });
 });

packages/berry-shell/sources/index.ts

@@ -1980,9 +1980,11 @@ __metadata:
     "@berry/parsers": "workspace:0.0.2"
     "@berry/pnpify": "workspace:0.0.4"
     "@types/cross-spawn": "npm:6.0.0"
+    "@types/tmp": "npm:0.1.0"
     cross-spawn: "npm:^6.0.5"
     execa: "npm:^1.0.0"
     stream-buffers: "npm:^3.0.2"
+    tmp: "npm:^0.0.33"
     typescript: "npm:^3.3.3333"
   languageName: unknown
   linkType: soft
@@ -3441,6 +3443,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/tmp@npm:0.1.0":
+  version: 0.1.0
+  resolution: "@types/tmp@npm:0.1.0"
+  checksum: 8f5132c25ea5cf18e9694d807628fb6d654cca303de0a440197807ffabe7ed3edf2e95fbfe45d40e432f625fb2ae5ecc8e7d3f35c5be127bdcf375f46d037675
+  languageName: node
+  linkType: hard
+
 "@types/tmp@npm:^0.0.32":
   version: 0.0.32
   resolution: "@types/tmp@npm:0.0.32"