bare-tty 1.0.4 → 1.0.5

package/binding.c

@@ -5,9 +5,15 @@
 #include <uv.h>
 
 typedef struct {
-  uv_tty_t tty;
-  uv_buf_t read_buf;
-  uv_shutdown_t end;
+  uv_tty_t handle;
+
+  struct {
+    uv_write_t write;
+    uv_shutdown_t shutdown;
+  } requests;
+
+  uv_buf_t read;
+
   js_env_t *env;
   js_ref_t *ctx;
   js_ref_t *on_write;
@@ -20,27 +26,41 @@ static void
 on_write (uv_write_t *req, int status) {
   int err;
 
-  bare_tty_t *self = (bare_tty_t *) req->data;
+  bare_tty_t *tty = (bare_tty_t *) req->data;
 
-  js_env_t *env = self->env;
+  js_env_t *env = tty->env;
 
   js_handle_scope_t *scope;
   err = js_open_handle_scope(env, &scope);
   assert(err == 0);
 
   js_value_t *ctx;
-  err = js_get_reference_value(env, self->ctx, &ctx);
+  err = js_get_reference_value(env, tty->ctx, &ctx);
   assert(err == 0);
 
-  js_value_t *callback;
-  err = js_get_reference_value(env, self->on_write, &callback);
+  js_value_t *on_write;
+  err = js_get_reference_value(env, tty->on_write, &on_write);
   assert(err == 0);
 
   js_value_t *argv[1];
-  err = js_create_int32(env, status, &argv[0]);
-  assert(err == 0);
 
-  js_call_function(env, ctx, callback, 1, argv, NULL);
+  if (status < 0) {
+    js_value_t *code;
+    err = js_create_string_utf8(env, (utf8_t *) uv_err_name(status), -1, &code);
+    assert(err == 0);
+
+    js_value_t *message;
+    err = js_create_string_utf8(env, (utf8_t *) uv_strerror(status), -1, &message);
+    assert(err == 0);
+
+    err = js_create_error(env, code, message, &argv[0]);
+    assert(err == 0);
+  } else {
+    err = js_get_null(env, &argv[0]);
+    assert(err == 0);
+  }
+
+  js_call_function(env, ctx, on_write, 1, argv, NULL);
 
   err = js_close_handle_scope(env, scope);
   assert(err == 0);
@@ -50,27 +70,41 @@ static void
 on_shutdown (uv_shutdown_t *req, int status) {
   int err;
 
-  bare_tty_t *self = (bare_tty_t *) req->data;
+  bare_tty_t *tty = (bare_tty_t *) req->data;
 
-  js_env_t *env = self->env;
+  js_env_t *env = tty->env;
 
   js_handle_scope_t *scope;
   err = js_open_handle_scope(env, &scope);
   assert(err == 0);
 
   js_value_t *ctx;
-  err = js_get_reference_value(env, self->ctx, &ctx);
+  err = js_get_reference_value(env, tty->ctx, &ctx);
   assert(err == 0);
 
-  js_value_t *callback;
-  err = js_get_reference_value(env, self->on_end, &callback);
+  js_value_t *on_end;
+  err = js_get_reference_value(env, tty->on_end, &on_end);
   assert(err == 0);
 
   js_value_t *argv[1];
-  err = js_create_int32(env, status, &argv[0]);
-  assert(err == 0);
 
-  js_call_function(env, ctx, callback, 1, argv, NULL);
+  if (status < 0) {
+    js_value_t *code;
+    err = js_create_string_utf8(env, (utf8_t *) uv_err_name(status), -1, &code);
+    assert(err == 0);
+
+    js_value_t *message;
+    err = js_create_string_utf8(env, (utf8_t *) uv_strerror(status), -1, &message);
+    assert(err == 0);
+
+    err = js_create_error(env, code, message, &argv[0]);
+    assert(err == 0);
+  } else {
+    err = js_get_null(env, &argv[0]);
+    assert(err == 0);
+  }
+
+  js_call_function(env, ctx, on_end, 1, argv, NULL);
 
   err = js_close_handle_scope(env, scope);
   assert(err == 0);
@@ -83,27 +117,47 @@ on_read (uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) {
 
   int err;
 
-  bare_tty_t *self = (bare_tty_t *) stream;
+  bare_tty_t *tty = (bare_tty_t *) stream;
 
-  js_env_t *env = self->env;
+  js_env_t *env = tty->env;
 
   js_handle_scope_t *scope;
   err = js_open_handle_scope(env, &scope);
   assert(err == 0);
 
   js_value_t *ctx;
-  err = js_get_reference_value(env, self->ctx, &ctx);
+  err = js_get_reference_value(env, tty->ctx, &ctx);
   assert(err == 0);
 
-  js_value_t *callback;
-  err = js_get_reference_value(env, self->on_read, &callback);
+  js_value_t *on_read;
+  err = js_get_reference_value(env, tty->on_read, &on_read);
   assert(err == 0);
 
-  js_value_t *argv[1];
-  err = js_create_int32(env, nread, &argv[0]);
-  assert(err == 0);
+  js_value_t *argv[2];
 
-  js_call_function(env, ctx, callback, 1, argv, NULL);
+  if (nread < 0) {
+    js_value_t *code;
+    err = js_create_string_utf8(env, (utf8_t *) uv_err_name(nread), -1, &code);
+    assert(err == 0);
+
+    js_value_t *message;
+    err = js_create_string_utf8(env, (utf8_t *) uv_strerror(nread), -1, &message);
+    assert(err == 0);
+
+    err = js_create_error(env, code, message, &argv[0]);
+    assert(err == 0);
+
+    err = js_create_int32(env, 0, &argv[1]);
+    assert(err == 0);
+  } else {
+    err = js_get_null(env, &argv[0]);
+    assert(err == 0);
+
+    err = js_create_int32(env, nread, &argv[1]);
+    assert(err == 0);
+  }
+
+  js_call_function(env, ctx, on_read, 1, argv, NULL);
 
   err = js_close_handle_scope(env, scope);
   assert(err == 0);
@@ -113,37 +167,37 @@ static void
 on_close (uv_handle_t *handle) {
   int err;
 
-  bare_tty_t *self = (bare_tty_t *) handle;
+  bare_tty_t *tty = (bare_tty_t *) handle;
 
-  js_env_t *env = self->env;
+  js_env_t *env = tty->env;
 
   js_handle_scope_t *scope;
   err = js_open_handle_scope(env, &scope);
   assert(err == 0);
 
   js_value_t *ctx;
-  err = js_get_reference_value(env, self->ctx, &ctx);
+  err = js_get_reference_value(env, tty->ctx, &ctx);
   assert(err == 0);
 
   js_value_t *callback;
-  err = js_get_reference_value(env, self->on_close, &callback);
+  err = js_get_reference_value(env, tty->on_close, &callback);
   assert(err == 0);
 
   js_call_function(env, ctx, callback, 0, NULL, NULL);
 
-  err = js_delete_reference(env, self->on_write);
+  err = js_delete_reference(env, tty->on_write);
   assert(err == 0);
 
-  err = js_delete_reference(env, self->on_end);
+  err = js_delete_reference(env, tty->on_end);
   assert(err == 0);
 
-  err = js_delete_reference(env, self->on_read);
+  err = js_delete_reference(env, tty->on_read);
   assert(err == 0);
 
-  err = js_delete_reference(env, self->on_close);
+  err = js_delete_reference(env, tty->on_close);
   assert(err == 0);
 
-  err = js_delete_reference(env, self->ctx);
+  err = js_delete_reference(env, tty->ctx);
   assert(err == 0);
 
   err = js_close_handle_scope(env, scope);
@@ -152,89 +206,83 @@ on_close (uv_handle_t *handle) {
 
 static void
 on_alloc (uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
-  bare_tty_t *self = (bare_tty_t *) handle;
-  *buf = self->read_buf;
+  bare_tty_t *tty = (bare_tty_t *) handle;
+
+  *buf = tty->read;
 }
 
 static js_value_t *
 bare_tty_init (js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 8;
-  js_value_t *argv[8];
+  size_t argc = 7;
+  js_value_t *argv[7];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 8);
+  assert(argc == 7);
 
   uv_loop_t *loop;
   js_get_env_loop(env, &loop);
 
-  bare_tty_t *self;
-  err = js_get_typedarray_info(env, argv[0], NULL, (void **) &self, NULL, NULL, NULL);
-  assert(err == 0);
+  js_value_t *handle;
 
-  size_t read_buf_len;
-  char *read_buf;
-  err = js_get_typedarray_info(env, argv[1], NULL, (void **) &read_buf, &read_buf_len, NULL, NULL);
+  bare_tty_t *tty;
+  err = js_create_arraybuffer(env, sizeof(bare_tty_t), (void **) &tty, &handle);
   assert(err == 0);
 
   uint32_t fd;
-  err = js_get_value_uint32(env, argv[2], &fd);
+  err = js_get_value_uint32(env, argv[0], &fd);
   assert(err == 0);
 
-  err = uv_tty_init(loop, &self->tty, fd, 1);
+  err = uv_tty_init(loop, &tty->handle, fd, 1);
 
   if (err < 0) {
     js_throw_error(env, uv_err_name(err), uv_strerror(err));
     return NULL;
   }
 
-  self->env = env;
+  tty->env = env;
 
-  self->read_buf = uv_buf_init(read_buf, read_buf_len);
+  err = js_get_typedarray_info(env, argv[1], NULL, (void **) &tty->read.base, &tty->read.len, NULL, NULL);
+  assert(err == 0);
 
-  err = js_create_reference(env, argv[3], 1, &self->ctx);
+  err = js_create_reference(env, argv[2], 1, &tty->ctx);
   assert(err == 0);
 
-  err = js_create_reference(env, argv[4], 1, &self->on_write);
+  err = js_create_reference(env, argv[3], 1, &tty->on_write);
   assert(err == 0);
 
-  err = js_create_reference(env, argv[5], 1, &self->on_end);
+  err = js_create_reference(env, argv[4], 1, &tty->on_end);
   assert(err == 0);
 
-  err = js_create_reference(env, argv[6], 1, &self->on_read);
+  err = js_create_reference(env, argv[5], 1, &tty->on_read);
   assert(err == 0);
 
-  err = js_create_reference(env, argv[7], 1, &self->on_close);
+  err = js_create_reference(env, argv[6], 1, &tty->on_close);
   assert(err == 0);
 
-  return NULL;
+  return handle;
 }
 
 static js_value_t *
 bare_tty_writev (js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 3;
-  js_value_t *argv[3];
+  size_t argc = 2;
+  js_value_t *argv[2];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 3);
-
-  uv_write_t *req;
-  err = js_get_typedarray_info(env, argv[0], NULL, (void **) &req, NULL, NULL, NULL);
-  assert(err == 0);
+  assert(argc == 2);
 
-  bare_tty_t *self;
-  err = js_get_typedarray_info(env, argv[1], NULL, (void **) &self, NULL, NULL, NULL);
+  bare_tty_t *tty;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &tty, NULL);
   assert(err == 0);
 
-  js_value_t *arr = argv[2];
-  js_value_t *item;
+  js_value_t *arr = argv[1];
 
   uint32_t bufs_len;
   err = js_get_array_length(env, arr, &bufs_len);
@@ -243,6 +291,7 @@ bare_tty_writev (js_env_t *env, js_callback_info_t *info) {
   uv_buf_t *bufs = malloc(sizeof(uv_buf_t) * bufs_len);
 
   for (uint32_t i = 0; i < bufs_len; i++) {
+    js_value_t *item;
     err = js_get_element(env, arr, i, &item);
     assert(err == 0);
 
@@ -251,9 +300,11 @@ bare_tty_writev (js_env_t *env, js_callback_info_t *info) {
     assert(err == 0);
   }
 
-  req->data = self;
+  uv_write_t *req = &tty->requests.write;
+
+  req->data = tty;
 
-  err = uv_write(req, (uv_stream_t *) &self->tty, bufs, bufs_len, on_write);
+  err = uv_write(req, (uv_stream_t *) &tty->handle, bufs, bufs_len, on_write);
 
   free(bufs);
 
@@ -277,15 +328,15 @@ bare_tty_end (js_env_t *env, js_callback_info_t *info) {
 
   assert(argc == 1);
 
-  bare_tty_t *self;
-  err = js_get_typedarray_info(env, argv[0], NULL, (void **) &self, NULL, NULL, NULL);
+  bare_tty_t *tty;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &tty, NULL);
   assert(err == 0);
 
-  uv_shutdown_t *req = &self->end;
+  uv_shutdown_t *req = &tty->requests.shutdown;
 
-  req->data = self;
+  req->data = tty;
 
-  err = uv_shutdown(req, (uv_stream_t *) self, on_shutdown);
+  err = uv_shutdown(req, (uv_stream_t *) &tty->handle, on_shutdown);
 
   if (err < 0) {
     js_throw_error(env, uv_err_name(err), uv_strerror(err));
@@ -307,11 +358,13 @@ bare_tty_resume (js_env_t *env, js_callback_info_t *info) {
 
   assert(argc == 1);
 
-  bare_tty_t *self;
-  err = js_get_typedarray_info(env, argv[0], NULL, (void **) &self, NULL, NULL, NULL);
+  bare_tty_t *tty;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &tty, NULL);
   assert(err == 0);
 
-  err = uv_read_start((uv_stream_t *) &self->tty, on_alloc, on_read);
+  if (!uv_is_readable((uv_stream_t *) &tty->handle)) return NULL;
+
+  err = uv_read_start((uv_stream_t *) &tty->handle, on_alloc, on_read);
 
   if (err < 0) {
     js_throw_error(env, uv_err_name(err), uv_strerror(err));
@@ -333,11 +386,13 @@ bare_tty_pause (js_env_t *env, js_callback_info_t *info) {
 
   assert(argc == 1);
 
-  bare_tty_t *self;
-  err = js_get_typedarray_info(env, argv[0], NULL, (void **) &self, NULL, NULL, NULL);
+  bare_tty_t *tty;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &tty, NULL);
   assert(err == 0);
 
-  err = uv_read_stop((uv_stream_t *) &self->tty);
+  if (!uv_is_readable((uv_stream_t *) &tty->handle)) return NULL;
+
+  err = uv_read_stop((uv_stream_t *) &tty->handle);
 
   if (err < 0) {
     js_throw_error(env, uv_err_name(err), uv_strerror(err));
@@ -359,11 +414,11 @@ bare_tty_close (js_env_t *env, js_callback_info_t *info) {
 
   assert(argc == 1);
 
-  bare_tty_t *self;
-  err = js_get_typedarray_info(env, argv[0], NULL, (void **) &self, NULL, NULL, NULL);
+  bare_tty_t *tty;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &tty, NULL);
   assert(err == 0);
 
-  uv_close((uv_handle_t *) &self->tty, on_close);
+  uv_close((uv_handle_t *) &tty->handle, on_close);
 
   return NULL;
 }
@@ -390,15 +445,15 @@ bare_tty_set_mode (js_env_t *env, js_callback_info_t *info) {
 
   assert(argc == 2);
 
-  bare_tty_t *self;
-  err = js_get_typedarray_info(env, argv[0], NULL, (void **) &self, NULL, NULL, NULL);
+  bare_tty_t *tty;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &tty, NULL);
   assert(err == 0);
 
   uint32_t mode;
   err = js_get_value_uint32(env, argv[1], &mode);
   assert(err == 0);
 
-  err = uv_tty_set_mode(&self->tty, mode);
+  err = uv_tty_set_mode(&tty->handle, mode);
 
   if (err < 0) {
     js_throw_error(env, uv_err_name(err), uv_strerror(err));
@@ -410,16 +465,6 @@ bare_tty_set_mode (js_env_t *env, js_callback_info_t *info) {
 
 static js_value_t *
 init (js_env_t *env, js_value_t *exports) {
-  {
-    js_value_t *val;
-    js_create_uint32(env, sizeof(bare_tty_t), &val);
-    js_set_named_property(env, exports, "sizeofTTY", val);
-  }
-  {
-    js_value_t *val;
-    js_create_uint32(env, sizeof(uv_write_t), &val);
-    js_set_named_property(env, exports, "sizeofWrite", val);
-  }
   {
     js_value_t *fn;
     js_create_function(env, "init", -1, bare_tty_init, NULL, &fn);

package/index.js

@@ -6,14 +6,13 @@ const DEFAULT_READ_BUFFER = 65536
 process.on('exit', () => binding.reset())
 
 module.exports = exports = class TTY extends Duplex {
-  constructor (fd, { readBufferSize = DEFAULT_READ_BUFFER, allowHalfOpen = true } = {}) {
+  constructor (fd, opts = {}) {
     super({ mapWritable })
 
-    const slab = Buffer.alloc(binding.sizeofTTY + binding.sizeofWrite + readBufferSize)
-
-    this._handle = slab.subarray(0, binding.sizeofTTY)
-    this._req = slab.subarray(binding.sizeofTTY, binding.sizeofTTY + binding.sizeofWrite)
-    this._buffer = slab.subarray(binding.sizeofTTY + binding.sizeofWrite)
+    const {
+      readBufferSize = DEFAULT_READ_BUFFER,
+      allowHalfOpen = true
+    } = opts
 
     this._writeCallback = null
     this._finalCallback = null
@@ -21,7 +20,9 @@ module.exports = exports = class TTY extends Duplex {
 
     this._allowHalfOpen = allowHalfOpen
 
-    binding.init(this._handle, this._buffer, fd, this,
+    this._buffer = Buffer.alloc(readBufferSize)
+
+    this._handle = binding.init(fd, this._buffer, this,
       this._onwrite,
       this._onfinal,
       this._onread,
@@ -36,7 +37,7 @@ module.exports = exports = class TTY extends Duplex {
 
   _writev (datas, cb) {
     this._writeCallback = cb
-    binding.writev(this._req, this._handle, datas)
+    binding.writev(this._handle, datas)
   }
 
   _final (cb) {
@@ -70,20 +71,19 @@ module.exports = exports = class TTY extends Duplex {
     cb(null)
   }
 
-  _onwrite (status) {
-    const err = status < 0 ? makeError(status) : null
+  _onwrite (err) {
     this._continueWrite(err)
   }
 
-  _onread (read) {
-    if (read === 0) {
-      this.push(null)
-      if (this._allowHalfOpen === false) this.end()
+  _onread (err, read) {
+    if (err) {
+      this.destroy(err)
       return
     }
 
-    if (read < 0) {
-      this.destroy(makeError(read))
+    if (read === 0) {
+      this.push(null)
+      if (this._allowHalfOpen === false) this.end()
       return
     }
 
@@ -93,8 +93,7 @@ module.exports = exports = class TTY extends Duplex {
     this.push(copy)
   }
 
-  _onfinal (status) {
-    const err = status < 0 ? makeError(status) : null
+  _onfinal (err) {
     this._continueFinal(err)
   }
 
@@ -117,13 +116,3 @@ exports.constants = {
 function mapWritable (buf) {
   return typeof buf === 'string' ? Buffer.from(buf) : buf
 }
-
-function makeError (errno) {
-  const [code, msg] = process.errnos.get(errno)
-  const err = new Error(code + ': ' + msg)
-
-  err.code = code
-  err.errno = errno
-
-  return err
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-tty",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Native TTY streams for JavaScript",
   "main": "index.js",
   "files": [
@@ -11,9 +11,7 @@
     "prebuilds"
   ],
   "scripts": {
-    "test": "standard && bare test.js",
-    "install": "bare-dev rebuild",
-    "prebuild": "bare-dev prebuild"
+    "test": "standard && bare test.js"
   },
   "repository": {
     "type": "git",