WriteQuit

src/cmd_line/commands/writequit.ts

@@ -0,0 +1,54 @@
+"use strict";
+
+import * as vscode from "vscode";
+import * as node from "../node";
+import * as error from "../../error";
+import {ModeHandler} from "../../mode/modeHandler";
+
+//
+// Implements :writequit
+// http://vimdoc.sourceforge.net/htmldoc/editing.html#write-quit
+//
+export interface IWriteQuitCommandArguments extends node.ICommandArgs {
+    // arguments
+    // [++opt]
+    opt? : string;
+    optValue? : string;
+    // wq! [++opt]
+    bang? : boolean;
+    // wq [++opt] {file}
+    file? : string;
+    // wq! [++opt] {file}
+    // [range]wq[!] [++opt] [file]
+    range?: node.LineRange;
+}
+
+export class WriteQuitCommand extends node.CommandBase {
+    protected _arguments : IWriteQuitCommandArguments;
+
+    constructor(args : IWriteQuitCommandArguments) {
+        super();
+        this._name = "writequit";
+        this._shortName = "wq";
+        this._arguments = args;
+    }
+
+    get arguments() : IWriteQuitCommandArguments {
+        return this._arguments;
+    }
+
+    // Writing command. Taken as a basis from the "write.ts" file.
+    execute(modeHandler : ModeHandler) : void {
+        var filename : RegExp = new RegExp("Untitled-[0-9]*");
+        if (!this.activeTextEditor.document.isDirty) {
+            if (filename.test(this.activeTextEditor.document.fileName)) {
+                vscode.commands.executeCommand("workbench.action.files.saveAs");
+            } else {
+                vscode.commands.executeCommand("workbench.action.files.save");
+            }
+            vscode.commands.executeCommand('workbench.action.closeActiveEditor');
+        } else {
+            throw error.VimError.fromCode(error.ErrorCode.E208);
+        }
+    }
+}

src/cmd_line/parser.ts

@@ -51,7 +51,7 @@ function parseCommand(state : ParserState, commandLine : node.CommandLine) : IPa
             case token.TokenType.CommandName:
                 var commandParser = (commandParsers as any)[tok.content];
                 if (!commandParser) {
-                    throw new Error("not implemented or not a valid command");
+                    throw new Error("Not implemented or not a valid command");
                 }
                 // TODO: Pass the args, but keep in mind there could be multiple
                 // commands, not just one.
@@ -60,7 +60,7 @@ function parseCommand(state : ParserState, commandLine : node.CommandLine) : IPa
                 commandLine.command = commandParser(args);
                 return null;
             default:
-                throw new Error("not implemented");
+                throw new Error("Not implemented");
         }
     }
     if (!state.isAtEof) {

src/cmd_line/subparser.ts

@@ -2,6 +2,7 @@
 
 import {parseQuitCommandArgs} from './subparsers/quit';
 import {parseWriteCommandArgs} from './subparsers/write';
+import {parseWriteQuitCommandArgs} from './subparsers/writequit';
 import * as tabCmd from './subparsers/tab';
 import * as fileCmd from './subparsers/file';
 
@@ -13,6 +14,9 @@ export const commandParsers = {
     quit: parseQuitCommandArgs,
     q: parseQuitCommandArgs,
 
+    wq: parseWriteQuitCommandArgs,
+    writequit: parseWriteQuitCommandArgs,
+
     tabn: tabCmd.parseTabNCommandArgs,
     tabnext: tabCmd.parseTabNCommandArgs,
 

src/cmd_line/subparsers/writequit.ts

@@ -0,0 +1,53 @@
+"use strict";
+
+import {WriteQuitCommand, IWriteQuitCommandArguments} from '../commands/writequit';
+import {Scanner} from '../scanner';
+
+export function parseWriteQuitCommandArgs(args : string) : WriteQuitCommand {
+    if (!args) {
+        return new WriteQuitCommand({});
+    }
+    var scannedArgs : IWriteQuitCommandArguments = {};
+    var scanner = new Scanner(args);
+    while (true) {
+        scanner.skipWhiteSpace();
+        if (scanner.isAtEof) {
+            break;
+        }
+        let c = scanner.next();
+        switch (c) {
+            case '!':
+                // :writequit!
+                scannedArgs.bang = true;
+                scanner.ignore();
+                continue;
+            case '+':
+                // :writequit ++opt=value
+                scanner.expect('+');
+                scanner.ignore();
+                scanner.expectOneOf(['bin', 'nobin', 'ff', 'enc']);
+                scannedArgs.opt = scanner.emit();
+                scanner.expect('=');
+                scanner.ignore();
+                while (!scanner.isAtEof) {
+                    let c = scanner.next();
+                    if (c !== ' ' || c !== '\t') {
+                        continue;
+                    }
+                    scanner.backup();
+                    continue;
+                }
+                let value = scanner.emit();
+                if (!value) {
+                    throw new Error("Expected value for option.");
+                }
+                scannedArgs.optValue = value;
+                continue;
+            default:
+                throw new Error("Not implemented");
+        }
+    }
+    // TODO: parse the stuff (it's really not).
+    // ++bin ++nobin ++ff ++enc =VALUE
+    return new WriteQuitCommand(scannedArgs);
+}

src/error.ts

@@ -9,12 +9,14 @@ interface IVimErrors {
 export enum ErrorCode {
     E37 = 37,
     E32 = 32,
+    E208 = 208,
     E488 = 488
 }
 
 const errors : IVimErrors = {
     32: "No file name",
     37: "No write since last change (add ! to override)",
+    208: "Error writing to file",
     488: "Trailing characters"
 };