TypeScript languages.registerCodeLensProvider方法代码示例

 disposables.add(server.onServerStart(() => {
     // register language feature provider on start
     localDisposables = new CompositeDisposable();
     const definitionMetadataDocumentProvider = new DefinitionMetadataDocumentProvider();
     definitionMetadataDocumentProvider.register();
     localDisposables.add(definitionMetadataDocumentProvider);
     const definitionProvider = new DefinitionProvider(server, definitionMetadataDocumentProvider);
     localDisposables.add(vscode.languages.registerDefinitionProvider(documentSelector, definitionProvider));
     localDisposables.add(vscode.languages.registerDefinitionProvider({ scheme: definitionMetadataDocumentProvider.scheme }, definitionProvider));
     localDisposables.add(vscode.languages.registerImplementationProvider(documentSelector, new ImplementationProvider(server)));
     const testManager = new TestManager(server, eventStream);
     localDisposables.add(testManager);
     localDisposables.add(vscode.languages.registerCodeLensProvider(documentSelector, new CodeLensProvider(server, testManager, optionProvider)));
     localDisposables.add(vscode.languages.registerDocumentHighlightProvider(documentSelector, new DocumentHighlightProvider(server)));
     localDisposables.add(vscode.languages.registerDocumentSymbolProvider(documentSelector, new DocumentSymbolProvider(server)));
     localDisposables.add(vscode.languages.registerReferenceProvider(documentSelector, new ReferenceProvider(server)));
     localDisposables.add(vscode.languages.registerHoverProvider(documentSelector, new HoverProvider(server)));
     localDisposables.add(vscode.languages.registerRenameProvider(documentSelector, new RenameProvider(server)));
     if (options.useFormatting) {
         localDisposables.add(vscode.languages.registerDocumentRangeFormattingEditProvider(documentSelector, new FormatProvider(server)));
         localDisposables.add(vscode.languages.registerOnTypeFormattingEditProvider(documentSelector, new FormatProvider(server), '}', ';'));
     }
     localDisposables.add(vscode.languages.registerCompletionItemProvider(documentSelector, new CompletionItemProvider(server), '.', ' '));
     localDisposables.add(vscode.languages.registerWorkspaceSymbolProvider(new WorkspaceSymbolProvider(server, optionProvider)));
     localDisposables.add(vscode.languages.registerSignatureHelpProvider(documentSelector, new SignatureHelpProvider(server), '(', ','));
     const codeActionProvider = new CodeActionProvider(server, optionProvider);
     localDisposables.add(codeActionProvider);
     localDisposables.add(vscode.languages.registerCodeActionsProvider(documentSelector, codeActionProvider));
     localDisposables.add(reportDiagnostics(server, advisor));
     localDisposables.add(forwardChanges(server));
     localDisposables.add(trackVirtualDocuments(server, eventStream));
     localDisposables.add(vscode.languages.registerFoldingRangeProvider(documentSelector, new StructureProvider(server)));
 }));

    disposables.push(server.onServerStart(() => {
        // register language feature provider on start
        const definitionMetadataDocumentProvider = new DefinitionMetadataDocumentProvider();
        definitionMetadataDocumentProvider.register();
        localDisposables.push(definitionMetadataDocumentProvider);

        localDisposables.push(vscode.languages.registerDefinitionProvider(documentSelector, new DefinitionProvider(server, definitionMetadataDocumentProvider)));
        localDisposables.push(vscode.languages.registerImplementationProvider(documentSelector, new ImplementationProvider(server)));
        localDisposables.push(vscode.languages.registerCodeLensProvider(documentSelector, new CodeLensProvider(server)));
        localDisposables.push(vscode.languages.registerDocumentHighlightProvider(documentSelector, new DocumentHighlightProvider(server)));
        localDisposables.push(vscode.languages.registerDocumentSymbolProvider(documentSelector, new DocumentSymbolProvider(server)));
        localDisposables.push(vscode.languages.registerReferenceProvider(documentSelector, new ReferenceProvider(server)));
        localDisposables.push(vscode.languages.registerHoverProvider(documentSelector, new HoverProvider(server)));
        localDisposables.push(vscode.languages.registerRenameProvider(documentSelector, new RenameProvider(server)));
        localDisposables.push(vscode.languages.registerDocumentRangeFormattingEditProvider(documentSelector, new FormatProvider(server)));
        localDisposables.push(vscode.languages.registerOnTypeFormattingEditProvider(documentSelector, new FormatProvider(server), '}', ';'));
        localDisposables.push(vscode.languages.registerCompletionItemProvider(documentSelector, new CompletionItemProvider(server), '.', '<'));
        localDisposables.push(vscode.languages.registerWorkspaceSymbolProvider(new WorkspaceSymbolProvider(server)));
        localDisposables.push(vscode.languages.registerSignatureHelpProvider(documentSelector, new SignatureHelpProvider(server), '(', ','));
        const codeActionProvider = new CodeActionProvider(server);
        localDisposables.push(codeActionProvider);
        localDisposables.push(vscode.languages.registerCodeActionsProvider(documentSelector, codeActionProvider));
        localDisposables.push(reportDiagnostics(server, advisor));
        localDisposables.push(forwardChanges(server));
    }));

