git.iko.soy/prybar
on master help sign in
Merge pull request #57 from replit/am-node

Fix up node.js repl (this is what's running in prod)

commit4692e8dd526c4ea99d5ec8a574f08ee086cdfab0 authorAmjad Masad <amjad.masad@gmail.com> dateMon 31 Aug 2020, 12:47 (6 years ago) parentfe1d5d976b96ef
12 files changed+1617−208
compare with master
unifiedsplit
languages/nodejs/main.go+15−22 languages/nodejs/repl.js+195−184 languages/nodejs/version.js−1 prybar_assets/nodejs/readline-sync.js+1329 scripts/docker-install.sh+2−1 test_files/hello.js+3 tests/nodejs/err.exp+21 tests/nodejs/eval_code.exp+8 tests/nodejs/header.exp+9 tests/nodejs/printing.exp+13 tests/nodejs/run_code.exp+6 tests/nodejs/run_file.exp+16
languages/nodejs/main.go+15−22
@@ -7,6 +7,7 @@ import (
77 "os"
88 "os/exec"
99 "syscall"
10+
1011 "github.com/replit/prybar/utils"
1112)
1213
@@ -39,35 +40,27 @@ func Execute(config *utils.Config) {
3940 panic(err)
4041 }
4142
42− env := os.Environ()
43− args := []string{"node"}
44−
45− if !config.Quiet {
46− args = append(args, "-r", findHelper("version"))
43+ args := []string{"node", findHelper("repl")}
4744
45+ if config.Quiet {
46+ os.Setenv("PRYBAR_QUIET", "1")
4847 }
4948
50− if config.Code != "" {
51− args = append(args, "-e", config.Code)
52− }
53−
54− if config.Exp != "" {
55− args = append(args, "-p", config.Exp)
56− }
49+ os.Setenv("PRYBAR_CODE", config.Code)
50+ os.Setenv("PRYBAR_EXP", config.Exp)
51+ os.Setenv("PRYBAR_PS1", config.Ps1)
5752
5853 if config.Interactive {
59− args = append(args, "-r", findHelper("repl"))
60− }
61−
62− if config.Ps1 != "" {
63− env = append(env, "NODE_PROMPT="+config.Ps1)
54+ os.Setenv("PRYBAR_INTERACTIVE", "1")
6455 }
6556
66− if config.Args != nil && len(config.Args) > 0 {
67− args = append(args, config.Args...)
68− } else if config.Exp == "" && config.Code == "" {
69− args = append(args, "-e", "")
57+ // We only support one file, despite the fact that this
58+ // variable is a list.
59+ if len(config.Args) >= 1 {
60+ os.Setenv("PRYBAR_FILE", config.Args[0])
61+ } else {
62+ os.Setenv("PRYBAR_FILE", "")
7063 }
7164
72− syscall.Exec(path, args, env)
65+ syscall.Exec(path, args, os.Environ())
7366}
languages/nodejs/repl.js+195−184
@@ -1,184 +1,195 @@
1−var repl = require('repl');
2−
3−
4−//Taken from module async-exit-hook
5−var exit = (function() {
6− 'use strict';
7−
8− const hooks = [];
9− const errHooks = [];
10− let called = false;
11− let waitingFor = 0;
12− let asyncTimeoutMs = 10000;
13−
14− const events = {};
15− const filters = {};
16−
17− function exit(exit, code, err) {
18− // Helper functions
19− let doExitDone = false;
20−
21− function doExit() {
22− if (doExitDone) {
23− return;
24− }
25− doExitDone = true;
26−
27− if (exit === true) {
28− // All handlers should be called even if the exit-hook handler was registered first
29− process.nextTick(process.exit.bind(null, code));
30− }
31− }
32−
33− // Async hook callback, decrements waiting counter
34− function stepTowardExit() {
35− process.nextTick(() => {
36− if (--waitingFor === 0) {
37− doExit();
38− }
39− });
40− }
41−
42− // Runs a single hook
43− function runHook(syncArgCount, err, hook) {
44− // Cannot perform async hooks in `exit` event
45− if (exit && hook.length > syncArgCount) {
46− // Hook is async, expects a finish callback
47− waitingFor++;
48−
49− if (err) {
50− // Pass error, calling uncaught exception handlers
51− return hook(err, stepTowardExit);
52− }
53− return hook(stepTowardExit);
54− }
55−
56− // Hook is synchronous
57− if (err) {
58− // Pass error, calling uncaught exception handlers
59− return hook(err);
60− }
61− return hook();
62− }
63−
64− // Only execute hooks once
65− if (called) {
66− return;
67− }
68−
69− called = true;
70−
71− // Run hooks
72− if (err) {
73− // Uncaught exception, run error hooks
74− errHooks.map(runHook.bind(null, 1, err));
75− }
76− hooks.map(runHook.bind(null, 0, null));
77−
78− if (waitingFor) {
79− // Force exit after x ms (10000 by default), even if async hooks in progress
80− setTimeout(() => {
81− doExit();
82− }, asyncTimeoutMs);
83− } else {
84− // No asynchronous hooks, exit immediately
85− doExit();
86− }
87− }
88−
89− // Add a hook
90− function add(hook) {
91− hooks.push(hook);
92−
93− if (hooks.length === 1) {
94− add.hookEvent('exit');
95− add.hookEvent('beforeExit', 0);
96− add.hookEvent('SIGHUP', 128 + 1);
97− add.hookEvent('SIGINT', 128 + 2);
98− add.hookEvent('SIGTERM', 128 + 15);
99− add.hookEvent('SIGBREAK', 128 + 21);
100−
101− // PM2 Cluster shutdown message. Caught to support async handlers with pm2, needed because
102− // explicitly calling process.exit() doesn't trigger the beforeExit event, and the exit
103− // event cannot support async handlers, since the event loop is never called after it.
104− add.hookEvent('message', 0, function (msg) { // eslint-disable-line prefer-arrow-callback
105− if (msg !== 'shutdown') {
106− return true;
107− }
108− });
109− }
110− }
111−
112− // New signal / event to hook
113− add.hookEvent = function (event, code, filter) {
114− events[event] = function () {
115− const eventFilters = filters[event];
116− for (let i = 0; i < eventFilters.length; i++) {
117− if (eventFilters[i].apply(this, arguments)) {
118− return;
119− }
120− }
121− exit(code !== undefined && code !== null, code);
122− };
123−
124− if (!filters[event]) {
125− filters[event] = [];
126− }
127−
128− if (filter) {
129− filters[event].push(filter);
130− }
131− process.on(event, events[event]);
132− };
133−
134− // Unhook signal / event
135− add.unhookEvent = function (event) {
136− process.removeListener(event, events[event]);
137− delete events[event];
138− delete filters[event];
139− };
140−
141− // List hooked events
142− add.hookedEvents = function () {
143− const ret = [];
144− for (const name in events) {
145− if ({}.hasOwnProperty.call(events, name)) {
146− ret.push(name);
147− }
148− }
149− return ret;
150− };
151−
152− // Add an uncaught exception handler
153− add.uncaughtExceptionHandler = function (hook) {
154− errHooks.push(hook);
155−
156− if (errHooks.length === 1) {
157− process.once('uncaughtException', exit.bind(null, true, 1));
158− }
159− };
160−
161− // Add an unhandled rejection handler
162− add.unhandledRejectionHandler = function (hook) {
163− errHooks.push(hook);
164−
165− if (errHooks.length === 1) {
166− process.once('unhandledRejection', exit.bind(null, true, 1));
167− }
168− };
169−
170− // Configure async force exit timeout
171− add.forceExitTimeout = function (ms) {
172− asyncTimeoutMs = ms;
173− };
174−
175− // Export
176− return add;
177−
178−})();
179−
180−
181−exit((reallyExit) => {
182− let r = repl.start(process.env.NODE_PROMPT || '> ');
183− r.on('exit', reallyExit);
184−});
1+const util = require('util');
2+const repl = require("repl");
3+const path = require("path");
4+const fs = require("fs");
5+const vm = require("vm");
6+const rl = require(path.join(
7+ process.cwd(),
8+ "prybar_assets",
9+ "nodejs",
10+ "readline-sync.js"
11+));
12+const tty = require("tty");
13+const Module = require("module");
14+
15+let r;
16+if (!process.env.PRYBAR_QUIET) {
17+ console.log("Node " + process.version + " on " + process.platform);
18+}
19+
20+// Red errors.
21+function logError(msg) {
22+ process.stdout.write("\u001b[0m\u001b[31m" + msg + "\u001b[0m");
23+}
24+
25+// The nodejs repl operates in raw mode and does some funky stuff to
26+// the terminal. This ns the repl and forces non-raw mode.
27+function pauseRepl() {
28+ if (!r) return;
29+
30+ r.pause();
31+ process.stdin.setRawMode(false);
32+}
33+
34+// Forces raw mode and resumes the repl.
35+function resumeRepl() {
36+ if (!r) return;
37+
38+ process.stdin.setRawMode(true);
39+ r.resume();
40+}
41+
42+// Clear the line if it has anything on it.
43+function clearLine() {
44+ if (r && r.line) r.clearLine();
45+}
46+
47+// Adapted from the internal node repl code just a lot simpler and adds
48+// red errors (see https://bit.ly/2FRM86S)
49+function handleError(e) {
50+ if (r) {
51+ r.lastError = e;
52+ }
53+
54+ if (e && typeof e === "object" && e.stack && e.name) {
55+ if (e.name === "SyntaxError") {
56+ e.stack = e.stack
57+ .replace(/^repl:\d+\r?\n/, "")
58+ .replace(/^\s+at\s.*\n?/gm, "");
59+ }
60+
61+ logError(e.stack);
62+ } else {
63+ // For some reason needs a newline to flush.
64+ logError("Thrown: " + r.writer(e) + "\n");
65+ }
66+
67+ if (r) {
68+ r.clearBufferedCommand();
69+ r.lines.level = [];
70+ r.displayPrompt();
71+ }
72+}
73+
74+function start(context) {
75+ r = repl.start({
76+ prompt: process.env.PRYBAR_PS1,
77+ });
78+ if (context) r.context = context;
79+
80+ // remove the internal error and ours for red etc.
81+ r._domain.removeListener("error", r._domain.listeners("error")[0]);
82+ r._domain.on("error", handleError);
83+ process.on("uncaughtException", handleError);
84+}
85+
86+global.alert = console.log;
87+global.prompt = (p) => {
88+ pauseRepl();
89+ clearLine();
90+
91+ let ret = rl.question(`${p}> `, {
92+ hideEchoBack: false,
93+ });
94+
95+ resumeRepl();
96+
97+ // Display prompt on the next turn.
98+ if (r) setImmediate(() => r.displayPrompt());
99+
100+ return ret;
101+};
102+
103+global.confirm = (q) => {
104+ pauseRepl();
105+ clearLine();
106+
107+ const ret = rl.keyInYNStrict(q);
108+
109+ resumeRepl();
110+
111+ // Display prompt on the next turn.
112+ if (r) setImmediate(() => r.displayPrompt());
113+ return ret;
114+};
115+
116+if (process.env.PRYBAR_CODE) {
117+ vm.runInThisContext(process.env.PRYBAR_CODE);
118+ if (process.env.PRYBAR_INTERACTIVE) {
119+ start();
120+ }
121+} else if (process.env.PRYBAR_EXP) {
122+ console.log(vm.runInThisContext(process.env.PRYBAR_EXP));
123+ if (process.env.PRYBAR_INTERACTIVE) {
124+ start();
125+ }
126+} else if (process.env.PRYBAR_FILE) {
127+ const mainPath = path.resolve(process.env.PRYBAR_FILE);
128+ const main = fs.readFileSync(mainPath, "utf-8");
129+ const module = new Module(mainPath, null);
130+
131+ module.id = ".";
132+ module.filename = mainPath;
133+ module.paths = Module._nodeModulePaths(path.dirname(mainPath));
134+
135+ process.mainModule = module;
136+ const sandbox = {
137+ module,
138+ require: module.require.bind(module),
139+ __dirname: path.dirname(mainPath),
140+ __filename: mainPath,
141+
142+ // These are deprecated properties and accessing them will trigger a warning.
143+ // We add them manually for backward compat.
144+ GLOBAL: global,
145+ root: global,
146+ };
147+
148+ // These properties will show a warning. We can avoid them.
149+ for (const prop of Object.getOwnPropertyNames(global)) {
150+ if (sandbox.hasOwnProperty(prop)) {
151+ continue;
152+ }
153+
154+ sandbox[prop] = global[prop];
155+ }
156+
157+ console.log(
158+ "\u001b[0m\u001b[90mHint: hit control+c anytime to enter REPL.\u001b[0m"
159+ );
160+ const context = vm.createContext(sandbox);
161+
162+ let script;
163+ try {
164+ script = vm.createScript(main, {
165+ filename: mainPath,
166+ displayErrors: false,
167+ });
168+ } catch (e) {
169+ handleError(e);
170+ }
171+
172+ if (script) {
173+ let res;
174+ try {
175+ res = script.runInContext(context, {
176+ displayErrors: false,
177+ });
178+ } catch (e) {
179+ handleError(e);
180+ }
181+
182+ module.loaded = true;
183+
184+ if (typeof res !== "undefined") {
185+ console.log(util.inspect(res, { colors: true }));
186+ }
187+ }
188+
189+ if (process.env.PRYBAR_INTERACTIVE) {
190+ process.once("SIGINT", () => start(context));
191+ process.once("beforeExit", () => start(context));
192+ }
193+} else if (process.env.PRYBAR_INTERACTIVE) {
194+ start();
195+}
languages/nodejs/version.jsdeleted−1
@@ -1 +0,0 @@
1−console.log('Node ' + process.version + ' on ' + process.platform);
prybar_assets/nodejs/readline-sync.jsnew file+1329
@@ -0,0 +1,1329 @@
1+/*
2+ * readlineSync
3+ * https://github.com/anseki/readline-sync
4+ *
5+ * Copyright (c) 2019 anseki
6+ * Licensed under the MIT license.
7+ */
8+
9+'use strict';
10+
11+var
12+ IS_WIN = process.platform === 'win32',
13+
14+ ALGORITHM_CIPHER = 'aes-256-cbc',
15+ ALGORITHM_HASH = 'sha256',
16+ DEFAULT_ERR_MSG = 'The current environment doesn\'t support interactive reading from TTY.',
17+
18+ fs = require('fs'),
19+ TTY = process.binding('tty_wrap').TTY,
20+ childProc = require('child_process'),
21+ pathUtil = require('path'),
22+
23+ defaultOptions = {
24+ /* eslint-disable key-spacing */
25+ prompt: '> ',
26+ hideEchoBack: false,
27+ mask: '*',
28+ limit: [],
29+ limitMessage: 'Input another, please.$<( [)limit(])>',
30+ defaultInput: '',
31+ trueValue: [],
32+ falseValue: [],
33+ caseSensitive: false,
34+ keepWhitespace: false,
35+ encoding: 'utf8',
36+ bufferSize: 1024,
37+ print: void 0,
38+ history: true,
39+ cd: false,
40+ phContent: void 0,
41+ preCheck: void 0
42+ /* eslint-enable key-spacing */
43+ },
44+
45+ fdR = 'none',
46+ isRawMode = false,
47+ salt = 0,
48+ lastInput = '',
49+ inputHistory = [],
50+ _DBG_useExt = false,
51+ _DBG_checkOptions = false,
52+ _DBG_checkMethod = false,
53+ fdW, ttyR, extHostPath, extHostArgs, tempdir, rawInput;
54+
55+function getHostArgs(options) {
56+ // Send any text to crazy Windows shell safely.
57+ function encodeArg(arg) {
58+ return arg.replace(/[^\w\u0080-\uFFFF]/g, function(chr) {
59+ return '#' + chr.charCodeAt(0) + ';';
60+ });
61+ }
62+
63+ return extHostArgs.concat((function(conf) {
64+ var args = [];
65+ Object.keys(conf).forEach(function(optionName) {
66+ if (conf[optionName] === 'boolean') {
67+ if (options[optionName]) { args.push('--' + optionName); }
68+ } else if (conf[optionName] === 'string') {
69+ if (options[optionName]) {
70+ args.push('--' + optionName, encodeArg(options[optionName]));
71+ }
72+ }
73+ });
74+ return args;
75+ })({
76+ /* eslint-disable key-spacing */
77+ display: 'string',
78+ displayOnly: 'boolean',
79+ keyIn: 'boolean',
80+ hideEchoBack: 'boolean',
81+ mask: 'string',
82+ limit: 'string',
83+ caseSensitive: 'boolean'
84+ /* eslint-enable key-spacing */
85+ }));
86+}
87+
88+// piping via files (for Node.js v0.10-)
89+function _execFileSync(options, execOptions) {
90+
91+ function getTempfile(name) {
92+ var suffix = '',
93+ filepath, fd;
94+ tempdir = tempdir || require('os').tmpdir();
95+
96+ while (true) {
97+ filepath = pathUtil.join(tempdir, name + suffix);
98+ try {
99+ fd = fs.openSync(filepath, 'wx');
100+ } catch (e) {
101+ if (e.code === 'EEXIST') {
102+ suffix++;
103+ continue;
104+ } else {
105+ throw e;
106+ }
107+ }
108+ fs.closeSync(fd);
109+ break;
110+ }
111+ return filepath;
112+ }
113+
114+ var res = {},
115+ pathStdout = getTempfile('readline-sync.stdout'),
116+ pathStderr = getTempfile('readline-sync.stderr'),
117+ pathExit = getTempfile('readline-sync.exit'),
118+ pathDone = getTempfile('readline-sync.done'),
119+ crypto = require('crypto'),
120+ hostArgs, shellPath, shellArgs, exitCode, extMessage, shasum, decipher, password;
121+
122+ shasum = crypto.createHash(ALGORITHM_HASH);
123+ shasum.update('' + process.pid + (salt++) + Math.random());
124+ password = shasum.digest('hex');
125+ decipher = crypto.createDecipher(ALGORITHM_CIPHER, password);
126+
127+ hostArgs = getHostArgs(options);
128+ if (IS_WIN) {
129+ shellPath = process.env.ComSpec || 'cmd.exe';
130+ process.env.Q = '"'; // The quote (") that isn't escaped.
131+ // `()` for ignore space by echo
132+ shellArgs = ['/V:ON', '/S', '/C',
133+ '(%Q%' + shellPath + '%Q% /V:ON /S /C %Q%' + /* ESLint bug? */ // eslint-disable-line no-path-concat
134+ '%Q%' + extHostPath + '%Q%' +
135+ hostArgs.map(function(arg) { return ' %Q%' + arg + '%Q%'; }).join('') +
136+ ' & (echo !ERRORLEVEL!)>%Q%' + pathExit + '%Q%%Q%) 2>%Q%' + pathStderr + '%Q%' +
137+ ' |%Q%' + process.execPath + '%Q% %Q%' + __dirname + '\\encrypt.js%Q%' +
138+ ' %Q%' + ALGORITHM_CIPHER + '%Q% %Q%' + password + '%Q%' +
139+ ' >%Q%' + pathStdout + '%Q%' +
140+ ' & (echo 1)>%Q%' + pathDone + '%Q%'];
141+ } else {
142+ shellPath = '/bin/sh';
143+ shellArgs = ['-c',
144+ // Use `()`, not `{}` for `-c` (text param)
145+ '("' + extHostPath + '"' + /* ESLint bug? */ // eslint-disable-line no-path-concat
146+ hostArgs.map(function(arg) { return " '" + arg.replace(/'/g, "'\\''") + "'"; }).join('') +
147+ '; echo $?>"' + pathExit + '") 2>"' + pathStderr + '"' +
148+ ' |"' + process.execPath + '" "' + __dirname + '/encrypt.js"' +
149+ ' "' + ALGORITHM_CIPHER + '" "' + password + '"' +
150+ ' >"' + pathStdout + '"' +
151+ '; echo 1 >"' + pathDone + '"'];
152+ }
153+ if (_DBG_checkMethod) { _DBG_checkMethod('_execFileSync', hostArgs); }
154+ try {
155+ childProc.spawn(shellPath, shellArgs, execOptions);
156+ } catch (e) {
157+ res.error = new Error(e.message);
158+ res.error.method = '_execFileSync - spawn';
159+ res.error.program = shellPath;
160+ res.error.args = shellArgs;
161+ }
162+
163+ while (fs.readFileSync(pathDone, {encoding: options.encoding}).trim() !== '1') {} // eslint-disable-line no-empty
164+ if ((exitCode =
165+ fs.readFileSync(pathExit, {encoding: options.encoding}).trim()) === '0') {
166+ res.input =
167+ decipher.update(fs.readFileSync(pathStdout, {encoding: 'binary'}),
168+ 'hex', options.encoding) +
169+ decipher.final(options.encoding);
170+ } else {
171+ extMessage = fs.readFileSync(pathStderr, {encoding: options.encoding}).trim();
172+ res.error = new Error(DEFAULT_ERR_MSG + (extMessage ? '\n' + extMessage : ''));
173+ res.error.method = '_execFileSync';
174+ res.error.program = shellPath;
175+ res.error.args = shellArgs;
176+ res.error.extMessage = extMessage;
177+ res.error.exitCode = +exitCode;
178+ }
179+
180+ fs.unlinkSync(pathStdout);
181+ fs.unlinkSync(pathStderr);
182+ fs.unlinkSync(pathExit);
183+ fs.unlinkSync(pathDone);
184+
185+ return res;
186+}
187+
188+function readlineExt(options) {
189+ var res = {},
190+ execOptions = {env: process.env, encoding: options.encoding},
191+ hostArgs, extMessage;
192+
193+ if (!extHostPath) {
194+ if (IS_WIN) {
195+ if (process.env.PSModulePath) { // Windows PowerShell
196+ extHostPath = 'powershell.exe';
197+ extHostArgs = ['-ExecutionPolicy', 'Bypass',
198+ '-File', __dirname + '\\read.ps1']; // eslint-disable-line no-path-concat
199+ } else { // Windows Script Host
200+ extHostPath = 'cscript.exe';
201+ extHostArgs = ['//nologo', __dirname + '\\read.cs.js']; // eslint-disable-line no-path-concat
202+ }
203+ } else {
204+ extHostPath = '/bin/sh';
205+ extHostArgs = [__dirname + '/read.sh']; // eslint-disable-line no-path-concat
206+ }
207+ }
208+ if (IS_WIN && !process.env.PSModulePath) { // Windows Script Host
209+ // ScriptPW (Win XP and Server2003) needs TTY stream as STDIN.
210+ // In this case, If STDIN isn't TTY, an error is thrown.
211+ execOptions.stdio = [process.stdin];
212+ }
213+
214+ if (childProc.execFileSync) {
215+ hostArgs = getHostArgs(options);
216+ if (_DBG_checkMethod) { _DBG_checkMethod('execFileSync', hostArgs); }
217+ try {
218+ res.input = childProc.execFileSync(extHostPath, hostArgs, execOptions);
219+ } catch (e) { // non-zero exit code
220+ extMessage = e.stderr ? (e.stderr + '').trim() : '';
221+ res.error = new Error(DEFAULT_ERR_MSG + (extMessage ? '\n' + extMessage : ''));
222+ res.error.method = 'execFileSync';
223+ res.error.program = extHostPath;
224+ res.error.args = hostArgs;
225+ res.error.extMessage = extMessage;
226+ res.error.exitCode = e.status;
227+ res.error.code = e.code;
228+ res.error.signal = e.signal;
229+ }
230+ } else {
231+ res = _execFileSync(options, execOptions);
232+ }
233+ if (!res.error) {
234+ res.input = res.input.replace(/^\s*'|'\s*$/g, '');
235+ options.display = '';
236+ }
237+
238+ return res;
239+}
240+
241+/*
242+ display: string
243+ displayOnly: boolean
244+ keyIn: boolean
245+ hideEchoBack: boolean
246+ mask: string
247+ limit: string (pattern)
248+ caseSensitive: boolean
249+ keepWhitespace: boolean
250+ encoding, bufferSize, print
251+*/
252+function _readlineSync(options) {
253+ var input = '',
254+ displaySave = options.display,
255+ silent = !options.display && options.keyIn && options.hideEchoBack && !options.mask;
256+
257+ function tryExt() {
258+ var res = readlineExt(options);
259+ if (res.error) { throw res.error; }
260+ return res.input;
261+ }
262+
263+ if (_DBG_checkOptions) { _DBG_checkOptions(options); }
264+
265+ (function() { // open TTY
266+ var fsB, constants, verNum;
267+
268+ function getFsB() {
269+ if (!fsB) {
270+ fsB = process.binding('fs'); // For raw device path
271+ constants = process.binding('constants');
272+ // for v6.3.0+
273+ constants = constants && constants.fs && typeof constants.fs.O_RDWR === 'number'
274+ ? constants.fs : constants;
275+ }
276+ return fsB;
277+ }
278+
279+ if (typeof fdR !== 'string') { return; }
280+ fdR = null;
281+
282+ if (IS_WIN) {
283+ // iojs-v2.3.2+ input stream can't read first line. (#18)
284+ // ** Don't get process.stdin before check! **
285+ // Fixed v5.1.0
286+ // Fixed v4.2.4
287+ // It regressed again in v5.6.0, it is fixed in v6.2.0.
288+ verNum = (function(ver) { // getVerNum
289+ var nums = ver.replace(/^\D+/, '').split('.');
290+ var verNum = 0;
291+ if ((nums[0] = +nums[0])) { verNum += nums[0] * 10000; }
292+ if ((nums[1] = +nums[1])) { verNum += nums[1] * 100; }
293+ if ((nums[2] = +nums[2])) { verNum += nums[2]; }
294+ return verNum;
295+ })(process.version);
296+ if (!(verNum >= 20302 && verNum < 40204 || verNum >= 50000 && verNum < 50100 || verNum >= 50600 && verNum < 60200) &&
297+ process.stdin.isTTY) {
298+ process.stdin.pause();
299+ fdR = process.stdin.fd;
300+ ttyR = process.stdin._handle;
301+ } else {
302+ try {
303+ // The stream by fs.openSync('\\\\.\\CON', 'r') can't switch to raw mode.
304+ // 'CONIN$' might fail on XP, 2000, 7 (x86).
305+ fdR = getFsB().open('CONIN$', constants.O_RDWR, parseInt('0666', 8));
306+ ttyR = new TTY(fdR, true);
307+ } catch (e) { /* ignore */ }
308+ }
309+
310+ if (process.stdout.isTTY) {
311+ fdW = process.stdout.fd;
312+ } else {
313+ try {
314+ fdW = fs.openSync('\\\\.\\CON', 'w');
315+ } catch (e) { /* ignore */ }
316+ if (typeof fdW !== 'number') { // Retry
317+ try {
318+ fdW = getFsB().open('CONOUT$', constants.O_RDWR, parseInt('0666', 8));
319+ } catch (e) { /* ignore */ }
320+ }
321+ }
322+
323+ } else {
324+ if (process.stdin.isTTY) {
325+ process.stdin.pause();
326+ try {
327+ fdR = fs.openSync('/dev/tty', 'r'); // device file, not process.stdin
328+ ttyR = process.stdin._handle;
329+ } catch (e) { /* ignore */ }
330+ } else {
331+ // Node.js v0.12 read() fails.
332+ try {
333+ fdR = fs.openSync('/dev/tty', 'r');
334+ ttyR = new TTY(fdR, false);
335+ } catch (e) { /* ignore */ }
336+ }
337+
338+ if (process.stdout.isTTY) {
339+ fdW = process.stdout.fd;
340+ } else {
341+ try {
342+ fdW = fs.openSync('/dev/tty', 'w');
343+ } catch (e) { /* ignore */ }
344+ }
345+ }
346+ })();
347+
348+ (function() { // try read
349+ var isCooked = !options.hideEchoBack && !options.keyIn,
350+ atEol, limit, buffer, reqSize, readSize, chunk, line;
351+ rawInput = '';
352+
353+ // Node.js v0.10- returns an error if same mode is set.
354+ function setRawMode(mode) {
355+ if (mode === isRawMode) { return true; }
356+ if (ttyR.setRawMode(mode) !== 0) { return false; }
357+ isRawMode = mode;
358+ return true;
359+ }
360+
361+ if (_DBG_useExt || !ttyR ||
362+ typeof fdW !== 'number' && (options.display || !isCooked)) {
363+ input = tryExt();
364+ return;
365+ }
366+
367+ if (options.display) {
368+ fs.writeSync(fdW, options.display);
369+ options.display = '';
370+ }
371+ if (options.displayOnly) { return; }
372+
373+ if (!setRawMode(!isCooked)) {
374+ input = tryExt();
375+ return;
376+ }
377+
378+ reqSize = options.keyIn ? 1 : options.bufferSize;
379+ // Check `allocUnsafe` to make sure of the new API.
380+ buffer = Buffer.allocUnsafe && Buffer.alloc ? Buffer.alloc(reqSize) : new Buffer(reqSize);
381+
382+ if (options.keyIn && options.limit) {
383+ limit = new RegExp('[^' + options.limit + ']',
384+ 'g' + (options.caseSensitive ? '' : 'i'));
385+ }
386+
387+ while (true) {
388+ readSize = 0;
389+ try {
390+ readSize = fs.readSync(fdR, buffer, 0, reqSize);
391+ } catch (e) {
392+ if (e.code !== 'EOF') {
393+ setRawMode(false);
394+ input += tryExt();
395+ return;
396+ }
397+ }
398+ if (readSize > 0) {
399+ chunk = buffer.toString(options.encoding, 0, readSize);
400+ rawInput += chunk;
401+ } else {
402+ chunk = '\n';
403+ rawInput += String.fromCharCode(0);
404+ }
405+
406+ if (chunk && typeof (line = (chunk.match(/^(.*?)[\r\n]/) || [])[1]) === 'string') {
407+ chunk = line;
408+ atEol = true;
409+ }
410+
411+ // other ctrl-chars
412+ // eslint-disable-next-line no-control-regex
413+ if (chunk) { chunk = chunk.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, ''); }
414+ if (chunk && limit) { chunk = chunk.replace(limit, ''); }
415+
416+ if (chunk) {
417+ if (!isCooked) {
418+ if (!options.hideEchoBack) {
419+ fs.writeSync(fdW, chunk);
420+ } else if (options.mask) {
421+ fs.writeSync(fdW, (new Array(chunk.length + 1)).join(options.mask));
422+ }
423+ }
424+ input += chunk;
425+ }
426+
427+ if (!options.keyIn && atEol ||
428+ options.keyIn && input.length >= reqSize) { break; }
429+ }
430+
431+ if (!isCooked && !silent) { fs.writeSync(fdW, '\n'); }
432+ setRawMode(false);
433+ })();
434+
435+ if (options.print && !silent) {
436+ options.print(
437+ displaySave + (
438+ options.displayOnly ? '' : (
439+ options.hideEchoBack ? (new Array(input.length + 1)).join(options.mask) : input
440+ ) + '\n' // must at least write '\n'
441+ ),
442+ options.encoding);
443+ }
444+
445+ return options.displayOnly ? '' :
446+ (lastInput = options.keepWhitespace || options.keyIn ? input : input.trim());
447+}
448+
449+function flattenArray(array, validator) {
450+ var flatArray = [];
451+ function _flattenArray(array) {
452+ if (array == null) { return; }
453+ if (Array.isArray(array)) {
454+ array.forEach(_flattenArray);
455+ } else if (!validator || validator(array)) {
456+ flatArray.push(array);
457+ }
458+ }
459+ _flattenArray(array);
460+ return flatArray;
461+}
462+
463+function escapePattern(pattern) {
464+ return pattern.replace(/[\x00-\x7f]/g, // eslint-disable-line no-control-regex
465+ function(s) { return '\\x' + ('00' + s.charCodeAt().toString(16)).substr(-2); });
466+}
467+
468+// margeOptions(options1, options2 ... )
469+// margeOptions(true, options1, options2 ... )
470+// arg1=true : Start from defaultOptions and pick elements of that.
471+function margeOptions() {
472+ var optionsList = Array.prototype.slice.call(arguments),
473+ optionNames, fromDefault;
474+
475+ if (optionsList.length && typeof optionsList[0] === 'boolean') {
476+ fromDefault = optionsList.shift();
477+ if (fromDefault) {
478+ optionNames = Object.keys(defaultOptions);
479+ optionsList.unshift(defaultOptions);
480+ }
481+ }
482+
483+ return optionsList.reduce(function(options, optionsPart) {
484+ if (optionsPart == null) { return options; }
485+
486+ // ======== DEPRECATED ========
487+ if (optionsPart.hasOwnProperty('noEchoBack') &&
488+ !optionsPart.hasOwnProperty('hideEchoBack')) {
489+ optionsPart.hideEchoBack = optionsPart.noEchoBack;
490+ delete optionsPart.noEchoBack;
491+ }
492+ if (optionsPart.hasOwnProperty('noTrim') &&
493+ !optionsPart.hasOwnProperty('keepWhitespace')) {
494+ optionsPart.keepWhitespace = optionsPart.noTrim;
495+ delete optionsPart.noTrim;
496+ }
497+ // ======== /DEPRECATED ========
498+
499+ if (!fromDefault) { optionNames = Object.keys(optionsPart); }
500+ optionNames.forEach(function(optionName) {
501+ var value;
502+ if (!optionsPart.hasOwnProperty(optionName)) { return; }
503+ value = optionsPart[optionName];
504+ /* eslint-disable no-multi-spaces */
505+ switch (optionName) {
506+ // _readlineSync <- * * -> defaultOptions
507+ // ================ string
508+ case 'mask': // * *
509+ case 'limitMessage': // *
510+ case 'defaultInput': // *
511+ case 'encoding': // * *
512+ value = value != null ? value + '' : '';
513+ if (value && optionName !== 'limitMessage') { value = value.replace(/[\r\n]/g, ''); }
514+ options[optionName] = value;
515+ break;
516+ // ================ number(int)
517+ case 'bufferSize': // * *
518+ if (!isNaN(value = parseInt(value, 10)) && typeof value === 'number') {
519+ options[optionName] = value; // limited updating (number is needed)
520+ }
521+ break;
522+ // ================ boolean
523+ case 'displayOnly': // *
524+ case 'keyIn': // *
525+ case 'hideEchoBack': // * *
526+ case 'caseSensitive': // * *
527+ case 'keepWhitespace': // * *
528+ case 'history': // *
529+ case 'cd': // *
530+ options[optionName] = !!value;
531+ break;
532+ // ================ array
533+ case 'limit': // * * to string for readlineExt
534+ case 'trueValue': // *
535+ case 'falseValue': // *
536+ options[optionName] = flattenArray(value, function(value) {
537+ var type = typeof value;
538+ return type === 'string' || type === 'number' ||
539+ type === 'function' || value instanceof RegExp;
540+ }).map(function(value) {
541+ return typeof value === 'string' ? value.replace(/[\r\n]/g, '') : value;
542+ });
543+ break;
544+ // ================ function
545+ case 'print': // * *
546+ case 'phContent': // *
547+ case 'preCheck': // *
548+ options[optionName] = typeof value === 'function' ? value : void 0;
549+ break;
550+ // ================ other
551+ case 'prompt': // *
552+ case 'display': // *
553+ options[optionName] = value != null ? value : '';
554+ break;
555+ // no default
556+ }
557+ /* eslint-enable no-multi-spaces */
558+ });
559+ return options;
560+ }, {});
561+}
562+
563+function isMatched(res, comps, caseSensitive) {
564+ return comps.some(function(comp) {
565+ var type = typeof comp;
566+ return type === 'string'
567+ ? (caseSensitive ? res === comp : res.toLowerCase() === comp.toLowerCase()) :
568+ type === 'number' ? parseFloat(res) === comp :
569+ type === 'function' ? comp(res) :
570+ comp instanceof RegExp ? comp.test(res) : false;
571+ });
572+}
573+
574+function replaceHomePath(path, expand) {
575+ var homePath = pathUtil.normalize(
576+ IS_WIN ? (process.env.HOMEDRIVE || '') + (process.env.HOMEPATH || '') :
577+ process.env.HOME || '').replace(/[/\\]+$/, '');
578+ path = pathUtil.normalize(path);
579+ return expand ? path.replace(/^~(?=\/|\\|$)/, homePath) :
580+ path.replace(new RegExp('^' + escapePattern(homePath) +
581+ '(?=\\/|\\\\|$)', IS_WIN ? 'i' : ''), '~');
582+}
583+
584+function replacePlaceholder(text, generator) {
585+ var PTN_INNER = '(?:\\(([\\s\\S]*?)\\))?(\\w+|.-.)(?:\\(([\\s\\S]*?)\\))?',
586+ rePlaceholder = new RegExp('(\\$)?(\\$<' + PTN_INNER + '>)', 'g'),
587+ rePlaceholderCompat = new RegExp('(\\$)?(\\$\\{' + PTN_INNER + '\\})', 'g');
588+
589+ function getPlaceholderText(s, escape, placeholder, pre, param, post) {
590+ var text;
591+ return escape || typeof (text = generator(param)) !== 'string' ? placeholder :
592+ text ? (pre || '') + text + (post || '') : '';
593+ }
594+
595+ return text.replace(rePlaceholder, getPlaceholderText)
596+ .replace(rePlaceholderCompat, getPlaceholderText);
597+}
598+
599+function array2charlist(array, caseSensitive, collectSymbols) {
600+ var group = [],
601+ groupClass = -1,
602+ charCode = 0,
603+ symbols = '',
604+ values, suppressed;
605+ function addGroup(groups, group) {
606+ if (group.length > 3) { // ellipsis
607+ groups.push(group[0] + '...' + group[group.length - 1]);
608+ suppressed = true;
609+ } else if (group.length) {
610+ groups = groups.concat(group);
611+ }
612+ return groups;
613+ }
614+
615+ values = array.reduce(function(chars, value) {
616+ return chars.concat((value + '').split(''));
617+ }, []).reduce(function(groups, curChar) {
618+ var curGroupClass, curCharCode;
619+ if (!caseSensitive) { curChar = curChar.toLowerCase(); }
620+ curGroupClass = /^\d$/.test(curChar) ? 1 :
621+ /^[A-Z]$/.test(curChar) ? 2 : /^[a-z]$/.test(curChar) ? 3 : 0;
622+ if (collectSymbols && curGroupClass === 0) {
623+ symbols += curChar;
624+ } else {
625+ curCharCode = curChar.charCodeAt(0);
626+ if (curGroupClass && curGroupClass === groupClass &&
627+ curCharCode === charCode + 1) {
628+ group.push(curChar);
629+ } else {
630+ groups = addGroup(groups, group);
631+ group = [curChar];
632+ groupClass = curGroupClass;
633+ }
634+ charCode = curCharCode;
635+ }
636+ return groups;
637+ }, []);
638+ values = addGroup(values, group); // last group
639+ if (symbols) { values.push(symbols); suppressed = true; }
640+ return {values: values, suppressed: suppressed};
641+}
642+
643+function joinChunks(chunks, suppressed) {
644+ return chunks.join(chunks.length > 2 ? ', ' : suppressed ? ' / ' : '/');
645+}
646+
647+function getPhContent(param, options) {
648+ var resCharlist = {},
649+ text, values, arg;
650+ if (options.phContent) {
651+ text = options.phContent(param, options);
652+ }
653+ if (typeof text !== 'string') {
654+ switch (param) {
655+ case 'hideEchoBack':
656+ case 'mask':
657+ case 'defaultInput':
658+ case 'caseSensitive':
659+ case 'keepWhitespace':
660+ case 'encoding':
661+ case 'bufferSize':
662+ case 'history':
663+ case 'cd':
664+ text = !options.hasOwnProperty(param) ? '' :
665+ typeof options[param] === 'boolean' ? (options[param] ? 'on' : 'off') :
666+ options[param] + '';
667+ break;
668+ // case 'prompt':
669+ // case 'query':
670+ // case 'display':
671+ // text = options.hasOwnProperty('displaySrc') ? options.displaySrc + '' : '';
672+ // break;
673+ case 'limit':
674+ case 'trueValue':
675+ case 'falseValue':
676+ values = options[options.hasOwnProperty(param + 'Src') ? param + 'Src' : param];
677+ if (options.keyIn) { // suppress
678+ resCharlist = array2charlist(values, options.caseSensitive);
679+ values = resCharlist.values;
680+ } else {
681+ values = values.filter(function(value) {
682+ var type = typeof value;
683+ return type === 'string' || type === 'number';
684+ });
685+ }
686+ text = joinChunks(values, resCharlist.suppressed);
687+ break;
688+ case 'limitCount':
689+ case 'limitCountNotZero':
690+ text = options[options.hasOwnProperty('limitSrc') ? 'limitSrc' : 'limit'].length;
691+ text = text || param !== 'limitCountNotZero' ? text + '' : '';
692+ break;
693+ case 'lastInput':
694+ text = lastInput;
695+ break;
696+ case 'cwd':
697+ case 'CWD':
698+ case 'cwdHome':
699+ text = process.cwd();
700+ if (param === 'CWD') {
701+ text = pathUtil.basename(text);
702+ } else if (param === 'cwdHome') {
703+ text = replaceHomePath(text);
704+ }
705+ break;
706+ case 'date':
707+ case 'time':
708+ case 'localeDate':
709+ case 'localeTime':
710+ text = (new Date())['to' +
711+ param.replace(/^./, function(str) { return str.toUpperCase(); }) +
712+ 'String']();
713+ break;
714+ default: // with arg
715+ if (typeof (arg = (param.match(/^history_m(\d+)$/) || [])[1]) === 'string') {
716+ text = inputHistory[inputHistory.length - arg] || '';
717+ }
718+ }
719+ }
720+ return text;
721+}
722+
723+function getPhCharlist(param) {
724+ var matches = /^(.)-(.)$/.exec(param),
725+ text = '',
726+ from, to, code, step;
727+ if (!matches) { return null; }
728+ from = matches[1].charCodeAt(0);
729+ to = matches[2].charCodeAt(0);
730+ step = from < to ? 1 : -1;
731+ for (code = from; code !== to + step; code += step) { text += String.fromCharCode(code); }
732+ return text;
733+}
734+
735+// cmd "arg" " a r g " "" 'a"r"g' "a""rg" "arg
736+function parseCl(cl) {
737+ var reToken = new RegExp(/(\s*)(?:("|')(.*?)(?:\2|$)|(\S+))/g),
738+ taken = '',
739+ args = [],
740+ matches, part;
741+ cl = cl.trim();
742+ while ((matches = reToken.exec(cl))) {
743+ part = matches[3] || matches[4] || '';
744+ if (matches[1]) {
745+ args.push(taken);
746+ taken = '';
747+ }
748+ taken += part;
749+ }
750+ if (taken) { args.push(taken); }
751+ return args;
752+}
753+
754+function toBool(res, options) {
755+ return (
756+ (options.trueValue.length &&
757+ isMatched(res, options.trueValue, options.caseSensitive)) ? true :
758+ (options.falseValue.length &&
759+ isMatched(res, options.falseValue, options.caseSensitive)) ? false : res);
760+}
761+
762+function getValidLine(options) {
763+ var res, forceNext, limitMessage,
764+ matches, histInput, args, resCheck;
765+
766+ function _getPhContent(param) { return getPhContent(param, options); }
767+ function addDisplay(text) { options.display += (/[^\r\n]$/.test(options.display) ? '\n' : '') + text; }
768+
769+ options.limitSrc = options.limit;
770+ options.displaySrc = options.display;
771+ options.limit = ''; // for readlineExt
772+ options.display = replacePlaceholder(options.display + '', _getPhContent);
773+
774+ while (true) {
775+ res = _readlineSync(options);
776+ forceNext = false;
777+ limitMessage = '';
778+
779+ if (options.defaultInput && !res) { res = options.defaultInput; }
780+
781+ if (options.history) {
782+ if ((matches = /^\s*!(?:!|-1)(:p)?\s*$/.exec(res))) { // `!!` `!-1` +`:p`
783+ histInput = inputHistory[0] || '';
784+ if (matches[1]) { // only display
785+ forceNext = true;
786+ } else { // replace input
787+ res = histInput;
788+ }
789+ // Show it even if it is empty (NL only).
790+ addDisplay(histInput + '\n');
791+ if (!forceNext) { // Loop may break
792+ options.displayOnly = true;
793+ _readlineSync(options);
794+ options.displayOnly = false;
795+ }
796+ } else if (res && res !== inputHistory[inputHistory.length - 1]) {
797+ inputHistory = [res];
798+ }
799+ }
800+
801+ if (!forceNext && options.cd && res) {
802+ args = parseCl(res);
803+ switch (args[0].toLowerCase()) {
804+ case 'cd':
805+ if (args[1]) {
806+ try {
807+ process.chdir(replaceHomePath(args[1], true));
808+ } catch (e) {
809+ addDisplay(e + '');
810+ }
811+ }
812+ forceNext = true;
813+ break;
814+ case 'pwd':
815+ addDisplay(process.cwd());
816+ forceNext = true;
817+ break;
818+ // no default
819+ }
820+ }
821+
822+ if (!forceNext && options.preCheck) {
823+ resCheck = options.preCheck(res, options);
824+ res = resCheck.res;
825+ if (resCheck.forceNext) { forceNext = true; } // Don't switch to false.
826+ }
827+
828+ if (!forceNext) {
829+ if (!options.limitSrc.length ||
830+ isMatched(res, options.limitSrc, options.caseSensitive)) { break; }
831+ if (options.limitMessage) {
832+ limitMessage = replacePlaceholder(options.limitMessage, _getPhContent);
833+ }
834+ }
835+
836+ addDisplay((limitMessage ? limitMessage + '\n' : '') +
837+ replacePlaceholder(options.displaySrc + '', _getPhContent));
838+ }
839+ return toBool(res, options);
840+}
841+
842+// for dev
843+exports._DBG_set_useExt = function(val) { _DBG_useExt = val; };
844+exports._DBG_set_checkOptions = function(val) { _DBG_checkOptions = val; };
845+exports._DBG_set_checkMethod = function(val) { _DBG_checkMethod = val; };
846+exports._DBG_clearHistory = function() { lastInput = ''; inputHistory = []; };
847+
848+// ------------------------------------
849+
850+exports.setDefaultOptions = function(options) {
851+ defaultOptions = margeOptions(true, options);
852+ return margeOptions(true); // copy
853+};
854+
855+exports.question = function(query, options) {
856+ /* eslint-disable key-spacing */
857+ return getValidLine(margeOptions(margeOptions(true, options), {
858+ display: query
859+ }));
860+ /* eslint-enable key-spacing */
861+};
862+
863+exports.prompt = function(options) {
864+ var readOptions = margeOptions(true, options);
865+ readOptions.display = readOptions.prompt;
866+ return getValidLine(readOptions);
867+};
868+
869+exports.keyIn = function(query, options) {
870+ /* eslint-disable key-spacing */
871+ var readOptions = margeOptions(margeOptions(true, options), {
872+ display: query,
873+ keyIn: true,
874+ keepWhitespace: true
875+ });
876+ /* eslint-enable key-spacing */
877+
878+ // char list
879+ readOptions.limitSrc = readOptions.limit.filter(function(value) {
880+ var type = typeof value;
881+ return type === 'string' || type === 'number';
882+ }).map(function(text) {
883+ return replacePlaceholder(text + '', getPhCharlist);
884+ });
885+ // pattern
886+ readOptions.limit = escapePattern(readOptions.limitSrc.join(''));
887+
888+ ['trueValue', 'falseValue'].forEach(function(optionName) {
889+ readOptions[optionName] = readOptions[optionName].reduce(function(comps, comp) {
890+ var type = typeof comp;
891+ if (type === 'string' || type === 'number') {
892+ comps = comps.concat((comp + '').split(''));
893+ } else { comps.push(comp); }
894+ return comps;
895+ }, []);
896+ });
897+
898+ readOptions.display = replacePlaceholder(readOptions.display + '',
899+ function(param) { return getPhContent(param, readOptions); });
900+
901+ return toBool(_readlineSync(readOptions), readOptions);
902+};
903+
904+// ------------------------------------
905+
906+exports.questionEMail = function(query, options) {
907+ if (query == null) { query = 'Input e-mail address: '; }
908+ /* eslint-disable key-spacing */
909+ return exports.question(query, margeOptions({
910+ // -------- default
911+ hideEchoBack: false,
912+ // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address
913+ limit: /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/,
914+ limitMessage: 'Input valid e-mail address, please.',
915+ trueValue: null,
916+ falseValue: null
917+ }, options, {
918+ // -------- forced
919+ keepWhitespace: false,
920+ cd: false
921+ }));
922+ /* eslint-enable key-spacing */
923+};
924+
925+exports.questionNewPassword = function(query, options) {
926+ /* eslint-disable key-spacing */
927+ var resCharlist, min, max,
928+ readOptions = margeOptions({
929+ // -------- default
930+ hideEchoBack: true,
931+ mask: '*',
932+ limitMessage: 'It can include: $<charlist>\n' +
933+ 'And the length must be: $<length>',
934+ trueValue: null,
935+ falseValue: null,
936+ caseSensitive: true
937+ }, options, {
938+ // -------- forced
939+ history: false,
940+ cd: false,
941+ // limit (by charlist etc.),
942+ phContent: function(param) {
943+ return param === 'charlist' ? resCharlist.text :
944+ param === 'length' ? min + '...' + max : null;
945+ }
946+ }),
947+ // added: charlist, min, max, confirmMessage, unmatchMessage
948+ charlist, confirmMessage, unmatchMessage,
949+ limit, limitMessage, res1, res2;
950+ /* eslint-enable key-spacing */
951+ options = options || {};
952+
953+ charlist = replacePlaceholder(
954+ options.charlist ? options.charlist + '' : '$<!-~>', getPhCharlist);
955+ if (isNaN(min = parseInt(options.min, 10)) || typeof min !== 'number') { min = 12; }
956+ if (isNaN(max = parseInt(options.max, 10)) || typeof max !== 'number') { max = 24; }
957+ limit = new RegExp('^[' + escapePattern(charlist) +
958+ ']{' + min + ',' + max + '}$');
959+ resCharlist = array2charlist([charlist], readOptions.caseSensitive, true);
960+ resCharlist.text = joinChunks(resCharlist.values, resCharlist.suppressed);
961+
962+ confirmMessage = options.confirmMessage != null ? options.confirmMessage :
963+ 'Reinput a same one to confirm it: ';
964+ unmatchMessage = options.unmatchMessage != null ? options.unmatchMessage :
965+ 'It differs from first one.' +
966+ ' Hit only the Enter key if you want to retry from first one.';
967+
968+ if (query == null) { query = 'Input new password: '; }
969+
970+ limitMessage = readOptions.limitMessage;
971+ while (!res2) {
972+ readOptions.limit = limit;
973+ readOptions.limitMessage = limitMessage;
974+ res1 = exports.question(query, readOptions);
975+
976+ readOptions.limit = [res1, ''];
977+ readOptions.limitMessage = unmatchMessage;
978+ res2 = exports.question(confirmMessage, readOptions);
979+ }
980+
981+ return res1;
982+};
983+
984+function _questionNum(query, options, parser) {
985+ var validValue;
986+ function getValidValue(value) {
987+ validValue = parser(value);
988+ return !isNaN(validValue) && typeof validValue === 'number';
989+ }
990+ /* eslint-disable key-spacing */
991+ exports.question(query, margeOptions({
992+ // -------- default
993+ limitMessage: 'Input valid number, please.'
994+ }, options, {
995+ // -------- forced
996+ limit: getValidValue,
997+ cd: false
998+ // trueValue, falseValue, caseSensitive, keepWhitespace don't work.
999+ }));
1000+ /* eslint-enable key-spacing */
1001+ return validValue;
1002+}
1003+exports.questionInt = function(query, options) {
1004+ return _questionNum(query, options, function(value) { return parseInt(value, 10); });
1005+};
1006+exports.questionFloat = function(query, options) {
1007+ return _questionNum(query, options, parseFloat);
1008+};
1009+
1010+exports.questionPath = function(query, options) {
1011+ /* eslint-disable key-spacing */
1012+ var error = '',
1013+ validPath, // before readOptions
1014+ readOptions = margeOptions({
1015+ // -------- default
1016+ hideEchoBack: false,
1017+ limitMessage: '$<error(\n)>Input valid path, please.' +
1018+ '$<( Min:)min>$<( Max:)max>',
1019+ history: true,
1020+ cd: true
1021+ }, options, {
1022+ // -------- forced
1023+ keepWhitespace: false,
1024+ limit: function(value) {
1025+ var exists, stat, res;
1026+ value = replaceHomePath(value, true);
1027+ error = ''; // for validate
1028+ // mkdir -p
1029+ function mkdirParents(dirPath) {
1030+ dirPath.split(/\/|\\/).reduce(function(parents, dir) {
1031+ var path = pathUtil.resolve((parents += dir + pathUtil.sep));
1032+ if (!fs.existsSync(path)) {
1033+ fs.mkdirSync(path);
1034+ } else if (!fs.statSync(path).isDirectory()) {
1035+ throw new Error('Non directory already exists: ' + path);
1036+ }
1037+ return parents;
1038+ }, '');
1039+ }
1040+
1041+ try {
1042+ exists = fs.existsSync(value);
1043+ validPath = exists ? fs.realpathSync(value) : pathUtil.resolve(value);
1044+ // options.exists default: true, not-bool: no-check
1045+ if (!options.hasOwnProperty('exists') && !exists ||
1046+ typeof options.exists === 'boolean' && options.exists !== exists) {
1047+ error = (exists ? 'Already exists' : 'No such file or directory') +
1048+ ': ' + validPath;
1049+ return false;
1050+ }
1051+ if (!exists && options.create) {
1052+ if (options.isDirectory) {
1053+ mkdirParents(validPath);
1054+ } else {
1055+ mkdirParents(pathUtil.dirname(validPath));
1056+ fs.closeSync(fs.openSync(validPath, 'w')); // touch
1057+ }
1058+ validPath = fs.realpathSync(validPath);
1059+ }
1060+ if (exists && (options.min || options.max ||
1061+ options.isFile || options.isDirectory)) {
1062+ stat = fs.statSync(validPath);
1063+ // type check first (directory has zero size)
1064+ if (options.isFile && !stat.isFile()) {
1065+ error = 'Not file: ' + validPath;
1066+ return false;
1067+ } else if (options.isDirectory && !stat.isDirectory()) {
1068+ error = 'Not directory: ' + validPath;
1069+ return false;
1070+ } else if (options.min && stat.size < +options.min ||
1071+ options.max && stat.size > +options.max) {
1072+ error = 'Size ' + stat.size + ' is out of range: ' + validPath;
1073+ return false;
1074+ }
1075+ }
1076+ if (typeof options.validate === 'function' &&
1077+ (res = options.validate(validPath)) !== true) {
1078+ if (typeof res === 'string') { error = res; }
1079+ return false;
1080+ }
1081+ } catch (e) {
1082+ error = e + '';
1083+ return false;
1084+ }
1085+ return true;
1086+ },
1087+ // trueValue, falseValue, caseSensitive don't work.
1088+ phContent: function(param) {
1089+ return param === 'error' ? error :
1090+ param !== 'min' && param !== 'max' ? null :
1091+ options.hasOwnProperty(param) ? options[param] + '' : '';
1092+ }
1093+ });
1094+ // added: exists, create, min, max, isFile, isDirectory, validate
1095+ /* eslint-enable key-spacing */
1096+ options = options || {};
1097+
1098+ if (query == null) { query = 'Input path (you can "cd" and "pwd"): '; }
1099+
1100+ exports.question(query, readOptions);
1101+ return validPath;
1102+};
1103+
1104+// props: preCheck, args, hRes, limit
1105+function getClHandler(commandHandler, options) {
1106+ var clHandler = {},
1107+ hIndex = {};
1108+ if (typeof commandHandler === 'object') {
1109+ Object.keys(commandHandler).forEach(function(cmd) {
1110+ if (typeof commandHandler[cmd] === 'function') {
1111+ hIndex[options.caseSensitive ? cmd : cmd.toLowerCase()] = commandHandler[cmd];
1112+ }
1113+ });
1114+ clHandler.preCheck = function(res) {
1115+ var cmdKey;
1116+ clHandler.args = parseCl(res);
1117+ cmdKey = clHandler.args[0] || '';
1118+ if (!options.caseSensitive) { cmdKey = cmdKey.toLowerCase(); }
1119+ clHandler.hRes =
1120+ cmdKey !== '_' && hIndex.hasOwnProperty(cmdKey)
1121+ ? hIndex[cmdKey].apply(res, clHandler.args.slice(1)) :
1122+ hIndex.hasOwnProperty('_') ? hIndex._.apply(res, clHandler.args) : null;
1123+ return {res: res, forceNext: false};
1124+ };
1125+ if (!hIndex.hasOwnProperty('_')) {
1126+ clHandler.limit = function() { // It's called after preCheck.
1127+ var cmdKey = clHandler.args[0] || '';
1128+ if (!options.caseSensitive) { cmdKey = cmdKey.toLowerCase(); }
1129+ return hIndex.hasOwnProperty(cmdKey);
1130+ };
1131+ }
1132+ } else {
1133+ clHandler.preCheck = function(res) {
1134+ clHandler.args = parseCl(res);
1135+ clHandler.hRes = typeof commandHandler === 'function'
1136+ ? commandHandler.apply(res, clHandler.args) : true; // true for break loop
1137+ return {res: res, forceNext: false};
1138+ };
1139+ }
1140+ return clHandler;
1141+}
1142+
1143+exports.promptCL = function(commandHandler, options) {
1144+ /* eslint-disable key-spacing */
1145+ var readOptions = margeOptions({
1146+ // -------- default
1147+ hideEchoBack: false,
1148+ limitMessage: 'Requested command is not available.',
1149+ caseSensitive: false,
1150+ history: true
1151+ }, options),
1152+ // -------- forced
1153+ // trueValue, falseValue, keepWhitespace don't work.
1154+ // preCheck, limit (by clHandler)
1155+ clHandler = getClHandler(commandHandler, readOptions);
1156+ /* eslint-enable key-spacing */
1157+ readOptions.limit = clHandler.limit;
1158+ readOptions.preCheck = clHandler.preCheck;
1159+ exports.prompt(readOptions);
1160+ return clHandler.args;
1161+};
1162+
1163+exports.promptLoop = function(inputHandler, options) {
1164+ /* eslint-disable key-spacing */
1165+ var readOptions = margeOptions({
1166+ // -------- default
1167+ hideEchoBack: false,
1168+ trueValue: null,
1169+ falseValue: null,
1170+ caseSensitive: false,
1171+ history: true
1172+ }, options);
1173+ /* eslint-enable key-spacing */
1174+ while (true) { if (inputHandler(exports.prompt(readOptions))) { break; } }
1175+ // return; // nothing is returned
1176+};
1177+
1178+exports.promptCLLoop = function(commandHandler, options) {
1179+ /* eslint-disable key-spacing */
1180+ var readOptions = margeOptions({
1181+ // -------- default
1182+ hideEchoBack: false,
1183+ limitMessage: 'Requested command is not available.',
1184+ caseSensitive: false,
1185+ history: true
1186+ }, options),
1187+ // -------- forced
1188+ // trueValue, falseValue, keepWhitespace don't work.
1189+ // preCheck, limit (by clHandler)
1190+ clHandler = getClHandler(commandHandler, readOptions);
1191+ /* eslint-enable key-spacing */
1192+ readOptions.limit = clHandler.limit;
1193+ readOptions.preCheck = clHandler.preCheck;
1194+ while (true) {
1195+ exports.prompt(readOptions);
1196+ if (clHandler.hRes) { break; }
1197+ }
1198+ // return; // nothing is returned
1199+};
1200+
1201+exports.promptSimShell = function(options) {
1202+ /* eslint-disable key-spacing */
1203+ return exports.prompt(margeOptions({
1204+ // -------- default
1205+ hideEchoBack: false,
1206+ history: true
1207+ }, options, {
1208+ // -------- forced
1209+ prompt: (function() {
1210+ return IS_WIN ? '$<cwd>>' :
1211+ // 'user@host:cwd$ '
1212+ (process.env.USER || '') +
1213+ (process.env.HOSTNAME ? '@' + process.env.HOSTNAME.replace(/\..*$/, '') : '') +
1214+ ':$<cwdHome>$ ';
1215+ })()
1216+ }));
1217+ /* eslint-enable key-spacing */
1218+};
1219+
1220+function _keyInYN(query, options, limit) {
1221+ var res;
1222+ if (query == null) { query = 'Are you sure? '; }
1223+ if ((!options || options.guide !== false) && (query += '')) {
1224+ query = query.replace(/\s*:?\s*$/, '') + ' [y/n]: ';
1225+ }
1226+ /* eslint-disable key-spacing */
1227+ res = exports.keyIn(query, margeOptions(options, {
1228+ // -------- forced
1229+ hideEchoBack: false,
1230+ limit: limit,
1231+ trueValue: 'y',
1232+ falseValue: 'n',
1233+ caseSensitive: false
1234+ // mask doesn't work.
1235+ }));
1236+ // added: guide
1237+ /* eslint-enable key-spacing */
1238+ return typeof res === 'boolean' ? res : '';
1239+}
1240+exports.keyInYN = function(query, options) { return _keyInYN(query, options); };
1241+exports.keyInYNStrict = function(query, options) { return _keyInYN(query, options, 'yn'); };
1242+
1243+exports.keyInPause = function(query, options) {
1244+ if (query == null) { query = 'Continue...'; }
1245+ if ((!options || options.guide !== false) && (query += '')) {
1246+ query = query.replace(/\s+$/, '') + ' (Hit any key)';
1247+ }
1248+ /* eslint-disable key-spacing */
1249+ exports.keyIn(query, margeOptions({
1250+ // -------- default
1251+ limit: null
1252+ }, options, {
1253+ // -------- forced
1254+ hideEchoBack: true,
1255+ mask: ''
1256+ }));
1257+ // added: guide
1258+ /* eslint-enable key-spacing */
1259+ // return; // nothing is returned
1260+};
1261+
1262+exports.keyInSelect = function(items, query, options) {
1263+ /* eslint-disable key-spacing */
1264+ var readOptions = margeOptions({
1265+ // -------- default
1266+ hideEchoBack: false
1267+ }, options, {
1268+ // -------- forced
1269+ trueValue: null,
1270+ falseValue: null,
1271+ caseSensitive: false,
1272+ // limit (by items),
1273+ phContent: function(param) {
1274+ return param === 'itemsCount' ? items.length + '' :
1275+ param === 'firstItem' ? (items[0] + '').trim() :
1276+ param === 'lastItem' ? (items[items.length - 1] + '').trim() : null;
1277+ }
1278+ }),
1279+ // added: guide, cancel
1280+ keylist = '',
1281+ key2i = {},
1282+ charCode = 49 /* '1' */,
1283+ display = '\n';
1284+ /* eslint-enable key-spacing */
1285+ if (!Array.isArray(items) || !items.length || items.length > 35) {
1286+ throw '`items` must be Array (max length: 35).';
1287+ }
1288+
1289+ items.forEach(function(item, i) {
1290+ var key = String.fromCharCode(charCode);
1291+ keylist += key;
1292+ key2i[key] = i;
1293+ display += '[' + key + '] ' + (item + '').trim() + '\n';
1294+ charCode = charCode === 57 /* '9' */ ? 97 /* 'a' */ : charCode + 1;
1295+ });
1296+ if (!options || options.cancel !== false) {
1297+ keylist += '0';
1298+ key2i['0'] = -1;
1299+ display += '[0] ' +
1300+ (options && options.cancel != null && typeof options.cancel !== 'boolean'
1301+ ? (options.cancel + '').trim() : 'CANCEL') + '\n';
1302+ }
1303+ readOptions.limit = keylist;
1304+ display += '\n';
1305+
1306+ if (query == null) { query = 'Choose one from list: '; }
1307+ if ((query += '')) {
1308+ if (!options || options.guide !== false) {
1309+ query = query.replace(/\s*:?\s*$/, '') + ' [$<limit>]: ';
1310+ }
1311+ display += query;
1312+ }
1313+
1314+ return key2i[exports.keyIn(display, readOptions).toLowerCase()];
1315+};
1316+
1317+exports.getRawInput = function() { return rawInput; };
1318+
1319+// ======== DEPRECATED ========
1320+function _setOption(optionName, args) {
1321+ var options;
1322+ if (args.length) { options = {}; options[optionName] = args[0]; }
1323+ return exports.setDefaultOptions(options)[optionName];
1324+}
1325+exports.setPrint = function() { return _setOption('print', arguments); };
1326+exports.setPrompt = function() { return _setOption('prompt', arguments); };
1327+exports.setEncoding = function() { return _setOption('encoding', arguments); };
1328+exports.setMask = function() { return _setOption('mask', arguments); };
1329+exports.setBufferSize = function() { return _setOption('bufferSize', arguments); };
scripts/docker-install.sh+2−1
@@ -37,7 +37,6 @@ libnspr4-dev
3737
3838# used during installation
3939git
40−curl
4140wget
4241
4342# used during runtime
@@ -47,6 +46,8 @@ rlwrap
4746
4847export DEBIAN_FRONTEND=noninteractive
4948apt-get update
49+apt-get install -y curl
50+curl -sL https://deb.nodesource.com/setup_12.x | bash -
5051apt-get install -y $(grep -v "^#" <<< "$packages")
5152rm -rf /var/lib/apt/lists/*
5253
test_files/hello.jsnew file+3
@@ -0,0 +1,3 @@
1+let a = "hello";
2+console.log(a);
3+a;
tests/nodejs/err.expnew file+21
@@ -0,0 +1,21 @@
1+#!/usr/bin/expect -f
2+
3+set timeout -1
4+spawn ./prybar-nodejs -i -q
5+match_max 100000
6+expect -exact "\[1G\[0J--> \[5G"
7+send -- "x\r"
8+expect -exact "x\r\r
9+\u001b\[0m\u001b\[31mReferenceError: x is not defined\r
10+ at repl:1:1\r
11+ at Script.runInContext (vm.js:130:18)\r
12+ at REPLServer.defaultEval (repl.js:435:29)\r
13+ at bound (domain.js:427:14)\r
14+ at REPLServer.runBound \[as eval\] (domain.js:440:12)\r
15+ at REPLServer.onLine (repl.js:760:10)\r
16+ at REPLServer.emit (events.js:315:20)\r
17+ at REPLServer.EventEmitter.emit (domain.js:483:12)\r
18+ at REPLServer.Interface._onLine (readline.js:329:10)\r
19+ at REPLServer.Interface._line (readline.js:658:8)\u001b\[0m\u001b\[1G\u001b\[0J--> \u001b\[5G"
20+send -- ""
21+expect eof
tests/nodejs/eval_code.expnew file+8
@@ -0,0 +1,8 @@
1+#!/usr/bin/expect -d
2+
3+set timeout -1
4+spawn ./prybar-nodejs -q -e 1+1
5+match_max 100000
6+expect -exact "\u001b\[33m2\u001b\[39m\r
7+"
8+expect eof
tests/nodejs/header.expnew file+9
@@ -0,0 +1,9 @@
1+#!/usr/bin/expect -f
2+
3+set timeout -1
4+spawn ./prybar-nodejs -i
5+match_max 100000
6+expect -re {Node v\d+\.\d+.\d+ on linux}
7+expect -exact "\[1G\[0J--> \[5G"
8+send -- ""
9+expect eof
tests/nodejs/printing.expnew file+13
@@ -0,0 +1,13 @@
1+#!/usr/bin/expect -f
2+
3+set timeout -1
4+spawn ./prybar-nodejs -i -q
5+match_max 100000
6+expect -exact "\[1G\[0J--> \[5G"
7+send -- "console.log('x')\r"
8+expect -exact "console.log('x')\r\r
9+x\r
10+\[90mundefined\[39m\r
11+\[1G\[0J--> "
12+send -- ""
13+expect eof
tests/nodejs/run_code.expnew file+6
@@ -0,0 +1,6 @@
1+#!/usr/bin/expect -f
2+
3+set timeout -1
4+spawn ./prybar-nodejs -q -c 1+1
5+match_max 100000
6+expect eof
tests/nodejs/run_file.expnew file+16
@@ -0,0 +1,16 @@
1+#!/usr/bin/expect -d
2+
3+set timeout -1
4+spawn ./prybar-nodejs -i ./test_files/hello.js
5+match_max 100000
6+expect -exact "Node v12.18.3 on linux\r
7+\u001b\[0m\u001b\[90mHint: hit control+c anytime to enter REPL.\[0m\r
8+hello\r
9+\u001b\[32m'hello'\u001b\[39m\r
10+\u001b\[1G\u001b\[0J--> \u001b\[5G"
11+send -- "a\r"
12+expect -exact "a\r\r
13+\u001b\[32m'hello'\u001b\[39m\r
14+\u001b\[1G\u001b\[0J--> \u001b\[5G"
15+send -- ""
16+expect eof