My goal has been to expand
Josh.Shell to be a better emulation of a console window. It seems simple enough: execute a command, print the output in a
div. But print something longer than your shell window and you immediately see where the real thing has a couple more tricks up its sleeve:
If foo.txt is too large, you could use
And now you pagination, plus a couple of other neat features.
Ok, let’s implement that in
Josh.Shell. Let’s start with the
less command. It could be hardcoded to know the
div the content is displayed in, do some measuring and start paginating output. Aside from being ugly, you immediately run into another problem: In order to determine after what line you pause paginated output, how do you determine where one line begins and ends. Which only further exposes the problem of output in a
div, sure the browser will wrap the text for you, but by delegating layout to the browser, you’ve lost all knowledge about the shape of the content.
To start taking back control over output we need the equivalent of
TermCap, i.e. an abstraction of our terminal
div that at least gives height and width in terms of characters. Next, we need change output to be just a string of characters with line feeds. This does lead us down a rabbit hole where we’ll eventually need to figure out how to handle ANSI terminal colors, and other character markup, but for the time being, let’s assume just plain-text ASCII.
Now we could implement a basic form of
less. But chances are the first time you want to use less is a scenario such as this:
ls -lah /foo | less
i.e. we don’t have a file that we want to display, we have the output of an existing command that we want to pipe into
less. And this is where we run into our next problem:
Josh.Readline has only one processor for the entire command line, i.e. the above will always be handled by the command handler attached to
ls. And while we could make that command handler smart enough to understand | we’d have to do it for every command and then do the same for < and >.
Intercepting command and completion handling
No, what we need is a way to intercept readline processing before it goes to the command handler for either execution or completion, so that we can recognize command separators and handle each appropriately. It also means that the command no longer should return their output to the shell, but that the pre-processor executing multiple commands receives it and provide it as input for the next command.
The pre-processor work will go in Josh.Readline and can be discussed via Issue 16, while the pipping behavior will be implemented on top of the pre-processor work and discussion of it should happen on Issue 18.
We certainly could just chain the callbacks, but we still have no way of providing input, and we’d end up being completely synchronous, i.e. one command would have to run to completion before its output could be piped to the next.
Rather than inventing some crazy custom callback scheme, what we are really looking at is just standard I/O. Rather than getting a callback to provide output, the command invocation should receive an environment, which provides input, output and error streams along with
TermCap and a completion code callback. The input stream (
stdin) can be only be read from while output (
stdout) and error (
stderr) can only be written to. As soon as the out streams are written to, the next receiver (command or shell) will be invoked with the output as its input.
Stderr by default will invoke the shell regardless of what other commands are still in the pipeline.
All these changes are planned for 0.3, a minor revision bump, because it will likely introduce some breaking changes. I don’t want to stop supporting the ability to just return HTML, so the
stdio model might be something to opt in, leaving the current model in place. If you have feedback on the
TermCap work, please add to the discussion in Issue 14.
One other pre-requisite for these changes is Issue 3. In a regular console, text followed by a backlash and a space and more text or quoting a string treats that sequence of characters as a single argument. Josh.Readline does not do this, causing some problems with completing and executing arguments with spaces in them and that will be even more of a problem once we support piping, so that needs to be fixed first.