Move child_process to its own package.

Author: joneshf

.gitignore

@@ -0,0 +1,7 @@
+/.*
+!/.gitignore
+bower_components/
+node_modules/
+output/
+tmp/
+npm-debug.log

README.md

@@ -0,0 +1,71 @@
+# Module Documentation
+
+## Module Node.ChildProcess
+
+### Types
+
+    newtype ChildProcess where
+      ChildProcess :: ChildProcessRec -> ChildProcess
+
+    type ChildProcessRec  = { disconnect :: forall eff. Fn0 (Eff eff Unit), send :: forall eff r. Fn2 {  | r } Handle (Eff eff Unit), kill :: forall eff. Fn1 Signal Boolean, connected :: Boolean, pid :: Number, stdout :: Stream Stdout, stdin :: Stream Stdin, stderr :: Stream Stderr }
+
+    data Handle :: *
+
+    data Spawn :: !
+
+    type SpawnOptions  = { gid :: Number, uid :: Number, detached :: Boolean, env :: forall r. {  | r }, stdio :: [String], cwd :: String }
+
+    data Stderr :: !
+
+    data Stdin :: !
+
+    data Stdout :: !
+
+    data Stream :: ! -> *
+
+
+### Type Class Instances
+
+    instance eventEmitterChildProcess :: EventEmitter ChildProcess
+
+    instance eventEmitterStreamStderr :: EventEmitter (Stream Stderr)
+
+    instance eventEmitterStreamStdin :: EventEmitter (Stream Stdin)
+
+    instance eventEmitterStreamStdout :: EventEmitter (Stream Stdout)
+
+
+### Values
+
+    closeEvent :: Event
+
+    defaultSpawnOptions :: SpawnOptions
+
+    disconnectEvent :: Event
+
+    errorEvent :: Event
+
+    exitEvent :: Event
+
+    messageEvent :: Event
+
+    process :: forall r. { env :: {  | r } }
+
+    spawn :: forall eff. String -> [String] -> SpawnOptions -> Eff (spawn :: Spawn | eff) ChildProcess
+
+    undefined :: forall a. a
+
+
+## Module Node.ChildProcess.Signal
+
+### Types
+
+    newtype Signal
+
+
+### Type Class Instances
+
+    instance showSignal :: Show Signal
+
+
+

bower.json

@@ -0,0 +1,9 @@
+{
+  "name": "purescript-node-child-process",
+  "version": "0.0.0",
+  "description": "PureScript bindings to child_process.",
+  "license": "MIT",
+  "dependencies": {
+    "purescript-node-events": "~0.0.5"
+  }
+}

gulpfile.js

@@ -0,0 +1,60 @@
+'use strict'
+
+var gulp       = require('gulp')
+  , purescript = require('gulp-purescript')
+  ;
+
+var paths = {
+    src: 'src/**/*.purs',
+    bowerSrc: [
+      'bower_components/purescript-*/src/**/*.purs',
+      'bower_components/purescript-*/src/**/*.purs.hs'
+    ],
+    dest: '',
+    docsDest: 'README.md'
+};
+
+var options = {
+    compiler: {},
+    docgen: {}
+};
+
+var compile = function(compiler) {
+    var psc = compiler(options.compiler);
+    psc.on('error', function(e) {
+        console.error(e.message);
+        psc.end();
+    });
+    return gulp.src([paths.src].concat(paths.bowerSrc))
+        .pipe(psc)
+        .pipe(gulp.dest(paths.dest));
+};
+
+gulp.task('make', function() {
+    return compile(purescript.pscMake);
+});
+
+gulp.task('browser', function() {
+    return compile(purescript.psc);
+});
+
+gulp.task('docs', function() {
+    var docgen = purescript.docgen(options.docgen);
+    docgen.on('error', function(e) {
+        console.error(e.message);
+        docgen.end();
+    });
+    return gulp.src(paths.src)
+      .pipe(docgen)
+      .pipe(gulp.dest(paths.docsDest));
+});
+
+gulp.task('watch-browser', function() {
+    gulp.watch(paths.src, ['browser', 'docs']);
+});
+
+gulp.task('watch-make', function() {
+    gulp.watch(paths.src, ['make', 'docs']);
+});
+
+gulp.task('default', ['make', 'docs']);

package.json

@@ -0,0 +1,10 @@
+{
+  "name": "purescript-node-child-process",
+  "version": "0.0.0",
+  "description": "PureScript bindings to child_process.",
+  "license": "MIT",
+  "devDependencies": {
+    "gulp": "^3.8.7",
+    "gulp-purescript": "0.0.9"
+  }
+}

src/Node/ChildProcess.purs

