TypeScript vscode.WorkspaceConfiguration类代码示例

 // 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;
 }

    /*-------------------------------------------------------------------------
     * 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);
    }

	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);
		}
	}

export function getConfigNoDefault(config: WorkspaceConfiguration, key: string): any {
    let x = config.inspect(key);
    var value = x.workspaceFolderValue;
    if (value === undefined)
        value = x.workspaceValue;
    if (value === undefined)
        value = x.globalValue;
    return value;
}

const isWindowsCompatible = (): boolean => {
  let config: WorkspaceConfiguration = getConfig();

  if (platform() === 'win32' || config.useWineToRun === true) {
    return true;
  }

  return false;
};

    /**
     * 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 static readRevealOutputChannelOn(configuration: WorkspaceConfiguration) {
     const setting = configuration.get<string>('rust-client.revealOutputChannelOn', 'never');
     return fromStringToRevealOutputChannelOn(setting);
 }

  return new Promise((resolve, reject) => {
    let pathToMakensis: string = getConfig().pathToMakensis;

    if (typeof pathToMakensis !== 'undefined' && pathToMakensis !== null) {
      console.log('Using makensis path found in user settings: ' + pathToMakensis);
      return resolve(pathToMakensis);
    }

    let which = spawn(this.which(), ['makensis']);

    which.stdout.on('data', (data) => {
      console.log('Using makensis path detected on file system: ' + data);
      return resolve(data);
    });

    which.on('close', (code) => {
      if (code !== 0) {
        return reject(code);
      }
    });
  });

	get runPubGetOnPubspecChangesIsConfiguredExplicitly() {
		const runPubGet = this.config.inspect("runPubGetOnPubspecChanges");
		// Return whether any of them are explicitly set, in which case we'll then read normally from the settings.
		return runPubGet && (runPubGet.globalValue !== undefined || runPubGet.workspaceValue !== undefined || runPubGet.workspaceFolderValue !== undefined);
	}