js/modules, fix 'self', change some of the wording in the docs

Author: Face Kapow

CONTRIBUTING.md

@@ -1,12 +1,12 @@
 # Contributing to runtime.js
 
-Firstly, thanks for deciding to contribute! :+1:
+First off, thanks for deciding to contribute! :+1:
 
 ## Got an issue?
 
  * Make sure the issue isn't already reported by checking in [Issues](https://github.com/runtimejs/runtime/issues).
  * Include the version of the kernel and JavaScript library in the issue description.
- * Include a description of what happens or what the issue/bug does and what the expected behavior is.
+ * Include a description of what happens and what the expected behavior is.
 
 ## Cool feature request?
 

docs/code-style-exceptions.md

@@ -16,7 +16,7 @@ You can still use `for-in`, just be sure you know [the catch](https://developer.
 
 You *can* use 'dangling' underscores to denote a private member on an object or class.
 Some APIs were written before this style was adopted which use underscores for private members and probably won't be changed for compatability.
-However, for any new APIs, it'd be prefered to use a [`Symbol`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol) instead, like:
+However, for any new APIs, it'd be preferred to use a [`Symbol`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol) instead, like:
 
 ```js
 const somePrivateVarName = Symbol('somePrivateVarName');
@@ -30,3 +30,7 @@ class Demo {
   }
 }
 ```
+
+## Using `get` and `set`
+
+You can (and should) use ES6 `get` and `set`, it's already used in various runtime.js APIs.

js/__loader.js

@@ -225,7 +225,6 @@ ${content}
     constants: 'constants-browserify',
     fs: './modules/fs.js',
     os: './modules/os.js',
-    __errors__: './modules/errors.js',
     net: './modules/net.js',
     dns: './modules/dns.js',
     punycode: 'punycode',
@@ -273,6 +272,5 @@ ${content}
   process.termout = new TermoutStream();
   process.termerr = new TermerrStream();
   loader.require('console');
-  Object.assign(global, loader.require('__errors__'));
   loader.require('/');
 })();

js/driver/virtio/vring/index.js

