Implement normal command

src/cmd_line/commands/normal.ts

@@ -0,0 +1,40 @@
+import { Parser, all, seq, whitespace } from 'parsimmon';
+import { VimState } from '../../state/vimState';
+import { ExCommand } from '../../vimscript/exCommand';
+import { LineRange } from '../../vimscript/lineRange';
+
+export class NormalCommand extends ExCommand {
+  public static readonly argParser: Parser<NormalCommand> = seq(whitespace, all).map(
+    ([_, keystroke]) => new NormalCommand(keystroke),
+  );
+
+  private readonly keystroke: string;
+  constructor(argument: string) {
+    super();
+    this.keystroke = argument;
+  }
+
+  override async execute(vimState: VimState): Promise<void> {
+    const keystroke = this.keystroke;
+    const lineNumber = vimState.cursorStopPosition.line;
+    vimState.recordedState.transformer.addTransformation({
+      type: 'executeNormal',
+      keystroke,
+      startLineNumber: lineNumber,
+      endLineNumber: lineNumber,
+      withRange: false,
+    });
+  }
+
+  override async executeWithRange(vimState: VimState, lineRange: LineRange): Promise<void> {
+    const keystroke = this.keystroke;
+    const { start, end } = lineRange.resolve(vimState);
+    vimState.recordedState.transformer.addTransformation({
+      type: 'executeNormal',
+      keystroke,
+      startLineNumber: start,
+      endLineNumber: end,
+      withRange: true,
+    });
+  }
+}

src/mode/modeHandler.ts

@@ -773,7 +773,8 @@ export class ModeHandler implements vscode.Disposable, IModeHandler {
         this.vimState.currentMode === Mode.Normal &&
         prevMode !== Mode.SearchInProgressMode &&
         prevMode !== Mode.EasyMotionInputMode &&
-        prevMode !== Mode.EasyMotionMode
+        prevMode !== Mode.EasyMotionMode &&
+        !(prevMode === Mode.CommandlineInProgress && this.vimState.isExecutingNormalCommand)
       ) {
         ranRepeatableAction = true;
       }
