TypeScript WorkspaceConfiguration.get方法代码示例

    /*-------------------------------------------------------------------------
     * Private Method
     *-----------------------------------------------------------------------*/
    private loadConfig() {
        const confDocomment: WorkspaceConfiguration = workspace.getConfiguration(Configuration.KEY_DOCOMMENT);
        const confEditor: WorkspaceConfiguration = workspace.getConfiguration(Configuration.KEY_EDITOR);

        this._config = new Configuration();
        this._config.activateOnEnter = confDocomment.get<boolean>(Configuration.ACTIVATE_ON_ENTER, false);
        this._config.insertSpaces = confEditor.get<boolean>(Configuration.INSERT_SPACES, false);
        this._config.tabSize = confEditor.get<number>(Configuration.TAB_SIZE, 4);
    }

 // Convert VS Code specific settings to a format acceptable by the server. Since
 // both client and server do use JSON the conversion is trivial.
 computeConfiguration(params: ConfigurationParams, _token: CancellationToken, _next: Function): any[] {
   if (!params.items) {
     return [];
   }
   let result: (IArgdownSettings | null)[] = [];
   for (let item of params.items) {
     // The server asks the client for configuration settings without a section
     // If a section is present we return null to indicate that the configuration
     // is not supported.
     if (item.section) {
       result.push(null);
       continue;
     }
     let config: WorkspaceConfiguration;
     if (item.scopeUri && this.client) {
       config = workspace.getConfiguration("argdown", this.client.protocol2CodeConverter.asUri(item.scopeUri));
     } else {
       config = workspace.getConfiguration("argdown");
     }
     result.push({
       configFile: config.get("configFile")
     });
   }
   return result;
 }

	public updateConfiguration(config: WorkspaceConfiguration): void {
		let newConfig = config.get('format', Configuration.def());

		if (!Configuration.equals(this.config, newConfig)) {
			this.config = newConfig;
			this.formatOptions = Object.create(null);
		}
	}

    /**
     * Tries to fetch the `rust-client.channel` configuration value. If missing,
     * falls back on active toolchain specified by rustup (at `rustupPath`),
     * finally defaulting to `nightly` if all fails.
     */
    private static readChannel(rustupPath: string, configuration: WorkspaceConfiguration, wsPath: string): string {
        const channel = configuration.get<string | null>('rust-client.channel', null);
        if (channel !== null) {
            return channel;
        } else {
            try {
                return getActiveChannel(rustupPath, wsPath);
            }
            // rustup might not be installed at the time the configuration is
            // initially loaded, so silently ignore the error and return a default value
            catch (e) {
                return 'nightly';
            }

        }
    }

	private getConfig<T>(key: string, defaultValue: T): NullAsUndefined<T> {
		return nullToUndefined(this.config.get<T>(key, defaultValue));
	}

 private static readRevealOutputChannelOn(configuration: WorkspaceConfiguration) {
     const setting = configuration.get<string>('rust-client.revealOutputChannelOn', 'never');
     return fromStringToRevealOutputChannelOn(setting);
 }

	private getConfig<T>(key: string): T {
		return this.config.get<T>(key);
	}

 /**
  * Returns the templates directory location.
  * If no user configuration is found, the extension will look for
  * templates in USER_DATA_DIR/Code/FileTemplates.
  * Otherwise it will look for the path defined in the extension configuration.
  * @return {string}
  */
 public getTemplatesDir(): string {
     return this.config.get('templates_dir', this.getDefaultTemplatesDir());
 }

workspace.onDidChangeConfiguration(e => {
	config = workspace.getConfiguration('format');
	onType = config.get<boolean>('onType', true);
	disabled = config.get<Array<string>>('disabled');
	workspaceDisabled = config.get<boolean>('workspaceDisabled', false);
});

import {
	workspace, DocumentFormattingEditProvider, Selection,
	OnTypeFormattingEditProvider, WorkspaceConfiguration,
	languages, ExtensionContext, TextEdit, Position, DocumentFilter,
	TextDocument, FormattingOptions, CancellationToken, Range,
	TextEditor, commands
} from 'vscode';

import { Format } from './format';

// Get global configuration settings
var config: WorkspaceConfiguration = workspace.getConfiguration('format');
var onType: boolean = config.get<boolean>('onType', true);
var disabled: Array<string> = config.get<Array<string>>('disabled');
var workspaceDisabled: boolean = config.get<boolean>('workspaceDisabled', false);

// Update the configuration settings if the configuration changes
workspace.onDidChangeConfiguration(e => {
	config = workspace.getConfiguration('format');
	onType = config.get<boolean>('onType', true);
	disabled = config.get<Array<string>>('disabled');
	workspaceDisabled = config.get<boolean>('workspaceDisabled', false);
});

workspace.onDidOpenTextDocument(document => {
	console.log(`Document Id: ${document.languageId}`);
})

// Format the code on type
class DocumentTypeFormat implements OnTypeFormattingEditProvider {
	public provideOnTypeFormattingEdits(document: TextDocument, position: Position, ch: string, options: FormattingOptions, token: CancellationToken): Thenable<TextEdit[]> {