Add a bunch of commands.

src/actions/actions.ts

@@ -1,4 +1,4 @@
-import { ModeHandler, ActionState, VimState } from './../mode/modeHandler';
+import { ModeHandler, VimCommandActions, VimState } from './../mode/modeHandler';
 import { ModeName } from './../mode/mode';
 import { TextEditor } from './../textEditor';
 import { Register } from './../register/register';
@@ -229,103 +229,102 @@ export class YankOperator extends BaseOperator {
     }
 }
 
-/*
+
 @RegisterAction
-class ActionEnterCommand extends BaseAction {
+class CommandShowCommandLine extends BaseCommand {
   modes = [ModeName.Normal];
   key = ":";
 
-  public async execAction(position: Position): Promise<VimState> {
-    await showCmdLine("", modeHandler);
+  public async exec(position: Position, vimState: VimState): Promise<VimState> {
+    vimState.commandAction = VimCommandActions.ShowCommandLine;
 
-    return {};
+    return vimState;
   }
 }
 
 @RegisterAction
-class ActionFind extends BaseAction {
+class CommandFind extends BaseCommand {
   modes = [ModeName.Normal];
   key = "/";
 
-  public async execAction(position: Position): Promise<VimState> {
-    await vscode.commands.executeCommand("actions.find");
+  public async exec(position: Position, vimState: VimState): Promise<VimState> {
+    vimState.commandAction = VimCommandActions.Find;
 
-    return {};
+    return vimState;
   }
 }
 
 @RegisterAction
-class ActionFold extends BaseAction {
-  modes = [ModeName.Normal];
+class CommandFold extends BaseCommand {
+  modes = [ModeName.Visual];
   key = "zc";
 
-  public async execAction(position: Position): Promise<VimState> {
-    await vscode.commands.executeCommand("editor.fold");
+  public async exec(position: Position, vimState: VimState): Promise<VimState> {
+    vimState.commandAction = VimCommandActions.Fold;
 
-    return {};
+    return vimState;
   }
 }
 
 @RegisterAction
-class ActionUnfold extends BaseAction {
+class CommandUnfold extends BaseCommand {
   modes = [ModeName.Normal];
   key = "zo";
 
-  public async execAction(position: Position): Promise<VimState> {
-    await vscode.commands.executeCommand("editor.unfold");
+  public async exec(position: Position, vimState: VimState): Promise<VimState> {
+    vimState.commandAction = VimCommandActions.Unfold;
 
-    return {};
+    return vimState;
   }
 }
 
 @RegisterAction
-class ActionFoldAll extends BaseAction {
+class CommandFoldAll extends BaseCommand {
   modes = [ModeName.Normal];
   key = "zC";
 
-  public async execAction(position: Position): Promise<VimState> {
-    await vscode.commands.executeCommand("editor.foldAll");
+  public async exec(position: Position, vimState: VimState): Promise<VimState> {
+    vimState.commandAction = VimCommandActions.FoldAll;
 
-    return {};
+    return vimState;
   }
 }
 
 @RegisterAction
-class ActionUnfoldAll extends BaseAction {
+class CommandUnfoldAll extends BaseCommand {
   modes = [ModeName.Normal];
   key = "zO";
 
-  public async execAction(position: Position): Promise<VimState> {
-    await vscode.commands.executeCommand("editor.unfoldAll");
+  public async exec(position: Position, vimState: VimState): Promise<VimState> {
+    vimState.commandAction = VimCommandActions.UnfoldAll;
 
-    return {};
+    return vimState;
   }
 }
 
 @RegisterAction
-class ActionUndo extends BaseAction {
+class CommandUndo extends BaseCommand {
   modes = [ModeName.Normal];
   key = "u";
 
-  public async execAction(position: Position): Promise<VimState> {
-    await vscode.commands.executeCommand("undo");
+  public async exec(position: Position, vimState: VimState): Promise<VimState> {
+    vimState.commandAction = VimCommandActions.Undo;
 
-    return { undo: true };
+    return vimState;
   }
 }
 
 @RegisterAction
-class ActionRedo extends BaseAction {
+class CommandRedo extends BaseCommand {
   modes = [ModeName.Normal];
   key = "ctrl+r";
 
-  public async execAction(position: Position): Promise<VimState> {
-    await vscode.commands.executeCommand("redo");
+  public async exec(position: Position, vimState: VimState): Promise<VimState> {
+    vimState.commandAction = VimCommandActions.Redo;
 
-    return { redo: true };
+    return vimState;
   }
 }
-*/
 
 @RegisterAction
 class CommandEsc extends BaseCommand {
@@ -466,7 +465,6 @@ class CommandInsertNewLineAbove extends BaseCommand {
   key = "O";
 
   public async exec(position: Position, vimState: VimState): Promise<VimState> {
-    // TODO: This code no good.
     await vscode.commands.executeCommand("editor.action.insertLineBefore");
 
     vimState.currentMode = ModeName.Insert;
@@ -481,7 +479,6 @@ class CommandInsertNewLineBefore extends BaseCommand {
   key = "o";
 
   public async exec(position: Position, vimState: VimState): Promise<VimState> {
-    // TODO: This code no good.
     await vscode.commands.executeCommand("editor.action.insertLineAfter");
 
     vimState.currentMode = ModeName.Insert;

src/mode/modeHandler.ts

@@ -15,6 +15,7 @@ import {
 import { Configuration } from '../configuration/configuration';
 import { Position, PositionOptions } from './../motion/position';
 import { TextEditor } from '../../src/textEditor';
+import { showCmdLine } from '../../src/cmd_line/main';
 
 // TODO: This is REALLY dumb...
 // figure out some way to force include this stuff...
@@ -28,6 +29,60 @@ new YankOperator();
 // TODO - or maybe just get rid of decorators
 // they're nice but introduce a weird class of bugs ;_;
 
+export enum VimCommandActions {
+    DoNothing,
+    ShowCommandLine,
+    Find,
+    Fold,
+    Unfold,
+    FoldAll,
+    UnfoldAll,
+    Undo,
+    Redo,
+}
+
+/**
+ * The VimState class holds permanent state that carries over from action
+ * to action.
+ *
+ * Actions defined in actions.ts are only allowed to mutate a VimState in order to
+ * indicate what they want to do.
+ */
+export class VimState {
+    /**
+     * The column the cursor wants to be at, or Number.POSITIVE_INFINITY if it should always
+     * be the rightmost column.
+     *
+     * Example: If you go to the end of a 20 character column, this value
+     * will be 20, even if you press j and the next column is only 5 characters.
+     * This is because if the third column is 25 characters, the cursor will go
+     * back to the 20th column.
+     */
+    public desiredColumn = 0;
+
+    /**
+     * The position the cursor will be when this action finishes.
+     */
+    public cursorPosition = new Position(0, 0, PositionOptions.CharacterWiseInclusive);
+
+    /**
+     * The mode Vim will be in once this action finishes.
+     */
+    public currentMode = ModeName.Normal;
+
+    /**
+     * This is for oddball commands that don't manipulate text in any way.
+     */
+    public commandAction = VimCommandActions.DoNothing;
+
+    private _actionState = new ActionState(this);
+    public get actionState(): ActionState { return this._actionState; }
+    public set actionState(a: ActionState) {
+        a.vimState = this;
+        this._actionState = a;
+    }
+}
+
 /**
  * The ActionState class represents state relevant to the current
  * action that the user is doing. Example: Imagine that the user types:
@@ -123,36 +178,6 @@ export class ActionState {
     }
 }
 
-/**
- * The VimState class holds permanent state that carries over from action
- * to action.
- *
- * TODO: Perhaps this should have ActionState inside it, and be returned from all commands.
- */
-export class VimState {
-    /**
-     * The column the cursor wants to be at, or Number.POSITIVE_INFINITY if it should always
-     * be the rightmost column.
-     *
-     * Example: If you go to the end of a 20 character column, this value
-     * will be 20, even if you press j and the next column is only 5 characters.
-     * This is because if the third column is 25 characters, the cursor will go
-     * back to the 20th column.
-     */
-    public desiredColumn = 0;
-
-    public cursorPosition = new Position(0, 0, PositionOptions.CharacterWiseInclusive);
-
-    public currentMode = ModeName.Normal;
-
-    private _actionState = new ActionState(this);
-    public get actionState(): ActionState { return this._actionState; }
-    public set actionState(a: ActionState) {
-        a.vimState = this;
-        this._actionState = a;
-    }
-}
-
 export class ModeHandler implements vscode.Disposable {
     private __motion: Motion;
     private _modes: Mode[];
@@ -278,6 +303,21 @@ export class ModeHandler implements vscode.Disposable {
         if (actionState.readyToExecute) {
             this._vimState = await this.executeState();
 
+            if (this._vimState.commandAction !== VimCommandActions.DoNothing) {
+                switch (this._vimState.commandAction) {
+                    case VimCommandActions.ShowCommandLine: await showCmdLine("", this); break;
+                    case VimCommandActions.Find: await vscode.commands.executeCommand("actions.find"); break;
+                    case VimCommandActions.Fold: await vscode.commands.executeCommand("editor.fold"); break;
+                    case VimCommandActions.Unfold: await vscode.commands.executeCommand("editor.unfold"); break;
+                    case VimCommandActions.FoldAll: await vscode.commands.executeCommand("editor.foldAll"); break;
+                    case VimCommandActions.UnfoldAll: await vscode.commands.executeCommand("editor.unfoldAll"); break;
+                    case VimCommandActions.Undo: await vscode.commands.executeCommand("undo"); break;
+                    case VimCommandActions.Redo: await vscode.commands.executeCommand("redo"); break;
+                }
+
+                this._vimState.commandAction = VimCommandActions.DoNothing;
+            }
+
             // Update mode
 
             if (this._vimState.currentMode !== this.currentModeName) {