export function activate(context: vsc.ExtensionContext) {
	const logger = new Logger();
	const config = new Configuration(logger);
	const azureClient = new AzureClient(config, logger);
	const sessionStore = new SessionStore(azureClient, config, logger);

	const publishCommand = new PublishCommand(sessionStore, azureClient, logger, config);

	const alphabet = [...'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'];

	const activityDiagnostics = new ActivityDiagnostics(sessionStore);
	activityDiagnostics.register();

	context.subscriptions.push(...[
		logger,
		config,
		vsc.commands.registerCommand(Commands.publish, publishCommand.publish, publishCommand),
		vsc.languages.registerCompletionItemProvider(documentSelector, new ActivityCompletionProvider(sessionStore, logger), ...alphabet),
		vsc.languages.registerCompletionItemProvider(documentSelector, new SnippetCompletionProvider(config), ...alphabet),
		vsc.languages.registerCompletionItemProvider(documentSelector, new IterationCompletionProvider(sessionStore, logger), '#'),
		vsc.languages.registerCompletionItemProvider(documentSelector, new UserStoryCompletionProvider(sessionStore, logger), '#'),
		vsc.languages.registerCodeLensProvider(documentSelector, new PublishCodeLensProvider()),
		vsc.languages.registerCodeActionsProvider(documentSelector, new ActivityCodeActionProvider(sessionStore, logger)),
		activityDiagnostics
	]);
}

export function registerCoverageCodeLens(jestExt: JestExt) {
  return [
    vscode.languages.registerCodeLensProvider(
      { pattern: '**/*.{ts,tsx,js,jsx}' },
      new CoverageCodeLensProvider(jestExt)
    ),
  ]
}

export function activateCodeLenses(onDidChange: vscode.EventEmitter<void>, symboldProvider: PythonSymbolProvider): vscode.Disposable {
    const disposables: vscode.Disposable[] = [];
    disposables.push(vscode.languages.registerCodeLensProvider(constants.PythonLanguage, new TestFileCodeLensProvider(onDidChange, symboldProvider)));

    return {
        dispose: function () {
            disposables.forEach(d => d.dispose());
        }
    };
}

export function activateCodeLenses(): vscode.Disposable {
    const disposables: vscode.Disposable[] = [];
    disposables.push(vscode.languages.registerCodeLensProvider(constants.PythonLanguage, new TestFileCodeLensProvider()));

    return {
        dispose: function () {
            disposables.forEach(d => d.dispose());
        }
    }
}

export function registerSnapshotCodeLens(enableSnapshotPreviews: boolean) {
  if (!enableSnapshotPreviews) {
    return []
  }
  return [
    vscode.languages.registerCodeLensProvider({ pattern: '**/*.{ts,tsx,js,jsx}' }, new SnapshotCodeLensProvider()),
    vscode.commands.registerCommand(missingSnapshotCommand, () => {
      vscode.window.showInformationMessage('Run test to generate snapshot.')
    }),
  ]
}