@@ -884,6 +885,7 @@ export class ModeHandler implements vscode.Disposable, IModeHandler {
     if (
       ranRepeatableAction &&
       !this.vimState.isReplayingMacro &&
+      !this.vimState.isExecutingNormalCommand &&
       !this.remapState.isCurrentlyPerformingRemapping
     ) {
       this.vimState.historyTracker.finishCurrentStep();

src/state/vimState.ts

@@ -1,22 +1,22 @@
 import * as vscode from 'vscode';
 
+import { SUPPORT_IME_SWITCHER, SUPPORT_NVIM } from 'platform/constants';
+import { Position } from 'vscode';
 import { IMovement } from '../actions/baseMotion';
-import { configuration } from '../configuration/configuration';
 import { IEasyMotion } from '../actions/plugins/easymotion/types';
-import { HistoryTracker } from './../history/historyTracker';
-import { Logger } from '../util/logger';
-import { Mode } from '../mode/mode';
-import { Cursor } from '../common/motion/cursor';
-import { RecordedState } from './recordedState';
-import { RegisterMode } from './../register/register';
-import { ReplaceState } from './../state/replaceState';
 import { SurroundState } from '../actions/plugins/surround';
-import { SUPPORT_NVIM, SUPPORT_IME_SWITCHER } from 'platform/constants';
-import { Position } from 'vscode';
 import { ExCommandLine, SearchCommandLine } from '../cmd_line/commandLine';
+import { Cursor } from '../common/motion/cursor';
+import { configuration } from '../configuration/configuration';
+import { Mode } from '../mode/mode';
 import { ModeData } from '../mode/modeData';
+import { Logger } from '../util/logger';
 import { SearchDirection } from '../vimscript/pattern';
+import { HistoryTracker } from './../history/historyTracker';
+import { RegisterMode } from './../register/register';
+import { ReplaceState } from './../state/replaceState';
 import { globalState } from './globalState';
+import { RecordedState } from './recordedState';
 
 interface IInputMethodSwitcher {
   switchInputMethod(prevMode: Mode, newMode: Mode): Promise<void>;
@@ -104,6 +104,7 @@ export class VimState implements vscode.Disposable {
 
   public isRunningDotCommand = false;
   public isReplayingMacro: boolean = false;
+  public isExecutingNormalCommand: boolean = false;
 
   /**
    * The last visual selection before running the dot command

src/transformations/execute.ts

@@ -1,4 +1,5 @@
 import * as vscode from 'vscode';
+import { TextLine } from 'vscode';
 import { ExCommandLine } from '../cmd_line/commandLine';
 import { Cursor } from '../common/motion/cursor';
 import { PositionDiff } from '../common/motion/position';
@@ -10,7 +11,10 @@ import { RecordedState } from '../state/recordedState';
 import { VimState } from '../state/vimState';
 import { TextEditor } from '../textEditor';
 import { Logger } from '../util/logger';
-import { keystrokesExpressionParser } from '../vimscript/expression';
+import {
+  keystrokesExpressionForMacroParser,
+  keystrokesExpressionParser,
+} from '../vimscript/expression';
 import {
   InsertTextVSCodeTransformation,
   TextTransformations,
@@ -159,7 +163,7 @@ export async function executeTransformations(
           return;
         } else if (typeof recordedMacro === 'string') {
           // A string was set to the register. We need to execute the characters as if they were typed (in normal mode).
-          const keystrokes = keystrokesExpressionParser.parse(recordedMacro);
+          const keystrokes = keystrokesExpressionForMacroParser.parse(recordedMacro);
           if (!keystrokes.status) {
             throw new Error(`Failed to execute macro: ${recordedMacro}`);
           }
@@ -232,6 +236,47 @@ export async function executeTransformations(
         vimState.editor.selection = new vscode.Selection(newPos, newPos);
         break;
 
+      case 'executeNormal':
+        const keystroke = keystrokesExpressionParser.parse(transformation.keystroke);
+        const startLineNumber = transformation.startLineNumber;
+        const endLineNumber = transformation.endLineNumber;
+        const withRange = transformation.withRange;
+        if (!keystroke.status) {
+          throw new Error(`Failed to execute normal command: ${transformation.keystroke}`);
+        }
+
+        const resultLines: TextLine[] = [];
+        if (withRange) {
+          for (let i = startLineNumber; i <= endLineNumber; i++) {
+            resultLines.push(vimState.document.lineAt(i));
+          }
+        } else {
+          const selectionList = vimState.editor.selections;
+          for (const selection of selectionList) {
+            const { start, end } = selection;
+
+            for (let i = start.line; i <= end.line; i++) {
+              resultLines.push(vimState.document.lineAt(i));
+            }
+          }
+        }
+
+        vimState.isExecutingNormalCommand = true;
+        vimState.recordedState = new RecordedState();
+        await vimState.setCurrentMode(Mode.Normal);
+        for (const line of resultLines) {
+          if (withRange) {
+            vimState.cursorStopPosition = vimState.cursorStartPosition =
+              TextEditor.getFirstNonWhitespaceCharOnLine(vimState.document, line.lineNumber);
+          }
+          await modeHandler.handleMultipleKeyEvents(keystroke.value);
+          if (vimState.currentMode === Mode.Insert) {
+            await modeHandler.handleMultipleKeyEvents(['<Esc>']);
+          }
+        }
+        vimState.isExecutingNormalCommand = false;
+        break;
+
       case 'vscodeCommand':
         // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         await vscode.commands.executeCommand(transformation.command, ...transformation.args);

src/transformations/transformations.ts

@@ -185,6 +185,14 @@ export interface ContentChangeTransformation {
   diff: PositionDiff;
 }
 
+export interface ExecuteNormalTransformation {
+  type: 'executeNormal';
+  keystroke: string;
+  startLineNumber: number;
+  endLineNumber: number;
+  withRange: boolean;
+}
+
 export type Transformation =
   | InsertTextTransformation
   | InsertTextVSCodeTransformation
@@ -194,6 +202,7 @@ export type Transformation =
   | Dot
   | Macro
   | ContentChangeTransformation
+  | ExecuteNormalTransformation
   | VSCodeCommandTransformation;
 
 /**

src/vimscript/exCommandParser.ts

@@ -18,6 +18,7 @@ import { CenterCommand, LeftCommand, RightCommand } from '../cmd_line/commands/l
 import { DeleteMarksCommand, MarksCommand } from '../cmd_line/commands/marks';
 import { MoveCommand } from '../cmd_line/commands/move';
 import { NohlCommand } from '../cmd_line/commands/nohl';
+import { NormalCommand } from '../cmd_line/commands/normal';
 import { OnlyCommand } from '../cmd_line/commands/only';
 import { PrintCommand } from '../cmd_line/commands/print';
 import { PutExCommand } from '../cmd_line/commands/put';
@@ -371,7 +372,7 @@ export const builtinExCommands: ReadonlyArray<[[string, string], ArgParser | und
   [['noh', 'lsearch'], succeed(new NohlCommand())],
   [['norea', 'bbrev'], undefined],
   [['noreme', 'nu'], undefined],
-  [['norm', 'al'], undefined],
+  [['norm', 'al'], NormalCommand.argParser],
   [['nos', 'wapfile'], undefined],
   [['nu', 'mber'], PrintCommand.argParser({ printNumbers: true, printText: true })],
   [['nun', 'map'], undefined],

src/vimscript/expression.ts

@@ -22,6 +22,12 @@ const escapedParser = string('\\')
   });
 
 export const keystrokesExpressionParser: Parser<string[]> = alt(
+  escapedParser,
+  specialCharacterParser,
+  any,
+).many();
+
+export const keystrokesExpressionForMacroParser: Parser<string[]> = alt(
   escapedParser,
   specialCharacterParser,
   noneOf('"'),

test/normalCommand.test.ts

@@ -0,0 +1,74 @@
+import { newTest } from './testSimplifier';
+import { cleanUpWorkspace, setupWorkspace } from './testUtils';
+
+suite('Execute normal command', () => {
+  setup(async () => {
+    await setupWorkspace();
+  });
+
+  teardown(cleanUpWorkspace);
+
+  newTest({
+    title: 'One liner',
+    start: ['foo =| bar = 1'],
+    keysPressed: ':normal f=i!=\n',
+    end: ['foo = bar !|== 1'],
+  });
+
+  newTest({
+    title: 'One liner with selection',
+    start: ['foo =| bar = 1'],
+    keysPressed: 'V:normal f=i!=\n',
+    end: ['foo !|== bar = 1'],
+  });
+
+  newTest({
+    title: 'Multiple liner with selection',
+    start: ['foo =| bar = 1', 'foo = bar = 2'],
+    keysPressed: 'Vj:normal f=i!=\n',
+    end: ['foo !== bar = 1', 'foo !|== bar = 2'],
+  });
+
+  newTest({
+    title: 'Multiple liner with line range',
+    start: ['foo =| bar = 1', 'foo = bar = 2', 'foo = bar = 3'],
+    keysPressed: ':2,3normal f=i!=\n',
+    end: ['foo = bar = 1', 'foo !== bar = 2', 'foo !|== bar = 3'],
+  });
+
+  newTest({
+    title: 'One liner with dot',
+    start: ['foo =| bar = 1', 'foo = bar = 2'],
+    keysPressed: 'f=i!=<Esc>j^f=:normal .\n',
+    end: ['foo = bar !== 1', 'foo !|== bar = 2'],
+  });
+
+  // TODO: remove comment out after fixing dot command bug
+  // newTest({
+  //   title: 'One liner with multiple dot',
+  //   start: ['foo =| bar = 1', 'foo = bar = 2'],
+  //   keysPressed: 'f=i!=<Esc>j^f=:normal 2.\n',
+  //   end: ['foo = bar !== 1', 'foo !=!|== bar = 2'],
+  // });
+
+  newTest({
+    title: 'One liner with macro',
+    start: ['|1. one, 2. two, 3. three, 4. four'],
+    keysPressed: 'qaf.r)q:normal @a\n',
+    end: ['1) one, 2|) two, 3. three, 4. four'],
+  });
+
+  newTest({
+    title: 'One liner with multiple macro',
+    start: ['|1. one, 2. two, 3. three, 4. four'],
+    keysPressed: 'qaf.r)q:normal 3@a\n',
+    end: ['1) one, 2) two, 3) three, 4|) four'],
+  });
+
+  newTest({
+    title: 'Multiple liner with multiple macro',
+    start: ['|0. zero', '1. one, 2. two, 3. three, 4. four', '5. five, 6. six, 7. seven, 8. eight'],
+    keysPressed: 'qaf.r)qjVj:normal 4@a\n',
+    end: ['0) zero', '1) one, 2) two, 3) three, 4) four', '5) five, 6) six, 7) seven, 8|) eight'],
+  });
+});