SQL Operations Studio Public Preview 1 (0.23) release source code

extensions/configuration-editing/src/extension.ts

@@ -0,0 +1,183 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as vscode from 'vscode';
+import { getLocation, visit, parse } from 'jsonc-parser';
+import * as path from 'path';
+import { SettingsDocument } from './settingsDocumentHelper';
+import * as nls from 'vscode-nls';
+
+const localize = nls.loadMessageBundle();
+
+const decoration = vscode.window.createTextEditorDecorationType({
+	color: '#b1b1b1'
+});
+
+let pendingLaunchJsonDecoration: NodeJS.Timer;
+
+export function activate(context): void {
+
+	//keybindings.json command-suggestions
+	context.subscriptions.push(registerKeybindingsCompletions());
+
+	//settings.json suggestions
+	context.subscriptions.push(registerSettingsCompletions());
+
+	//extensions.json suggestions
+	context.subscriptions.push(registerExtensionsCompletions());
+
+	// launch.json decorations
+	context.subscriptions.push(vscode.window.onDidChangeActiveTextEditor(editor => updateLaunchJsonDecorations(editor), null, context.subscriptions));
+	context.subscriptions.push(vscode.workspace.onDidChangeTextDocument(event => {
+		if (vscode.window.activeTextEditor && event.document === vscode.window.activeTextEditor.document) {
+			if (pendingLaunchJsonDecoration) {
+				clearTimeout(pendingLaunchJsonDecoration);
+			}
+			pendingLaunchJsonDecoration = setTimeout(() => updateLaunchJsonDecorations(vscode.window.activeTextEditor), 1000);
+		}
+	}, null, context.subscriptions));
+	updateLaunchJsonDecorations(vscode.window.activeTextEditor);
+}
+
+function registerKeybindingsCompletions(): vscode.Disposable {
+	const commands = vscode.commands.getCommands(true);
+
+	return vscode.languages.registerCompletionItemProvider({ pattern: '**/keybindings.json' }, {
+
+		provideCompletionItems(document, position, token) {
+			const location = getLocation(document.getText(), document.offsetAt(position));
+			if (location.path[1] === 'command') {
+
+				const range = document.getWordRangeAtPosition(position) || new vscode.Range(position, position);
+				return commands.then(ids => ids.map(id => newSimpleCompletionItem(JSON.stringify(id), range)));
+			}
+		}
+	});
+}
+
+function registerSettingsCompletions(): vscode.Disposable {
+	return vscode.languages.registerCompletionItemProvider({ language: 'json', pattern: '**/settings.json' }, {
+		provideCompletionItems(document, position, token) {
+			return new SettingsDocument(document).provideCompletionItems(position, token);
+		}
+	});
+}
+
+function registerExtensionsCompletions(): vscode.Disposable {
+	return vscode.languages.registerCompletionItemProvider({ pattern: '**/extensions.json' }, {
+		provideCompletionItems(document, position, token) {
+			const location = getLocation(document.getText(), document.offsetAt(position));
+			const range = document.getWordRangeAtPosition(position) || new vscode.Range(position, position);
+			if (location.path[0] === 'recommendations') {
+				const config = parse(document.getText());
+				const alreadyEnteredExtensions = config && config.recommendations || [];
+				if (Array.isArray(alreadyEnteredExtensions)) {
+					const knownExtensionProposals = vscode.extensions.all.filter(e =>
+						!(e.id.startsWith('vscode.')
+							|| e.id === 'Microsoft.vscode-markdown'
+							|| alreadyEnteredExtensions.indexOf(e.id) > -1));
+					if (knownExtensionProposals.length) {
+						return knownExtensionProposals.map(e => {
+							const item = new vscode.CompletionItem(e.id);
+							const insertText = `"${e.id}"`;
+							item.kind = vscode.CompletionItemKind.Value;
+							item.insertText = insertText;
+							item.range = range;
+							item.filterText = insertText;
+							return item;
+						});
+					} else {
+						const example = new vscode.CompletionItem(localize('exampleExtension', "Example"));
+						example.insertText = '"vscode.csharp"';
+						example.kind = vscode.CompletionItemKind.Value;
+						example.range = range;
+						return [example];
+					}
+				}
+			}
+			return [];
+		}
+	});
+}
+
+function newSimpleCompletionItem(label: string, range: vscode.Range, description?: string, insertText?: string): vscode.CompletionItem {
+	const item = new vscode.CompletionItem(label);
+	item.kind = vscode.CompletionItemKind.Value;
+	item.detail = description;
+	item.insertText = insertText || label;
+	item.range = range;
+
+	return item;
+}
+
+function updateLaunchJsonDecorations(editor: vscode.TextEditor | undefined): void {
+	if (!editor || path.basename(editor.document.fileName) !== 'launch.json') {
+		return;
+	}
+
+	const ranges: vscode.Range[] = [];
+	let addPropertyAndValue = false;
+	let depthInArray = 0;
+	visit(editor.document.getText(), {
+		onObjectProperty: (property, offset, length) => {
+			// Decorate attributes which are unlikely to be edited by the user.
+			// Only decorate "configurations" if it is not inside an array (compounds have a configurations property which should not be decorated).
+			addPropertyAndValue = property === 'version' || property === 'type' || property === 'request' || property === 'compounds' || (property === 'configurations' && depthInArray === 0);
+			if (addPropertyAndValue) {
+				ranges.push(new vscode.Range(editor.document.positionAt(offset), editor.document.positionAt(offset + length)));
+			}
+		},
+		onLiteralValue: (value, offset, length) => {
+			if (addPropertyAndValue) {
+				ranges.push(new vscode.Range(editor.document.positionAt(offset), editor.document.positionAt(offset + length)));
+			}
+		},
+		onArrayBegin: (offset: number, length: number) => {
+			depthInArray++;
+		},
+		onArrayEnd: (offset: number, length: number) => {
+			depthInArray--;
+		}
+	});
+
+	editor.setDecorations(decoration, ranges);
+}
+
+vscode.languages.registerDocumentSymbolProvider({ pattern: '**/launch.json', language: 'json' }, {
+	provideDocumentSymbols(document: vscode.TextDocument, token: vscode.CancellationToken): vscode.ProviderResult<vscode.SymbolInformation[]> {
+		const result: vscode.SymbolInformation[] = [];
+		let name: string = '';
+		let lastProperty = '';
+		let startOffset = 0;
+		let depthInObjects = 0;
+
+		visit(document.getText(), {
+			onObjectProperty: (property, offset, length) => {
+				lastProperty = property;
+			},
+			onLiteralValue: (value: any, offset: number, length: number) => {
+				if (lastProperty === 'name') {
+					name = value;
+				}
+			},
+			onObjectBegin: (offset: number, length: number) => {
+				depthInObjects++;
+				if (depthInObjects === 2) {
+					startOffset = offset;
+				}
+			},
+			onObjectEnd: (offset: number, length: number) => {
+				if (name && depthInObjects === 2) {
+					result.push(new vscode.SymbolInformation(name, vscode.SymbolKind.Object, new vscode.Range(document.positionAt(startOffset), document.positionAt(offset))));
+				}
+				depthInObjects--;
+			},
+		});
+
+		return result;
+	}
+});

