TypeScript WorkspaceEdit.insert方法代码示例

		saveText: async (text: string) => {
			const filename = await utils.createFile('', getFixturePath([
				rule,
				value,
				'test'
			]));
			const doc = await workspace.openTextDocument(filename);
			await window.showTextDocument(doc);
			const edit = new WorkspaceEdit();
			edit.insert(doc.uri, new Position(0, 0), text);
			assert.strictEqual(
				await workspace.applyEdit(edit),
				true,
				'applies edit'
			);
			return await new Promise(resolve => {
				let saveCount = 0;
				workspace.onDidSaveTextDocument(savedDoc => {
					if (++saveCount === (options.saves || 1)) {
						resolve(savedDoc.getText());
					}
				});
				doc.save();
			});
		}

	// Applies Edits to given WorkspaceEdit
	applyUsingWorkspaceEdit(workspaceEdit: WorkspaceEdit, fileUri: Uri): void {
		switch (this.action) {
			case EditTypes.EDIT_INSERT:
				workspaceEdit.insert(fileUri, this.start, this.text);
				break;

			case EditTypes.EDIT_DELETE:
				workspaceEdit.delete(fileUri, new Range(this.start, this.end));
				break;

			case EditTypes.EDIT_REPLACE:
				workspaceEdit.replace(fileUri, new Range(this.start, this.end), this.text);
				break;
		}
	}

			return new Promise<string>(async resolve => {
				const doc = await createDoc(options.contents);
				workspace.onDidChangeTextDocument(doc.save);
				workspace.onDidSaveTextDocument(savedDoc => {
					assert.strictEqual(savedDoc.isDirty, false, 'dirty saved doc');
					resolve(savedDoc.getText());
				});
				const edit = new WorkspaceEdit();
				edit.insert(doc.uri, new Position(0, 0), text);
				assert.strictEqual(
					await workspace.applyEdit(edit),
					true,
					'editor fails to apply edit'
				);
			});

		saveText: async (text: string) => {
			const doc = await createDoc();
			const edit = new WorkspaceEdit();
			edit.insert(doc.uri, new Position(0, 0), text);
			assert.strictEqual(
				await workspace.applyEdit(edit),
				true,
				'applies edit'
			);
			return await new Promise(resolve => {
				workspace.onDidSaveTextDocument(savedDoc => {
					resolve(savedDoc.getText());
				});
				doc.save();
			});
		}

function onDocumentOpen(td: TextDocument) {
	let extension = extname(td.fileName);
	if (extension != ".wurst" && extension != ".jurst") {
		return;
	}
	if (td.lineCount > 1 || td.getText().length > 0) {
		return;
	}

	let packageName = basename(td.fileName, extension);
	let newText = `package ${packageName}\n\n`;

	let edit = new WorkspaceEdit()
	edit.insert(td.uri, new Position(1,1), newText)
	workspace.applyEdit(edit);


}

  public addNewLine(document: TextDocument) {
    // get the line count
    let lineCount = document.lineCount;
    console.log('lineCount: ' + lineCount);

    let allText = document.getText();
    let matches = allText.match(/\r?\n$/);
    if (matches) {
      return;
    }

    let workspaceConfiguration = workspace.getConfiguration('editor');
    let lineEnding: string = workspaceConfiguration.get<string>('lineEnding');

    let uri = document.uri;

    let workspaceEdit = new WorkspaceEdit();
    let position = new Position(lineCount, 0);
    workspaceEdit.insert(uri, position, lineEnding);
    workspace.applyEdit(workspaceEdit).then(function() {
      document.save();
    });
  }

  test('jj -> <Esc> through modehandler', async () => {
    const expectedDocumentContent = 'lorem ipsum';

    // setup
    await setupWithBindings({
      insertModeKeyBindings: defaultInsertModeKeyBindings,
      normalModeKeyBindings: defaultNormalModeKeyBindings,
      visualModeKeyBindings: defaultVisualModeKeyBindings,
    });

    let remapper = new Remappers();

    const edit = new vscode.WorkspaceEdit();
    edit.insert(
      vscode.window.activeTextEditor!.document.uri,
      new vscode.Position(0, 0),
      expectedDocumentContent
    );
    vscode.workspace.applyEdit(edit);

    await modeHandler.handleKeyEvent('i');
    assertEqual(modeHandler.currentMode.name, ModeName.Insert);

    // act
    let actual = false;
    try {
      actual = await remapper.sendKey(['j', 'j'], modeHandler, modeHandler.vimState);
    } catch (e) {
      assert.fail(e);
    }

    // assert
    assert.equal(actual, true);
    assertEqual(modeHandler.currentMode.name, ModeName.Normal);
    assert.equal(vscode.window.activeTextEditor!.document.getText(), expectedDocumentContent);
  });