revert unrelated changes

denoland · bartlomieju · Jan 16, 2023 · Jan 16, 2023 · Jan 16, 2023 · Jan 16, 2023
commit 0feeed51c0a6b1d199b51a4fe53c60344482341f
diff --git a/cli/tests/unit/os_test.ts b/cli/tests/unit/os_test.ts
@@ -26,6 +26,13 @@ Deno.test({ permissions: { env: true } }, function deleteEnv() {
   assertEquals(Deno.env.get("TEST_VAR"), undefined);
 });
 
+Deno.test({ permissions: { env: true } }, function hasEnv() {
+  Deno.env.set("TEST_VAR", "A");
+  assert(Deno.env.has("TEST_VAR"));
+  Deno.env.delete("TEST_VAR");
+  assert(!Deno.env.has("TEST_VAR"));
+});
+
 Deno.test({ permissions: { env: true } }, function avoidEmptyNamedEnv() {
   assertThrows(() => Deno.env.set("", "v"), TypeError);
   assertThrows(() => Deno.env.set("a=a", "v"), TypeError);

diff --git a/cli/tests/unit/write_file_test.ts b/cli/tests/unit/write_file_test.ts
@@ -393,3 +393,19 @@ function pathExists(path: string | URL) {
     return false;
   }
 }
+
+Deno.test(
+  { permissions: { read: true, write: true } },
+  async function writeFileStream() {
+    const stream = new ReadableStream({
+      pull(controller) {
+        controller.enqueue(new Uint8Array([1]));
+        controller.enqueue(new Uint8Array([2]));
+        controller.close();
+      },
+    });
+    const filename = Deno.makeTempDirSync() + "/test.txt";
+    await Deno.writeFile(filename, stream);
+    assertEquals(Deno.readFileSync(filename), new Uint8Array([1, 2]));
+  },
+);
diff --git a/cli/tests/unit/write_text_file_test.ts b/cli/tests/unit/write_text_file_test.ts
@@ -200,3 +200,19 @@ Deno.test(
     assertEquals(Deno.readTextFileSync(filename), "Hello");
   },
 );
+
+Deno.test(
+  { permissions: { read: true, write: true } },
+  async function writeTextFileStream() {
+    const stream = new ReadableStream({
+      pull(controller) {
+        controller.enqueue("Hello");
+        controller.enqueue("World");
+        controller.close();
+      },
+    });
+    const filename = Deno.makeTempDirSync() + "/test.txt";
+    await Deno.writeTextFile(filename, stream);
+    assertEquals(Deno.readTextFileSync(filename), "HelloWorld");
+  },
+);
diff --git a/cli/tsc/dts/lib.deno.ns.d.ts b/cli/tsc/dts/lib.deno.ns.d.ts
@@ -1231,6 +1231,19 @@ declare namespace Deno {
      */
     delete(key: string): void;
 
+    /** Check whether an environment variable is present or not.
+     *
+     * ```ts
+     * Deno.env.set("SOME_VAR", "Value");
+     * Deno.env.has("SOME_VAR");  // outputs true
+     * ```
+     *
+     * Requires `allow-env` permission.
+     *
+     * @tags allow-env
+     */
+    has(key: string): boolean;
+
     /** Returns a snapshot of the environment variables at invocation as a
      * simple object of keys and values.
      *
@@ -3351,7 +3364,7 @@ declare namespace Deno {
    */
   export function writeFile(
     path: string | URL,
-    data: Uint8Array,
+    data: Uint8Array | ReadableStream<Uint8Array>,
     options?: WriteFileOptions,
   ): Promise<void>;
 
@@ -3394,7 +3407,7 @@ declare namespace Deno {
    */
   export function writeTextFile(
     path: string | URL,
-    data: string,
+    data: string | ReadableStream<string>,
     options?: WriteFileOptions,
   ): Promise<void>;
 

diff --git a/runtime/js/30_os.js b/runtime/js/30_os.js
@@ -96,6 +96,9 @@
       return ops.op_env();
     },
     set: setEnv,
+    has(key) {
+      return getEnv(key) !== undefined;
+    },
     delete: deleteEnv,
   };
 

diff --git a/runtime/js/40_write_file.js b/runtime/js/40_write_file.js
@@ -5,6 +5,9 @@
   const ops = core.ops;
   const { abortSignal } = window.__bootstrap;
   const { pathFromURL } = window.__bootstrap.util;
+  const { open } = window.__bootstrap.files;
+  const { ReadableStreamPrototype } = window.__bootstrap.streams;
+  const { ObjectPrototypeIsPrototypeOf } = window.__bootstrap.primordials;
 
   function writeFileSync(
     path,
@@ -36,16 +39,29 @@
       options.signal[abortSignal.add](abortHandler);
     }
     try {
-      await core.opAsync(
-        "op_write_file_async",
-        pathFromURL(path),
-        options.mode,
-        options.append ?? false,
-        options.create ?? true,
-        options.createNew ?? false,
-        data,
-        cancelRid,
-      );
+      if (ObjectPrototypeIsPrototypeOf(ReadableStreamPrototype, data)) {
+        const file = await open(path, {
+          mode: options.mode,
+          append: options.append ?? false,
+          create: options.create ?? true,
+          createNew: options.createNew ?? false,
+          write: true,
+        });
+        await data.pipeTo(file.writable, {
+          signal: options.signal,
+        });
+      } else {
+        await core.opAsync(
+          "op_write_file_async",
+          pathFromURL(path),
+          options.mode,
+          options.append ?? false,
+          options.create ?? true,
+          options.createNew ?? false,
+          data,
+          cancelRid,
+        );
+      }
     } finally {
       if (options.signal) {
         options.signal[abortSignal.remove](abortHandler);
@@ -70,8 +86,16 @@
     data,
     options = {},
   ) {
-    const encoder = new TextEncoder();
-    return writeFile(path, encoder.encode(data), options);
+    if (ObjectPrototypeIsPrototypeOf(ReadableStreamPrototype, data)) {
+      return writeFile(
+        path,
+        data.pipeThrough(new TextEncoderStream()),
+        options,
+      );
+    } else {
+      const encoder = new TextEncoder();
+      return writeFile(path, encoder.encode(data), options);
+    }
   }
 
   window.__bootstrap.writeFile = {