Read command

ROADMAP.md

@@ -278,8 +278,8 @@ Status | Command | Description
 
 Status | Command | Description
 ---|--------|------------------------------
-:arrow_down:| :r [file]	    | insert the contents of [file] below the cursor
-:arrow_down:| :r! {command}  | insert the standard output of {command} below the cursor
+:warning:   | :r [file]	    | insert the contents of [file] below the cursor
+:warning:   | :r! {command}  | insert the standard output of {command} below the cursor
 
 ## Deleting text
 

package.json

@@ -242,6 +242,7 @@
     "postinstall": "node ./node_modules/vscode/bin/install && gulp init"
   },
   "dependencies": {
+    "child-process": "^1.0.2",
     "copy-paste": "^1.3.0",
     "diff-match-patch": "^1.0.0",
     "lodash": "^4.12.0"

src/cmd_line/commands/read.ts

@@ -0,0 +1,81 @@
+"use strict";
+
+import * as node from "../node";
+import {readFile} from 'fs';
+import {exec} from 'child_process';
+import {TextEditor} from '../../textEditor';
+
+export interface IReadCommandArguments extends node.ICommandArgs {
+  file?: string;
+  cmd?: string;
+}
+
+//
+//  Implements :read and :read!
+//  http://vimdoc.sourceforge.net/htmldoc/insert.html#:read
+//  http://vimdoc.sourceforge.net/htmldoc/insert.html#:read!
+//
+export class ReadCommand extends node.CommandBase {
+  protected _arguments : IReadCommandArguments;
+
+  constructor(args : IReadCommandArguments) {
+    super();
+    this._name = 'read';
+    this._shortName = 'r';
+    this._arguments = args;
+  }
+
+  get arguments() : IReadCommandArguments {
+    return this._arguments;
+  }
+
+  async execute() : Promise<void> {
+    const textToInsert = await this.getTextToInsert();
+    if (textToInsert) {
+      await TextEditor.insert(textToInsert);
+    }
+  }
+
+  async getTextToInsert() : Promise<string> {
+    if (this.arguments.file && this.arguments.file.length > 0) {
+      return await this.getTextToInsertFromFile();
+    } else if (this.arguments.cmd && this.arguments.cmd.length > 0) {
+      return await this.getTextToInsertFromCmd();
+    } else {
+      throw Error('Invalid arguments');
+    }
+  }
+
+  async getTextToInsertFromFile() : Promise<string> {
+    // TODO: Read encoding from ++opt argument.
+    return new Promise<string>((resolve, reject) => {
+      try {
+        readFile(this.arguments.file as string, 'utf8', (err, data) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(data);
+          }
+        });
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+
+  async getTextToInsertFromCmd() : Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+      try {
+        exec(this.arguments.cmd as string, (err, stdout, stderr) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(stdout);
+          }
+        });
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+}

src/cmd_line/scanner.ts

@@ -69,6 +69,14 @@ export class Scanner {
     return s;
   }
 
+  // Returns the text from the current position to the end.
+  remaining() : string {
+    while (!this.isAtEof) {
+      this.next();
+    }
+    return this.emit();
+  }
+
   backup(): void {
     this.pos--;
   }

src/cmd_line/subparser.ts

@@ -8,6 +8,7 @@ import * as tabCmd from './subparsers/tab';
 import * as fileCmd from './subparsers/file';
 import {parseOptionsCommandArgs} from './subparsers/setoptions';
 import {parseSubstituteCommandArgs} from './subparsers/substitute';
+import {parseReadCommandArgs} from './subparsers/read';
 import {parseRegisterCommandArgs} from './subparsers/register';
 
 // maps command names to parsers for said commands.
@@ -61,5 +62,8 @@ export const commandParsers = {
   set: parseOptionsCommandArgs,
   se: parseOptionsCommandArgs,
 
+  read: parseReadCommandArgs,
+  r: parseReadCommandArgs,
+
   reg: parseRegisterCommandArgs
 };

src/cmd_line/subparsers/read.ts

@@ -0,0 +1,32 @@
+"use strict";
+
+import {ReadCommand, IReadCommandArguments} from '../commands/read';
+import {Scanner} from '../scanner';
+
+export function parseReadCommandArgs(args : string) : ReadCommand {
+  if (!args) {
+    throw Error('Expected arguments.');
+  }
+
+  var scannedArgs : IReadCommandArguments = {};
+  var scanner = new Scanner(args);
+
+  scanner.skipWhiteSpace();
+  let c = scanner.next();
+  // read command has 2 forms - 'read <file-path>' and 'read! <shell-command>'
+  if (c === '!') {
+    scanner.ignore();
+    scanner.skipWhiteSpace();
+    scannedArgs.cmd = scanner.remaining();
+    if (!scannedArgs.cmd || scannedArgs.cmd.length === 0) {
+      throw Error('Expected shell command.');
+    }
+  } else {
+    scannedArgs.file = scanner.remaining();
+    if (!scannedArgs.file || scannedArgs.file.length === 0) {
+      throw Error('Expected file path.');
+    }
+  }
+
+  return new ReadCommand(scannedArgs);
+}

test/cmd_line/read.test.ts

@@ -0,0 +1,25 @@
+"use strict";
+
+import { ModeHandler } from '../../src/mode/modeHandler';
+import { setupWorkspace, cleanUpWorkspace, assertEqualLines } from './../testUtils';
+import { runCmdLine } from '../../src/cmd_line/main';
+
+suite("read", () => {
+  let modeHandler: ModeHandler;
+
+  setup(async () => {
+    await setupWorkspace();
+    modeHandler = new ModeHandler();
+  });
+
+  teardown(cleanUpWorkspace);
+
+  test("Can read shell command output", async () => {
+    await runCmdLine('r! echo hey\\\\n\\\\tho', modeHandler);
+    assertEqualLines([
+      'hey',
+      '\tho',
+      ''
+    ]);
+  });
+});