nsh updates

.gitignore

@@ -1 +1,2 @@
 node_modules
+npm-debug.log

.travis.yml

@@ -0,0 +1,16 @@
+language: node_js
+node_js:
+  - "6"
+  - "6.1"
+  - "5.11"
+  - "iojs"
+env:
+  - CXX=g++-4.8
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+    packages:
+      - g++-4.8
+after_script:
+  - npm run coveralls

README.md

@@ -1,16 +1,12 @@
-# No(de) Shell
+[![Build Status](https://travis-ci.org/piranna/nsh.svg?branch=master)](https://travis-ci.org/piranna/nsh)
+[![Coverage Status](https://coveralls.io/repos/github/piranna/nsh/badge.svg?branch=master)](https://coveralls.io/github/piranna/nsh?branch=master)
 
-<a href="http://nodeos.github.io"><img src="http://i.imgur.com/pIJu2TS.png" width=200 height=79/></a>
+# Node SHell
 
-Both **no shell** or **node shell** accurately describe `nsh`.
+[![Built for NodeOS](http://i.imgur.com/pIJu2TS.png)](http://nodeos.github.io)
 
-The goal of `nsh` is to provide a basic shell that will run without having `bash` or another process tidy things up first.
-
-The shell needs to be able to nest without mixing up who gets what keyboard input.
-The shell should also be able to run interactive programs like *vim*.
-
-Right now node doesn't support doing proper job control, although I have a pull-request into libuv about that.
-
-- https://github.com/joyent/libuv/pull/934
-
-Features are welcome, but may not be added until I'm sure the basics are stable.
+`nsh` is a basic POSIX compliant shell that will run without having `bash` or
+another process tidy things up first. It's also `require()`able and embedable on
+other projects like [blesh](https://github.com/piranna/blesh), and has a
+collection of basic commands as build-in functions running on the same shell
+process powered by [Coreutils.js](https://github.com/piranna/Coreutils.js).

lib/ast2js/_environment.js

@@ -0,0 +1,85 @@
+'use strict'
+
+var environment =
+{
+  '?': 0,
+  PS1: '\\w > ',
+  PS2: '> ',
+  PS4: '+ '
+}
+
+
+//
+// Regular access
+//
+
+const handler =
+{
+  ownKeys: function()
+  {
+    return Object.keys(environment)
+  },
+
+  get: function(_, prop)
+  {
+    var value = environment[prop]
+
+    if(value === undefined) value = process.env[prop]
+    if(value == null) value = ''
+
+    return value
+  },
+
+  set: function(_, prop, value)
+  {
+    if(value === undefined) return this.deleteProperty(_, prop)
+
+    // Exported environment variable
+    const env = process.env
+    if(env[prop] !== undefined)
+      env[prop] = value
+
+    // Local environment variable
+    else
+      environment[prop] = value
+
+    return true
+  },
+
+  deleteProperty: function(_, prop)
+  {
+    // Local environment variable
+    var value = environment[prop]
+    if(value !== undefined)
+      delete environment[prop]
+
+    // Exported environment variable
+    else
+      delete process.env[prop]
+
+    return true
+  }
+}
+
+
+exports = new Proxy({}, handler)
+
+
+//
+// Stacked environment variables
+//
+
+exports.push = function()
+{
+  process.env = {__proto__: process.env}
+  environment = {__proto__: environment}
+}
+
+exports.pop = function()
+{
+  process.env = process.env.__proto__
+  environment = environment.__proto__
+}
+
+
+module.exports = exports

lib/ast2js/_execCommands.js

@@ -0,0 +1,43 @@
+const eachSeries = require('async/eachSeries')
+
+
+module.exports = execCommands
+
+const ast2js      = require('./index')
+const environment = require('./_environment')
+
+
+// Always calculate dynamic `$PATH` based on the original one
+const npmPath = require('npm-path').bind(null, {env:{PATH:process.env.PATH}})
+
+
+function execCommands(stdio, commands, callback)
+{
+  eachSeries(commands, function(command, callback)
+  {
+    // `$PATH` is dynamic based on current directory and any command could
+    // change it, so we update it previously to exec any of them
+    npmPath()
+
+    command.stdio = stdio
+
+    ast2js(command, function(error, command)
+    {
+      if(error) return callback(error)
+
+      if(command == null) return callback()
+
+      command.once('error', callback)
+      .once('exit', function(code, signal)
+      {
+        environment['?']  = code
+        environment['??'] = signal
+
+        this.removeListener('error', callback)
+
+        callback(code || signal)
+      })
+    })
+  },
+  callback)
+}

lib/ast2js/_redirects.js

@@ -0,0 +1,73 @@
+var reduce = require('async').reduce
+
+var ast2js = require('./index')
+
+
+function filterPipes(item)
+{
+  return item.type === 'pipe'
+}
+
+function getSrcFd(stdio, fd)
+{
+  var result = stdio[fd]
+
+  if(typeof result === 'string') return fd
+
+  return result
+}
+
+function setOutput(item)
+{
+  item.command.output = this
+}
+
+
+function iterator(stdio, redirect, callback)
+{
+  ast2js(redirect, function(error, value)
+  {
+    if(error) return callback(error)
+
+    var type = redirect.type
+    switch(type)
+    {
+      case 'duplicateFd':
+        stdio[redirect.destFd] = getSrcFd(stdio, redirect.srcFd)
+      break;
+
+      case 'moveFd':
+        stdio[redirect.dest] = getSrcFd(stdio, redirect.fd)
+        stdio[redirect.fd]   = 'ignore'
+      break;
+
+      case 'pipe':
+        stdio[1] = value
+      break;
+
+      case 'redirectFd':
+        stdio[redirect.fd] = value
+
+        if(redirect.op === '&>'
+        || redirect.op === '&>>')
+          stdio[2] = value
+      break;
+
+      default:
+        return callback('Unknown redirect type "'+type+'"')
+    }
+
+    callback(null, stdio)
+  })
+}
+
+
+function redirects(stdio, array, callback)
+{
+  array.filter(filterPipes).forEach(setOutput, stdio.stdout)
+
+  reduce(array, stdio.slice(), iterator, callback)
+}
+
+
+module.exports = redirects

lib/ast2js/_spawnStream.js

@@ -0,0 +1,147 @@
+const EventEmitter = require('events')
+const spawn        = require('child_process').spawn
+const stream       = require('stream')
+
+const Duplex   = stream.Duplex
+const Readable = stream.Readable
+const Writable = stream.Writable
+
+
+function noop(){}
+
+/**
+ * Node.js `spawn` only accept streams with a file descriptor as stdio, so use
+ * pipes instead and connect the given streams to them.
+ */
+function wrapStdio(command, argv, options)
+{
+  argv    = argv    || []
+  options = options || {}
+
+  var stdio = options.stdio
+  if(!stdio) options.stdio = stdio = []
+
+  var stdin  = stdio[0]
+  var stdout = stdio[1]
+  var stderr = stdio[2]
+
+  // Wrap stdio
+  if(typeof stdin === 'string' || typeof stdin === 'number'
+  || stdin && stdin.constructor.name === 'ReadStream')
+    stdin = null
+  else
+    stdio[0] = 'pipe'
+
+  if(typeof stdout === 'string' || typeof stdout === 'number'
+  || stdout && stdout.constructor.name === 'WriteStream')
+    stdout = null
+  else
+    stdio[1] = 'pipe'
+
+  if(typeof stderr === 'string' || typeof stderr === 'number'
+  || stderr && stderr.constructor.name === 'WriteStream')
+    stderr = null
+  else
+    stdio[2] = 'pipe'
+
+  // Create child process
+  var cp = spawn(command, argv, options)
+
+  // Adjust events, pipe streams and restore stdio
+  if(stdin != null)
+  {
+    stdin.pipe(cp.stdin)
+    cp.stdin = null
+  }
+  if(stdout != null)
+  {
+    cp.stdout.pipe(stdout)
+    cp.stdout = null
+  }
+  if(stderr != null)
+  {
+    cp.stderr.pipe(stderr)
+    cp.stderr = null
+  }
+
+  // Return child process
+  return cp
+}
+
+
+function spawnStream(command, argv, options)
+{
+  if(argv && argv.constructor.name === 'Object')
+  {
+    options = argv
+    argv = undefined
+  }
+
+  options = options || {}
+  var stdio = options.stdio || []
+
+  var stdin  = stdio[0]
+  var stdout = stdio[1]
+  var stderr = stdio[2]
+
+  var cp = wrapStdio(command, argv, options)
+
+  stdin  = (stdin  == null || stdin  === 'pipe') ? cp.stdin  : null
+  stdout = (stdout == null || stdout === 'pipe') ? cp.stdout : null
+  stderr = (stderr == null || stderr === 'pipe') ? cp.stderr : null
+
+  var result
+
+  // Both `stdin` and `stdout` are open, probably the normal case. Create a
+  // `Duplex` object with them so command can be used as a filter
+  if(stdin && stdout) result = Duplex()
+
+  // Only `stdout` is open, use it directly
+  else if(stdout) result = Readable()
+
+  // Only `stdin` is open, ensure is always 'only' `Writable`
+  else if(stdin) result = Writable()
+
+  // Both `stdin` and `stdout` are clossed, or already redirected on `spawn`
+  else result = new EventEmitter()
+
+  // Connect stdio streams
+  if(stdin)
+  {
+    result._write = stdin.write.bind(stdin)
+    result.once('finish', stdin.end.bind(stdin))
+  }
+
+  if(stdout)
+  {
+    result._read = noop
+    stdout.on  ('data', result.push.bind(result))
+    stdout.once('end' , result.push.bind(result, null))
+  }
+
+  // Use child process `exit` event instead of missing `stdout` `end` event
+  else
+    cp.once('exit', result.emit.bind(result, 'end'))
+
+  if(stderr)
+  {
+    // Expose `stderr` so it can be used later.
+    result.stderr = stderr
+
+    // Redirect `stderr` from piped command to our own `stderr`, since there's
+    // no way to redirect it to `process.stderr` by default as it should be.
+    // This way we can at least fetch the error messages someway instead of
+    // lost them...
+    var out_stderr = stdout && stdout.stderr
+    if(out_stderr) out_stderr.pipe(stderr)
+  }
+
+  // Propagate process events
+  cp.once('error', result.emit.bind(result, 'error'))
+  cp.once('exit' , result.emit.bind(result, 'exit' ))
+
+  return result
+}
+
+
+module.exports = spawnStream