Merge pull request #4 from spicydonuts/expose-node-api

Expose more of the node api for createInterface

Author: hdgarrood

README.md

@@ -8,6 +8,4 @@ A low-level PureScript interface to the Node `readline` API.
 bower install purescript-readline
 ```
 
-## Module documentation
-
-- [Node.ReadLine](docs/Node/ReadLine.md)
+Module documentation can be found on [Pursuit](https://pursuit.purescript.org/packages/purescript-node-readline)

bower.json

@@ -21,6 +21,10 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-console": "^0.1.0"
+    "purescript-console": "^0.1.0",
+    "purescript-node-streams": "~0.3.0",
+    "purescript-node-process": "~0.4.1",
+    "purescript-options": "^0.6.0",
+    "purescript-foreign": "^0.7.2"
   }
 }

docs/Node/ReadLine.md

@@ -1,24 +1,33 @@
 /* global exports */
-"use strict";
+'use strict';
 
 // module Node.ReadLine
 
-exports.setLineHandler = function(readline) {
-    return function(callback) {
-        return function() {
-            readline.removeAllListeners('line');
-            readline.on('line', function(line) {
-                callback(line)();
-            });
-            return readline;
-        };
-    };
+exports.createInterfaceImpl = function(options) {
+  return function() {
+    var readline = require('readline');
+    return readline.createInterface({
+      input: options.input,
+      output: options.output,
+      completer: options.completer && function(line) {
+        var res = options.completer(line)();
+        return [res.completions, res.suffix];
+      },
+      terminal: options.terminal,
+      historySize: options.historySize
+    });
+  };
+};
+
+exports.close = function(readline) {
+  return function() {
+    readline.close();
+  };
 };
 
 exports.prompt = function(readline) {
     return function() {
         readline.prompt();
-        return readline;
     };
 };
 
@@ -27,29 +36,18 @@ exports.setPrompt = function(prompt) {
         return function(readline) {
             return function() {
                 readline.setPrompt(prompt, length);
-                return readline;
             };
         };
     };
 };
 
-exports.createInterface = function(completer) {
-    return function() {
-        var readline = require('readline');
-        return readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-            completer: function(line) {
-                var res = completer(line)();
-                return [res.completions, res.suffix];
-            }
-        });
-    };
-};
-
-exports.close = function(readline) {
+exports.setLineHandler = function(readline) {
+  return function(callback) {
     return function() {
-        readline.close();
-        return readline;
+      readline.removeAllListeners('line');
+      readline.on('line', function(line) {
+        callback(line)();
+      });
     };
+  };
 };

src/Node/ReadLine.js

@@ -1,42 +1,133 @@
 -- | This module provides a binding to the Node `readline` API.
 
-module Node.ReadLine where
+module Node.ReadLine
+  ( Interface
+  , READLINE
+  , InterfaceOptions
+  , Completer
+  , LineHandler
+  , createInterface
+  , createConsoleInterface
+  , output
+  , completer
+  , terminal
+  , historySize
+  , noCompletion
+  , prompt
+  , setPrompt
+  , setLineHandler
+  , close
+  ) where
 
-import Prelude (return)
-
-import Control.Monad.Eff
-import Control.Monad.Eff.Console
+import Prelude (Unit, return, (<>), ($))
+import Control.Monad.Eff (Eff)
+import Control.Monad.Eff.Console (CONSOLE)
+import Control.Monad.Eff.Exception (EXCEPTION)
+import Data.Foreign (Foreign)
+import Data.Options (Options, Option, (:=), options, opt)
+import Node.Process (stdin, stdout)
+import Node.Stream (Readable, Writable)
 
 -- | A handle to a console interface.
 -- |
 -- | A handle can be created with the `createInterface` function.
 foreign import data Interface :: *
 
+-- | The effect of interacting with a stream via an `Interface`
+foreign import data READLINE :: !
+
+foreign import createInterfaceImpl :: forall eff.
+                                      Foreign
+                                   -> Eff ( readline :: READLINE
+                                          | eff
+                                          ) Interface
+
+-- | Options passed to `readline`'s `createInterface`
+data InterfaceOptions
+
+output :: forall w eff. Option InterfaceOptions (Writable w eff)
+output = opt "output"
+
+completer :: forall eff. Option InterfaceOptions (Completer eff)
+completer = opt "completer"
+
+terminal :: Option InterfaceOptions Boolean
+terminal = opt "terminal"
+
+historySize :: Option InterfaceOptions Int
+historySize = opt "historySize"
+
 -- | A function which performs tab completion.
 -- |
--- | This function takes the partial command as input, and returns a collection of 
+-- | This function takes the partial command as input, and returns a collection of
 -- | completions, as well as the matched portion of the input string.
-type Completer eff = String -> Eff (console :: CONSOLE | eff) { completions :: Array String, matched :: String }
+type Completer eff = String -> Eff eff { completions :: Array String
+                                       , matched :: String }
 
--- | A function which handles input from the user.
-type LineHandler eff a = String -> Eff (console :: CONSOLE | eff) a 
+-- | Builds an interface with the specified options.
+createInterface :: forall r eff.
+                   Readable r ( readline :: READLINE
+                              | eff
+                              )
+                -> Options InterfaceOptions
+                -> Eff ( readline :: READLINE
+                       | eff
+                       ) Interface
+createInterface input opts = createInterfaceImpl
+  $ options $ opts
+           <> opt "input" := input
 
--- | Set the current line handler function.
-foreign import setLineHandler :: forall eff a. Interface -> LineHandler eff a -> Eff (console :: CONSOLE | eff) Interface
+-- | Create an interface with the specified completion function.
+createConsoleInterface :: forall eff.
+                          Completer ( readline :: READLINE
+                                    , console :: CONSOLE
+                                    , err :: EXCEPTION
+                                    | eff
+                                    )
+                       -> Eff ( readline :: READLINE
+                              , console :: CONSOLE
+                              , err :: EXCEPTION
+                              | eff
+                              ) Interface
+createConsoleInterface compl = createInterface stdin $ output := stdout
+                                                    <> completer := compl
+
+-- | A completion function which offers no completions.
+noCompletion :: forall eff. Completer eff
+noCompletion s = return { completions: [], matched: s }
 
 -- | Prompt the user for input on the specified `Interface`.
-foreign import prompt :: forall eff. Interface -> Eff (console :: CONSOLE | eff) Interface
+foreign import prompt :: forall eff.
+                         Interface
+                      -> Eff ( readline :: READLINE
+                             | eff
+                             ) Unit
 
 -- | Set the prompt.
-foreign import setPrompt :: forall eff. String -> Int -> Interface -> Eff (console :: CONSOLE | eff) Interface
-
--- | Create an interface with the specified completion function.
-foreign import createInterface :: forall eff. Completer eff -> Eff (console :: CONSOLE | eff) Interface
+foreign import setPrompt :: forall eff.
+                            String
+                         -> Int
+                         -> Interface
+                         -> Eff ( readline :: READLINE
+                                | eff
+                                ) Unit
 
 -- | Close the specified `Interface`.
-foreign import close :: forall eff. Interface -> Eff (console :: CONSOLE | eff) Interface
+foreign import close :: forall eff.
+                        Interface
+                     -> Eff ( readline :: READLINE
+                            | eff
+                            ) Unit
 
--- | A completion function which offers no completions.
-noCompletion :: forall eff. Completer eff
-noCompletion s = return { completions: [], matched: s }
+-- | A function which handles each line of input.
+type LineHandler eff a = String -> Eff eff a
 
+-- | Set the current line handler function.
+foreign import setLineHandler :: forall eff a.
+                                 Interface
+                              -> LineHandler ( readline :: READLINE
+                                             | eff
+                                             ) a
+                              -> Eff ( readline :: READLINE
+                                     | eff
+                                     ) Unit

src/Node/ReadLine.purs

@@ -1,14 +1,11 @@
 module Test.Main where
 
 import Prelude
-
-import Control.Monad.Eff
 import Control.Monad.Eff.Console
-
 import Node.ReadLine
 
 main = do
-  interface <- createInterface noCompletion
+  interface <- createConsoleInterface noCompletion
 
   setPrompt "> " 2 interface
   prompt interface