export function activate(context: vscode.ExtensionContext) {
  // To make us VS Code agnostic outside of this file
  const pluginSettings = getExtensionSettings()
  const jestPath = pathToJest(pluginSettings)
  const configPath = pathToConfig(pluginSettings)
  const currentJestVersion = 20
  const workspace = new ProjectWorkspace(pluginSettings.rootPath, jestPath, configPath, currentJestVersion)

  // Create our own console
  const channel = vscode.window.createOutputChannel('Jest')

  // We need a singleton to represent the extension
  extensionInstance = new JestExt(workspace, channel, pluginSettings)

  const languages = [
    { language: 'javascript' },
    { language: 'javascriptreact' },
    { language: 'typescript' },
    { language: 'typescriptreact' },
  ]
  context.subscriptions.push(
    registerStatusBar(channel),
    vscode.commands.registerTextEditorCommand(`${extensionName}.start`, () => {
      vscode.window.showInformationMessage('Started Jest, press escape to hide this message.')
      extensionInstance.startProcess()
    }),
    vscode.commands.registerTextEditorCommand(`${extensionName}.stop`, () => extensionInstance.stopProcess()),
    vscode.commands.registerTextEditorCommand(`${extensionName}.show-channel`, () => {
      channel.show()
    }),
    ...registerSnapshotCodeLens(pluginSettings.enableSnapshotPreviews),
    ...registerSnapshotPreview(),
    ...registerCoverageCodeLens(extensionInstance),
    registerToggleCoverageOverlay(pluginSettings.showCoverageOnLoad),
    vscode.commands.registerCommand(`${extensionName}.run-test`, extensionInstance.runTest),
    vscode.languages.registerCodeLensProvider(languages, extensionInstance.debugCodeLensProvider),
    vscode.workspace.onDidChangeConfiguration(e => {
      if (e.affectsConfiguration('jest')) {
        const updatedSettings = getExtensionSettings()
        extensionInstance.triggerUpdateSettings(updatedSettings)
      }
    }),

    vscode.workspace.onDidCloseTextDocument(document => {
      extensionInstance.onDidCloseTextDocument(document)
    }),

    vscode.window.onDidChangeActiveTextEditor(extensionInstance.onDidChangeActiveTextEditor, extensionInstance),
    vscode.workspace.onDidChangeTextDocument(extensionInstance.onDidChangeTextDocument, extensionInstance)
  )
}

export function activate(context: vscode.ExtensionContext) {
    const config: AppConfiguration = new AppConfiguration();
    const metricsUtil: MetricsUtil = new MetricsUtil(config, context);
    const disposables = [];

    disposables.push(
        languages.registerCodeLensProvider(metricsUtil.selector, new CodeMetricsCodeLensProvider(metricsUtil))
    );
    disposables.push(new EditorDecoration(context, metricsUtil));

    const triggerCodeLensComputation = () => {
        if (!vscode.window.activeTextEditor) {
            return;
        }
        var end = vscode.window.activeTextEditor.selection.end;
        vscode.window.activeTextEditor
            .edit(editbuilder => {
                editbuilder.insert(end, " ");
            })
            .then(() => {
                commands.executeCommand("undo");
            });
    };

    disposables.push(
        commands.registerCommand("codemetrics.toggleCodeMetricsForArrowFunctions", () => {
            config.codeMetricsForArrowFunctionsToggled = !config.codeMetricsForArrowFunctionsToggled;
            config.toggleCodeMetricsForArrowFunctionsExecuted = true;
            triggerCodeLensComputation();
        })
    );

    disposables.push(
        commands.registerCommand("codemetrics.toggleCodeMetricsDisplayed", () => {
            config.codeMetricsDisplayed = !config.codeMetricsDisplayed;
            triggerCodeLensComputation();
        })
    );

    disposables.push(
        commands.registerCommand("codemetrics.showCodeMetricsCodeLensInfo", (codelens: CodeMetricsCodeLens) => {
            var items = codelens.getChildren().filter(item => item.getCollectedComplexity() > 0);
            var explanations = items
                .map(item => item.toLogString("").trim() + " - " + item.description)
                .map(item => item.replace(/[\r\n]+/g, " "));
            vscode.window.showQuickPick(explanations).then(selected => {
                if (selected) {
                    var selectedCodeLens = items[explanations.indexOf(selected)];
                    if (selectedCodeLens) {
                        var characterPosition = vscode.window.activeTextEditor.document.positionAt(
                            selectedCodeLens.start
                        );
                        vscode.window.activeTextEditor.selection = new vscode.Selection(
                            characterPosition,
                            characterPosition
                        );
                    }
                }
            });
        })
    );

    context.subscriptions.push(...disposables);
}

		new ConfigurationDependentRegistration(modeId, 'referencesCodeLens.enabled', () => {
			return vscode.languages.registerCodeLensProvider(selector,
				new TypeScriptReferencesCodeLensProvider(client, cachedResponse));
		}));