@@ -111,14 +111,14 @@ class VRing {
     return true;
   }
   getBuffer() {
-    const hasUnprocessed = self.usedRing.hasUnprocessedBuffers();
+    const hasUnprocessed = this.usedRing.hasUnprocessedBuffers();
     if (!hasUnprocessed) return null;
 
     const used = this.usedRing.getUsedDescriptor();
     if (used === null) return null;
 
     const descriptorId = used.id;
-    const buffer = self.descriptorTable.getBuffer(descriptorId);
+    const buffer = this.descriptorTable.getBuffer(descriptorId);
     const len = used.len;
 
     this.availableRing.setEventIdx(this.usedRing.lastUsedIndex + 1);
@@ -128,7 +128,7 @@ class VRing {
       console.log('VRING ERROR: buffer is not a Uint8Array');
       console.log('used.descriptor id ', descriptorId);
       console.log('used.len ', len);
-      console.log('last used index ', self.usedRing.lastUsedIndex);
+      console.log('last used index ', this.usedRing.lastUsedIndex);
       return null;
     }
 

js/modules/console.js

@@ -14,19 +14,27 @@
 'use strict';
 
 const util = require('util');
+const stream = require('stream');
 
 class Console {
   constructor(stdout, stderr) {
-    if (!stdout) throw new Error('Console: Must provide a stdout stream to the constructor.');
+    if (!stdout || (!(stdout instanceof stream.Writable) && !(stdout instanceof stream.Duplex))) {
+      throw new TypeError('Console expects a writable stream instance');
+    }
     this._stdout = stdout;
-    if (stderr) this._stderr = stderr;
+    if (stderr) {
+      if (!(stderr instanceof stream.Writable) && !(stderr instanceof stream.Duplex)) {
+        throw new TypeError('Console expects writable stream instances');
+      }
+      this._stderr = stderr;
+    }
     this._labels = {};
   }
   assert(val, ...data) {
     if (!val) throw new Error(util.format(...data));
   }
-  dir(obj, opts) {
-    opts = opts || {};
+  dir(obj, optsOpt = {}) {
+    const opts = optsOpt;
     opts.customInspect = true;
     this._stdout.write(util.inspect(obj, opts));
   }
@@ -37,18 +45,16 @@ class Console {
   log(...data) {
     this._stdout.write(`${util.format(...data)}\n`);
   }
-  time(label) {
-    if (!label) label = 'undefined';
+  time(label = 'undefined') {
     this._labels[label] = Date.now();
   }
-  timeEnd(label) {
-    if (!label) label = 'undefined'
-    if (!this._labels[label]) throw new Error('Console.timeEnd: Label does not exist.');
-    this._stdout.write(`${label}: ${Date.now()-this._labels[label]}ms\n`);
+  timeEnd(label = 'undefined') {
+    if (!this._labels[label]) process.emitWarning(`No such label ${label} for console.timeEnd()`);
+    this._stdout.write(`${label}: ${Date.now() - this._labels[label]}ms\n`);
   }
   trace(...data) {
     let trace = (new Error()).stack;
-    let arr = trace.split('\n');
+    const arr = trace.split('\n');
     arr[0] = 'Trace';
     if (data.length > 0) arr[0] += `: ${util.format(...data)}`;
     trace = arr.join('\n');
@@ -62,5 +68,18 @@ class Console {
   }
 }
 
-module.exports = Console;
 global.console = new Console(process.stdout, process.stderr);
+
+const bound = [
+  'assert',
+  'dir',
+  'error',
+  'log',
+  'time',
+  'timeEnd',
+  'trace',
+  'info',
+  'warn',
+];
+for (const item of bound) module.exports[item] = console[item].bind(console);
+module.exports.Console = Console;

js/modules/dns.js

@@ -13,38 +13,48 @@
 // limitations under the License.
 'use strict';
 
-Object.assign(exports, {
-  NODATA: 'ENODATA',
-  BADFAMILY: 'EBADFAMILY',
-  FORMERR: 'EFORMERR',
-  SERVFAIL: 'ESERVFAIL',
-  NOTFOUND: 'ENOTFOUND',
-  NOTIMP: 'ENOTIMP',
-  REFUSED: 'EREFUSED',
-  BADQUERY: 'EBADQUERY',
-  BADNAME: 'EBADNAME',
-  BADRESP: 'EBADRESP',
-  CONNREFUSED: 'ECONNREFUSED',
-  TIMEOUT: 'ETIMEOUT',
-  EOF: 'EEOF',
-  FILE: 'EFILE',
-  NOMEM: 'ENOMEM',
-  DESTRUCTION: 'EDESTRUCTION',
-  BADSTR: 'EBADSTR',
-  BADFLAGS: 'EBADFLAGS',
-  NONAME: 'ENONAME',
-  BADHINTS: 'EBADHINTS',
-  NOTINITIALIZED: 'ENOTINITIALIZED',
-  LOADIPHLPAPI: 'ELOADIPHLPAPI',
-  ADDRGETNETWORKPARAMS: 'EADDRGETNETWORKPARAMS',
-  CANCELLED: 'ECANCELLED'
-});
+const { SystemError } = require('./errors');
 
-let servers = [
-  '8.8.8.8'
+const names = [
+  'NODATA',
+  'BADFAMILY',
+  'FORMERR',
+  'SERVFAIL',
+  'NOTFOUND',
+  'NOTIMP',
+  'REFUSED',
+  'BADQUERY',
+  'BADNAME',
+  'BADRESP',
+  'CONNREFUSED',
+  'TIMEOUT',
+  'EOF',
+  'FILE',
+  'NOMEM',
+  'DESTRUCTION',
+  'BADSTR',
+  'BADFLAGS',
+  'NONAME',
+  'BADHINTS',
+  'NOTINITIALIZED',
+  'LOADIPHLPAPI',
+  'ADDRGETNETWORKPARAMS',
+  'CANCELLED',
 ];
+for (const name of names) exports[name] = `E${name}`;
 
-function lookup(hostname, opts, cb) {
+const servers = [
+  '8.8.8.8',
+];
+
+const throwIPv6Err = (cb) => {
+  const err = new SystemError('runtime doesn\'t support IPv6', exports.BADFAMILY);
+  if (cb) return cb(err);
+  throw err;
+};
+
+const lookup = (hostname, optsOpt, cb) => {
+  const opts = optsOpt;
   if (opts.family && opts.family === 6) return throwIPv6Err(cb);
   opts.query = opts.query || 'A';
   if (hostname === 'localhost' && opts.query === 'A') {
@@ -54,24 +64,23 @@ function lookup(hostname, opts, cb) {
       if (opts.addrOnly) {
         if (cb) cb(null, ['127.0.0.1']);
       } else {
-        if (cb) cb(null, [{address: '127.0.0.1', family: 4}]);
+        if (cb) cb(null, [{ address: '127.0.0.1', family: 4 }]);
       }
     }
     return;
   }
   runtime.dns.resolve(hostname, {
-    query: opts.query
-  }, function(err, data) {
+    query: opts.query,
+  }, (err, data) => {
     if (err) {
       if (cb) cb(err, null, null);
       return;
     }
-    var res;
-    var ret = [];
-    for (var i = 0; i < data.results.length; i++) {
-      res = data.results[i];
+    const ret = [];
+    for (const i of Object.keys(data.results)) {
+      const res = data.results[i];
       if (!opts.all && i === 0) {
-        var addr = res.address.join('.');
+        const addr = res.address.join('.');
         if (cb) cb(null, addr, 4);
         break;
       } else {
@@ -82,10 +91,12 @@ function lookup(hostname, opts, cb) {
             } else {
               ret.push({
                 address: res.address.join('.'),
-                family: 4
+                family: 4,
               });
             }
             break;
+          default:
+            break;
         }
       }
     }
@@ -95,56 +106,45 @@ function lookup(hostname, opts, cb) {
     }
     if (cb) cb(null, ret);
   });
-}
-
-function throwIPv6Err(cb) {
-  var err = new SystemError('runtime doesn\'t support IPv6', exports.BADFAMILY);
-  if (cb) return cb(err);
-  throw err;
-}
+};
 
-exports.getServers = function() {
-  return servers;
-}
+exports.getServers = () => servers;
 
-exports.lookup = function(hostname, opts, cb) {
+exports.lookup = (hostname, optsOpt, cbOpt) => {
+  let opts = optsOpt;
+  let cb = cbOpt;
   if (typeof opts === 'function') {
     cb = opts;
     opts = null;
   }
   if (typeof opts === 'undefined' || opts === null) opts = {};
   if (typeof opts === 'number' || opts instanceof Number) {
     opts = {
-      family: opts
+      family: opts,
     };
   }
 
   return lookup(hostname, opts, cb);
-}
+};
 
-exports.resolve4 = function(hostname, cb) {
-  return lookup(hostname, {
-    all: true,
-    addrOnly: true
-  }, cb);
-}
+exports.resolve4 = (hostname, cb) => lookup(hostname, {
+  all: true,
+  addrOnly: true,
+}, cb);
 
-exports.resolve6 = function(hostname, cb) {
-  throwIPv6Err(cb);
-}
+exports.resolve6 = (hostname, cb) => throwIPv6Err(cb);
 
-exports.resolve = function(hostname, rrtype, cb) {
+exports.resolve = (hostname, rrtypeOpt, cbOpt) => {
+  let rrtype = rrtypeOpt;
+  let cb = cbOpt;
   if (typeof rrtype === 'function') {
     cb = rrtype;
     rrtype = null;
   }
   if (typeof rrtype === 'undefined' || rrtype === null) rrtype = 'A';
-  switch (rrtype) {
-    case 'A':
-      return exports.resolve4(hostname, cb);
-      break;
-    case 'AAAA':
-      return exports.resolve6(hostname, cb);
-      break;
+  if (rrtype === 'A') {
+    return exports.resolve4(hostname, cb);
+  } else if (rrtype === 'AAAA') {
+    return exports.resolve6(hostname, cb);
   }
-}
+};

js/modules/errors.js

@@ -17,11 +17,11 @@ exports.Error = Error;
 
 class SystemError {
   constructor(message, errcode, call) {
-    var msg = '';
+    let msg = '';
     if (errcode) msg += `${errcode}: `;
     if (message) msg += message;
     if (call) msg += `, ${call}`;
-    var err = new Error(msg);
+    const err = new Error(msg);
     err.code = errcode || '';
     err.syscall = call || '';
     return err;