extensions/configuration-editing/src/settingsDocumentHelper.ts

@@ -0,0 +1,209 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { getLocation, Location } from 'jsonc-parser';
+import * as nls from 'vscode-nls';
+
+const localize = nls.loadMessageBundle();
+
+export class SettingsDocument {
+
+	constructor(private document: vscode.TextDocument) { }
+
+	public provideCompletionItems(position: vscode.Position, token: vscode.CancellationToken): vscode.ProviderResult<vscode.CompletionItem[]> {
+		const location = getLocation(this.document.getText(), this.document.offsetAt(position));
+		const range = this.document.getWordRangeAtPosition(position) || new vscode.Range(position, position);
+
+		// window.title
+		if (location.path[0] === 'window.title') {
+			return this.provideWindowTitleCompletionItems(location, range);
+		}
+
+		// files.association
+		if (location.path[0] === 'files.associations') {
+			return this.provideFilesAssociationsCompletionItems(location, range);
+		}
+
+		// files.exclude, search.exclude
+		if (location.path[0] === 'files.exclude' || location.path[0] === 'search.exclude') {
+			return this.provideExcludeCompletionItems(location, range);
+		}
+
+		// files.defaultLanguage
+		if (location.path[0] === 'files.defaultLanguage') {
+			return this.provideLanguageCompletionItems(location, range);
+		}
+
+		return this.provideLanguageOverridesCompletionItems(location, position);
+	}
+
+	private provideWindowTitleCompletionItems(location: Location, range: vscode.Range): vscode.ProviderResult<vscode.CompletionItem[]> {
+		const completions: vscode.CompletionItem[] = [];
+
+		completions.push(this.newSimpleCompletionItem('${activeEditorShort}', range, localize('activeEditorShort', "e.g. myFile.txt")));
+		completions.push(this.newSimpleCompletionItem('${activeEditorMedium}', range, localize('activeEditorMedium', "e.g. myFolder/myFile.txt")));
+		completions.push(this.newSimpleCompletionItem('${activeEditorLong}', range, localize('activeEditorLong', "e.g. /Users/Development/myProject/myFolder/myFile.txt")));
+		completions.push(this.newSimpleCompletionItem('${rootName}', range, localize('rootName', "e.g. myFolder1, myFolder2, myFolder3")));
+		completions.push(this.newSimpleCompletionItem('${rootPath}', range, localize('rootPath', "e.g. /Users/Development/myProject")));
+		completions.push(this.newSimpleCompletionItem('${folderName}', range, localize('folderName', "e.g. myFolder")));
+		completions.push(this.newSimpleCompletionItem('${folderPath}', range, localize('folderPath', "e.g. /Users/Development/myFolder")));
+		completions.push(this.newSimpleCompletionItem('${appName}', range, localize('appName', "e.g. VS Code")));
+		completions.push(this.newSimpleCompletionItem('${dirty}', range, localize('dirty', "a dirty indicator if the active editor is dirty")));
+		completions.push(this.newSimpleCompletionItem('${separator}', range, localize('separator', "a conditional separator (' - ') that only shows when surrounded by variables with values")));
+
+		return Promise.resolve(completions);
+	}
+
+	private provideFilesAssociationsCompletionItems(location: Location, range: vscode.Range): vscode.ProviderResult<vscode.CompletionItem[]> {
+		const completions: vscode.CompletionItem[] = [];
+
+		// Key
+		if (location.path.length === 1) {
+			completions.push(this.newSnippetCompletionItem({
+				label: localize('assocLabelFile', "Files with Extension"),
+				documentation: localize('assocDescriptionFile', "Map all files matching the glob pattern in their filename to the language with the given identifier."),
+				snippet: location.isAtPropertyKey ? '"*.${1:extension}": "${2:language}"' : '{ "*.${1:extension}": "${2:language}" }',
+				range
+			}));
+
+			completions.push(this.newSnippetCompletionItem({
+				label: localize('assocLabelPath', "Files with Path"),
+				documentation: localize('assocDescriptionPath', "Map all files matching the absolute path glob pattern in their path to the language with the given identifier."),
+				snippet: location.isAtPropertyKey ? '"/${1:path to file}/*.${2:extension}": "${3:language}"' : '{ "/${1:path to file}/*.${2:extension}": "${3:language}" }',
+				range
+			}));
+		}
+
+		// Value
+		else if (location.path.length === 2 && !location.isAtPropertyKey) {
+			return this.provideLanguageCompletionItems(location, range);
+		}
+
+		return Promise.resolve(completions);
+	}
+
+	private provideExcludeCompletionItems(location: Location, range: vscode.Range): vscode.ProviderResult<vscode.CompletionItem[]> {
+		const completions: vscode.CompletionItem[] = [];
+
+		// Key
+		if (location.path.length === 1) {
+			completions.push(this.newSnippetCompletionItem({
+				label: localize('fileLabel', "Files by Extension"),
+				documentation: localize('fileDescription', "Match all files of a specific file extension."),
+				snippet: location.isAtPropertyKey ? '"**/*.${1:extension}": true' : '{ "**/*.${1:extension}": true }',
+				range
+			}));
+
+			completions.push(this.newSnippetCompletionItem({
+				label: localize('filesLabel', "Files with Multiple Extensions"),
+				documentation: localize('filesDescription', "Match all files with any of the file extensions."),
+				snippet: location.isAtPropertyKey ? '"**/*.{ext1,ext2,ext3}": true' : '{ "**/*.{ext1,ext2,ext3}": true }',
+				range
+			}));
+
+			completions.push(this.newSnippetCompletionItem({
+				label: localize('derivedLabel', "Files with Siblings by Name"),
+				documentation: localize('derivedDescription', "Match files that have siblings with the same name but a different extension."),
+				snippet: location.isAtPropertyKey ? '"**/*.${1:source-extension}": { "when": "$(basename).${2:target-extension}" }' : '{ "**/*.${1:source-extension}": { "when": "$(basename).${2:target-extension}" } }',
+				range
+			}));
+
+			completions.push(this.newSnippetCompletionItem({
+				label: localize('topFolderLabel', "Folder by Name (Top Level)"),
+				documentation: localize('topFolderDescription', "Match a top level folder with a specific name."),
+				snippet: location.isAtPropertyKey ? '"${1:name}": true' : '{ "${1:name}": true }',
+				range
+			}));
+
+			completions.push(this.newSnippetCompletionItem({
+				label: localize('topFoldersLabel', "Folders with Multiple Names (Top Level)"),
+				documentation: localize('topFoldersDescription', "Match multiple top level folders."),
+				snippet: location.isAtPropertyKey ? '"{folder1,folder2,folder3}": true' : '{ "{folder1,folder2,folder3}": true }',
+				range
+			}));
+
+			completions.push(this.newSnippetCompletionItem({
+				label: localize('folderLabel', "Folder by Name (Any Location)"),
+				documentation: localize('folderDescription', "Match a folder with a specific name in any location."),
+				snippet: location.isAtPropertyKey ? '"**/${1:name}": true' : '{ "**/${1:name}": true }',
+				range
+			}));
+		}
+
+		// Value
+		else {
+			completions.push(this.newSimpleCompletionItem('false', range, localize('falseDescription', "Disable the pattern.")));
+			completions.push(this.newSimpleCompletionItem('true', range, localize('trueDescription', "Enable the pattern.")));
+
+			completions.push(this.newSnippetCompletionItem({
+				label: localize('derivedLabel', "Files with Siblings by Name"),
+				documentation: localize('siblingsDescription', "Match files that have siblings with the same name but a different extension."),
+				snippet: '{ "when": "$(basename).${1:extension}" }',
+				range
+			}));
+		}
+
+		return Promise.resolve(completions);
+	}
+
+	private provideLanguageCompletionItems(location: Location, range: vscode.Range, formatFunc: (string) => string = (l) => JSON.stringify(l)): vscode.ProviderResult<vscode.CompletionItem[]> {
+		return vscode.languages.getLanguages().then(languages => {
+			return languages.map(l => {
+				return this.newSimpleCompletionItem(formatFunc(l), range);
+			});
+		});
+	}
+
+	private provideLanguageOverridesCompletionItems(location: Location, position: vscode.Position): vscode.ProviderResult<vscode.CompletionItem[]> {
+		let range = this.document.getWordRangeAtPosition(position) || new vscode.Range(position, position);
+		const text = this.document.getText(range);
+
+		if (location.path.length === 0) {
+
+			let snippet = '"[${1:language}]": {\n\t"$0"\n}';
+
+			// Suggestion model word matching includes quotes,
+			// hence exclude the starting quote from the snippet and the range
+			// ending quote gets replaced
+			if (text && text.startsWith('"')) {
+				range = new vscode.Range(new vscode.Position(range.start.line, range.start.character + 1), range.end);
+				snippet = snippet.substring(1);
+			}
+
+			return Promise.resolve([this.newSnippetCompletionItem({
+				label: localize('languageSpecificEditorSettings', "Language specific editor settings"),
+				documentation: localize('languageSpecificEditorSettingsDescription', "Override editor settings for language"),
+				snippet,
+				range
+			})]);
+		}
+
+		if (location.path.length === 1 && location.previousNode && typeof location.previousNode.value === 'string' && location.previousNode.value.startsWith('[')) {
+			// Suggestion model word matching includes closed sqaure bracket and ending quote
+			// Hence include them in the proposal to replace
+			return this.provideLanguageCompletionItems(location, range, language => `"[${language}]"`);
+		}
+		return Promise.resolve([]);
+	}
+
+	private newSimpleCompletionItem(text: string, range: vscode.Range, description?: string, insertText?: string): vscode.CompletionItem {
+		const item = new vscode.CompletionItem(text);
+		item.kind = vscode.CompletionItemKind.Value;
+		item.detail = description;
+		item.insertText = insertText ? insertText : text;
+		item.range = range;
+		return item;
+	}
+
+	private newSnippetCompletionItem(o: { label: string; documentation?: string; snippet: string; range: vscode.Range; }): vscode.CompletionItem {
+		const item = new vscode.CompletionItem(o.label);
+		item.kind = vscode.CompletionItemKind.Value;
+		item.documentation = o.documentation;
+		item.insertText = new vscode.SnippetString(o.snippet);
+		item.range = o.range;
+		return item;
+	}
+}

extensions/configuration-editing/src/typings/ref.d.ts

@@ -0,0 +1,7 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/// <reference path='../../../../src/vs/vscode.d.ts'/>
+/// <reference types='@types/node'/>