Move writeFileSync to write_file.ts, add writeFile and tests (#728)

6 files changed, 146 insertions, 63 deletions

diff --git a/js/deno.ts b/js/deno.ts
index fab8ef4e2..8908d7b67 100644
--- a/js/deno.ts
+++ b/js/deno.ts
@@ -8,11 +8,11 @@ export {
   makeTempDirSync,
   renameSync,
   statSync,
-  lstatSync,
-  writeFileSync
+  lstatSync
 } from "./os";
 export { mkdirSync, mkdir } from "./mkdir";
 export { readFileSync, readFile } from "./read_file";
+export { writeFileSync, writeFile } from "./write_file";
 export { ErrorKind, DenoError } from "./errors";
 export { libdeno } from "./libdeno";
 export const argv: string[] = [];
diff --git a/js/os.ts b/js/os.ts
index 4849ac19f..8b54b4b8c 100644
--- a/js/os.ts
+++ b/js/os.ts
@@ -275,38 +275,6 @@ function statSyncInner(filename: string, lstat: boolean): FileInfo {
 }
 
 /**
- * Write a new file.
- *     import { writeFileSync } from "deno";
- *
- *     const encoder = new TextEncoder("utf-8");
- *     const data = encoder.encode("Hello world\n");
- *     writeFileSync("hello.txt", data);
- */
-export function writeFileSync(
-  filename: string,
-  data: Uint8Array,
-  perm = 0o666
-): void {
-  /* Ideally we could write:
-  const res = sendSync({
-    command: fbs.Command.WRITE_FILE_SYNC,
-    writeFileSyncFilename: filename,
-    writeFileSyncData: data,
-    writeFileSyncPerm: perm
-  });
-  */
-  const builder = new flatbuffers.Builder();
-  const filename_ = builder.createString(filename);
-  const dataOffset = fbs.WriteFileSync.createDataVector(builder, data);
-  fbs.WriteFileSync.startWriteFileSync(builder);
-  fbs.WriteFileSync.addFilename(builder, filename_);
-  fbs.WriteFileSync.addData(builder, dataOffset);
-  fbs.WriteFileSync.addPerm(builder, perm);
-  const msg = fbs.WriteFileSync.endWriteFileSync(builder);
-  sendSync(builder, fbs.Any.WriteFileSync, msg);
-}
-
-/**
  * Renames (moves) oldpath to newpath.
  *     import { renameSync } from "deno";
  *     const oldpath = 'from/path';
diff --git a/js/os_test.ts b/js/os_test.ts
index df88b5085..4c5da1505 100644
--- a/js/os_test.ts
+++ b/js/os_test.ts
@@ -85,35 +85,6 @@ test(async function lstatSyncNotFound() {
   assertEqual(badInfo, undefined);
 });
 
-testPerm({ write: true }, function writeFileSyncSuccess() {
-  const enc = new TextEncoder();
-  const data = enc.encode("Hello");
-  const filename = deno.makeTempDirSync() + "/test.txt";
-  deno.writeFileSync(filename, data, 0o666);
-  const dataRead = deno.readFileSync(filename);
-  const dec = new TextDecoder("utf-8");
-  const actual = dec.decode(dataRead);
-  assertEqual("Hello", actual);
-});
-
-// For this test to pass we need --allow-write permission.
-// Otherwise it will fail with deno.PermissionDenied instead of deno.NotFound.
-testPerm({ write: true }, function writeFileSyncFail() {
-  const enc = new TextEncoder();
-  const data = enc.encode("Hello");
-  const filename = "/baddir/test.txt";
-  // The following should fail because /baddir doesn't exist (hopefully).
-  let caughtError = false;
-  try {
-    deno.writeFileSync(filename, data);
-  } catch (e) {
-    caughtError = true;
-    assertEqual(e.kind, deno.ErrorKind.NotFound);
-    assertEqual(e.name, "NotFound");
-  }
-  assert(caughtError);
-});
-
 testPerm({ write: true }, function makeTempDirSync() {
   const dir1 = deno.makeTempDirSync({ prefix: "hello", suffix: "world" });
   const dir2 = deno.makeTempDirSync({ prefix: "hello", suffix: "world" });
diff --git a/js/unit_tests.ts b/js/unit_tests.ts
index 1c5a9227e..e00cfc116 100644
--- a/js/unit_tests.ts
+++ b/js/unit_tests.ts
@@ -6,4 +6,5 @@ import "./console_test.ts";
 import "./fetch_test.ts";
 import "./os_test.ts";
 import "./read_file_test.ts";
+import "./write_file_test.ts";
 import "./mkdir_test.ts";
diff --git a/js/write_file.ts b/js/write_file.ts
new file mode 100644
index 000000000..60c6ff6ab
--- /dev/null
+++ b/js/write_file.ts
@@ -0,0 +1,54 @@
+// Copyright 2018 the Deno authors. All rights reserved. MIT license.
+import * as fbs from "gen/msg_generated";
+import { flatbuffers } from "flatbuffers";
+import * as dispatch from "./dispatch";
+
+/**
+ * Write a new file, with given filename and data synchronously.
+ *
+ *     import { writeFileSync } from "deno";
+ *
+ *     const encoder = new TextEncoder("utf-8");
+ *     const data = encoder.encode("Hello world\n");
+ *     writeFileSync("hello.txt", data);
+ */
+export function writeFileSync(
+  filename: string,
+  data: Uint8Array,
+  perm = 0o666
+): void {
+  dispatch.sendSync(...req(filename, data, perm));
+}
+
+/**
+ * Write a new file, with given filename and data.
+ *
+ *     import { writeFile } from "deno";
+ *
+ *     const encoder = new TextEncoder("utf-8");
+ *     const data = encoder.encode("Hello world\n");
+ *     await writeFile("hello.txt", data);
+ */
+export async function writeFile(
+  filename: string,
+  data: Uint8Array,
+  perm = 0o666
+): Promise<void> {
+  await dispatch.sendAsync(...req(filename, data, perm));
+}
+
+function req(
+  filename: string,
+  data: Uint8Array,
+  perm: number
+): [flatbuffers.Builder, fbs.Any, flatbuffers.Offset] {
+  const builder = new flatbuffers.Builder();
+  const filename_ = builder.createString(filename);
+  const dataOffset = fbs.WriteFile.createDataVector(builder, data);
+  fbs.WriteFile.startWriteFile(builder);
+  fbs.WriteFile.addFilename(builder, filename_);
+  fbs.WriteFile.addData(builder, dataOffset);
+  fbs.WriteFile.addPerm(builder, perm);
+  const msg = fbs.WriteFile.endWriteFile(builder);
+  return [builder, fbs.Any.WriteFile, msg];
+}
diff --git a/js/write_file_test.ts b/js/write_file_test.ts
new file mode 100644
index 000000000..f10343aeb
--- /dev/null
+++ b/js/write_file_test.ts
@@ -0,0 +1,89 @@
+// Copyright 2018 the Deno authors. All rights reserved. MIT license.
+import { testPerm, assert, assertEqual } from "./test_util.ts";
+import * as deno from "deno";
+
+testPerm({ write: true }, function writeFileSyncSuccess() {
+  const enc = new TextEncoder();
+  const data = enc.encode("Hello");
+  const filename = deno.makeTempDirSync() + "/test.txt";
+  deno.writeFileSync(filename, data, 0o666);
+  const dataRead = deno.readFileSync(filename);
+  const dec = new TextDecoder("utf-8");
+  const actual = dec.decode(dataRead);
+  assertEqual("Hello", actual);
+});
+
+testPerm({ write: true }, function writeFileSyncFail() {
+  const enc = new TextEncoder();
+  const data = enc.encode("Hello");
+  const filename = "/baddir/test.txt";
+  // The following should fail because /baddir doesn't exist (hopefully).
+  let caughtError = false;
+  try {
+    deno.writeFileSync(filename, data);
+  } catch (e) {
+    caughtError = true;
+    assertEqual(e.kind, deno.ErrorKind.NotFound);
+    assertEqual(e.name, "NotFound");
+  }
+  assert(caughtError);
+});
+
+testPerm({ write: false }, function writeFileSyncPerm() {
+  const enc = new TextEncoder();
+  const data = enc.encode("Hello");
+  const filename = "/baddir/test.txt";
+  // The following should fail due to no write permission
+  let caughtError = false;
+  try {
+    deno.writeFileSync(filename, data);
+  } catch (e) {
+    caughtError = true;
+    assertEqual(e.kind, deno.ErrorKind.PermissionDenied);
+    assertEqual(e.name, "PermissionDenied");
+  }
+  assert(caughtError);
+});
+
+testPerm({ write: true }, async function writeFileSuccess() {
+  const enc = new TextEncoder();
+  const data = enc.encode("Hello");
+  const filename = deno.makeTempDirSync() + "/test.txt";
+  await deno.writeFile(filename, data, 0o666);
+  const dataRead = deno.readFileSync(filename);
+  const dec = new TextDecoder("utf-8");
+  const actual = dec.decode(dataRead);
+  assertEqual("Hello", actual);
+});
+
+testPerm({ write: true }, async function writeFileNotFound() {
+  const enc = new TextEncoder();
+  const data = enc.encode("Hello");
+  const filename = "/baddir/test.txt";
+  // The following should fail because /baddir doesn't exist (hopefully).
+  let caughtError = false;
+  try {
+    await deno.writeFile(filename, data);
+  } catch (e) {
+    caughtError = true;
+    assertEqual(e.kind, deno.ErrorKind.NotFound);
+    assertEqual(e.name, "NotFound");
+  }
+  assert(caughtError);
+});
+
+testPerm({ write: false }, async function writeFilePerm() {
+  const enc = new TextEncoder();
+  const data = enc.encode("Hello");
+  const filename = "/baddir/test.txt";
+  // The following should fail due to no write permission
+  let caughtError = false;
+  try {
+    await deno.writeFile(filename, data);
+  } catch (e) {
+    caughtError = true;
+    assertEqual(e.kind, deno.ErrorKind.PermissionDenied);
+    assertEqual(e.name, "PermissionDenied");
+  }
+  assert(caughtError);
+});