@@ -0,0 +1,83 @@
+module Node.ChildProcess where
+
+  import Control.Monad.Eff (Eff())
+
+  import Data.Function (Fn0(), Fn1(), Fn2())
+
+  import Node.ChildProcess.Signal (Signal(..))
+  import Node.Events (Event(..), EventEmitter)
+
+  foreign import data Handle :: *
+  foreign import data Spawn :: !
+  foreign import data Stream :: ! -> *
+  foreign import data Stderr :: !
+  foreign import data Stdin :: !
+  foreign import data Stdout :: !
+
+  newtype ChildProcess = ChildProcess ChildProcessRec
+
+  type ChildProcessRec =
+    { stderr     :: Stream Stderr
+    , stdin      :: Stream Stdin
+    , stdout     :: Stream Stdout
+    , pid        :: Number
+    , connected  :: Boolean
+    , kill       :: forall eff. Fn1 Signal Boolean
+    , send       :: forall eff r. Fn2 { | r} Handle (Eff eff Unit)
+    , disconnect :: forall eff. Fn0 (Eff eff Unit)
+    }
+
+  type SpawnOptions =
+    { cwd       :: String
+    , stdio     :: [String]
+    , env       :: forall r. { | r}
+    , detached  :: Boolean
+    , uid       :: Number
+    , gid       :: Number
+    }
+
+  instance eventEmitterStreamStderr :: EventEmitter (Stream Stderr)
+  instance eventEmitterStreamStdin  :: EventEmitter (Stream Stdin)
+  instance eventEmitterStreamStdout :: EventEmitter (Stream Stdout)
+
+  instance eventEmitterChildProcess :: EventEmitter ChildProcess
+
+  closeEvent :: Event
+  closeEvent = Event "close"
+
+  disconnectEvent :: Event
+  disconnectEvent = Event "disconnect"
+
+  errorEvent :: Event
+  errorEvent = Event "error"
+
+  exitEvent :: Event
+  exitEvent = Event "exit"
+
+  messageEvent :: Event
+  messageEvent = Event "message"
+
+  foreign import spawn
+    "function spawn(command) {\
+    \  return function(args) {\
+    \    return function(opts) {\
+    \      return function() {\
+    \        return require('child_process').spawn(command, args, opts);\
+    \      }\
+    \    }\
+    \  }\
+    \}" :: forall eff. String -> [String] -> SpawnOptions -> Eff (spawn :: Spawn | eff) ChildProcess
+
+  defaultSpawnOptions :: SpawnOptions
+  defaultSpawnOptions =
+    { cwd: undefined
+    , stdio: ["pipe", "pipe", "pipe"]
+    , env: process.env
+    , detached: false
+    , uid: undefined
+    , gid: undefined
+    }
+
+  -- There's gotta be a better way.
+  foreign import undefined :: forall a. a
+  foreign import process :: forall r. {env :: { | r}}

src/Node/ChildProcess/Signal.purs

@@ -0,0 +1,85 @@
+module Node.ChildProcess.Signal
+  ( Signal()
+  , sigabrt
+  , sigalrm
+  , sigbus
+  , sigchld
+  , sigcld
+  , sigcont
+  , sigemt
+  , sigfpe
+  , sighup
+  , sigill
+  , siginfo
+  , sigint
+  , sigio
+  , sigiot
+  , sigkill
+  , siglost
+  , sigpipe
+  , sigpoll
+  , sigprof
+  , sigpwr
+  , sigquit
+  , sigsegv
+  , sigstkflt
+  , sigstop
+  , sigsys
+  , sigterm
+  , sigtrap
+  , sigtstp
+  , sigttin
+  , sigttou
+  , sigunused
+  , sigurg
+  , sigusr1
+  , sigusr2
+  , sigvtalrm
+  , sigwinch
+  , sigxcpu
+  , sigxfsz
+  ) where
+
+  newtype Signal = Signal String
+
+  sigabrt   = Signal "SIGABRT"
+  sigalrm   = Signal "SIGALRM"
+  sigbus    = Signal "SIGBUS"
+  sigchld   = Signal "SIGCHLD"
+  sigcld    = Signal "SIGCLD"
+  sigcont   = Signal "SIGCONT"
+  sigemt    = Signal "SIGEMT"
+  sigfpe    = Signal "SIGFPE"
+  sighup    = Signal "SIGHUP"
+  sigill    = Signal "SIGILL"
+  siginfo   = Signal "SIGINFO"
+  sigint    = Signal "SIGINT"
+  sigio     = Signal "SIGIO"
+  sigiot    = Signal "SIGIOT"
+  sigkill   = Signal "SIGKILL"
+  siglost   = Signal "SIGLOST"
+  sigpipe   = Signal "SIGPIPE"
+  sigpoll   = Signal "SIGPOLL"
+  sigprof   = Signal "SIGPROF"
+  sigpwr    = Signal "SIGPWR"
+  sigquit   = Signal "SIGQUIT"
+  sigsegv   = Signal "SIGSEGV"
+  sigstkflt = Signal "SIGSTKFLT"
+  sigstop   = Signal "SIGSTOP"
+  sigsys    = Signal "SIGSYS"
+  sigterm   = Signal "SIGTERM"
+  sigtrap   = Signal "SIGTRAP"
+  sigtstp   = Signal "SIGTSTP"
+  sigttin   = Signal "SIGTTIN"
+  sigttou   = Signal "SIGTTOU"
+  sigunused = Signal "SIGUNUSED"
+  sigurg    = Signal "SIGURG"
+  sigusr1   = Signal "SIGUSR1"
+  sigusr2   = Signal "SIGUSR2"
+  sigvtalrm = Signal "SIGVTALRM"
+  sigwinch  = Signal "SIGWINCH"
+  sigxcpu   = Signal "SIGXCPU"
+  sigxfsz   = Signal "SIGXFSZ"
+
+  instance showSignal :: Show Signal where
+    show (Signal sig) = sig

test/Node/ChildProcess.purs

@@ -0,0 +1,25 @@
+module Test.Node.ChildProcess where
+
+  import Data.Function (mkFn2, runFn1)
+
+  import Debug.Trace
+
+  import Node.ChildProcess
+  import Node.ChildProcess.Signal
+  import Node.Events
+
+  foreign import toString
+    "function toString(x) {\
+    \  return x == null ? 'null' : x.toString();\
+    \}" :: forall a. a -> String
+
+  main = do
+    ChildProcess ls <- spawn "ls" ["-la"] defaultSpawnOptions
+    on closeEvent (mkFn2 \code sig ->
+        trace $ "ls exited with code: " ++
+          (toString code) ++
+          "\nfrom signal: " ++
+          (toString sig))
+      (ChildProcess ls)
+    on (Event "data") (toString >>> trace) ls.stdout
+    pure $ runFn1 ls.kill sigterm