TypeScript Files.uriToFilePath方法代码示例

		return new Promise<Diagnostic[]>((resolve, reject) => {

			let filename = Files.uriToFilePath(document.uri)
			let args = [ '--report=json', filename ];
			if (settings.standard ) {
				args.push( `--standard=${settings.standard}`)
			}
			args.push( filename );

			let options = {
				cwd: rootPath ? rootPath: path.dirname(filename),
				env: process.env
			};

			let result = "";
			let phpcs = cp.spawn( this.phpcsPath, args, options );

			phpcs.stderr.on("data", (buffer: Buffer) => {
				result += buffer.toString();
			});

			phpcs.stdout.on("data", (buffer: Buffer) => {
				result += buffer.toString();
			});

			phpcs.on("close", (code: string) => {
				try {
					result = result.trim();
					let match = null;

					// Determine whether we have an error and report it otherwise send back the diagnostics.
					if (match = result.match(/^ERROR:\s?(.*)/i)) {
						let error = match[1].trim();
						if (match = error.match(/^the \"(.*)\" coding standard is not installed\./)) {
							throw { message: `The "${match[1]}" coding standard set in your configuration is not installed. Please review your configuration an try again.` };
						}
						throw { message: error };
					} else if ( match = result.match(/^FATAL\s?ERROR:\s?(.*)/i)) {
						let error = match[1].trim();
						if (match = error.match(/^Uncaught exception '.*' with message '(.*)'/)) {
							throw { message: match[1] };
						}
						throw { message: error };
					}

					let diagnostics: Diagnostic[] = [];
					let report = JSON.parse(result);
					for (var filename in report.files) {
						let file: PhpcsReportFile = report.files[filename];
						file.messages.forEach(message => {
							diagnostics.push(makeDiagnostic(document, message));
						});
					}
					resolve(diagnostics);
				}
				catch (e) {
					reject(e);
				}
			});
		});

Client.connection.onFoldingRanges((params: lsp.FoldingRangeRequestParam): lsp.FoldingRange[] =>
    {
        Client.log('Client.connection.onFoldingRanges');

        let filePath = lsp.Files.uriToFilePath(params.textDocument.uri);
        Client.log('   path: ' + filePath);

        return undefined;
    });

function getMessage(err, document) {
	let result = null;
	if (typeof err.message === 'string') {
		result = err.message.replace(/\r?\n/g, ' ');
	} else {
		result = `An unknown error occured while validating file: ${Files.uriToFilePath(document.uri)}`;
	}

	return result;
}

function validate(document) {
	const content = document.getText();
	const uri = document.uri;
	const url = Files.uriToFilePath(uri);

	if (Object.keys(editorSettings.config).length === 0) {
		// Update settings from a configuration file only if their updates
		if (configWatcherStatus) {
			linterSettings = configResolver.load(null, path.dirname(url));
			configWatcherStatus = false;
		}
	} else {
		linterSettings = editorSettings.config;
	}

	if (!linterSettings) {
		linterSettings = {};
	}

	// ---> Maybe there's another way?
	const extendPath = linterSettings.extends;
	if (extendPath && path.basename(extendPath) === extendPath) {
		linterSettings.extends = `./node_modules/pug-lint-config-${linterSettings.extends}/index.js`;
	}
	// <---

	linter.configure(linterSettings);

	const diagnostics = [];
	const report = linter.checkString(content, url);
	if (report.length > 0) {
		report.forEach((problem) => {
			diagnostics.push(makeDiagnostic(problem));
		});
	}

	connection.sendDiagnostics({ uri, diagnostics });
}

 (rootFolder: lsp.WorkspaceFolder): string =>
 {
     return lsp.Files.uriToFilePath(rootFolder.uri);
 }),