function revealResourcesInOS(resources: URI[], windowsService: IWindowsService, notificationService: INotificationService): void { if (resources.length) { sequence(resources.map(r => () => windowsService.showItemInFolder(paths.normalize(r.fsPath, true)))); } else { notificationService.info(nls.localize('openFileToReveal', "Open a file first to reveal")); } }
export function provideSuggestionItems(model: IReadOnlyModel, position: Position, options: ISuggestOptions = {}): TPromise<ISuggestionItem[]> { const result: ISuggestionItem[] = []; const suggestFilter = createSuggesionFilter(options); const suggestCompare = createSuggesionComparator(options); // add suggestions from snippet registry const snippets = SnippetsRegistry.getSnippets(model, position); fillInSuggestResult(result, snippets, undefined, suggestFilter); // add suggestions from contributed providers - providers are ordered in groups of // equal score and once a group produces a result the process stops let hasResult = false; const factory = (options.groups || SuggestRegistry.orderedGroups(model)).map(supports => { return () => { // stop when we have a result if (hasResult) { return; } // for each support in the group ask for suggestions return TPromise.join(supports.map(support => asWinJsPromise(token => support.provideCompletionItems(model, position, token)).then(values => { if (!isFalsyOrEmpty(values)) { for (let suggestResult of values) { hasResult = fillInSuggestResult(result, suggestResult, support, suggestFilter) || hasResult; } } }, onUnexpectedError))); }; }); return sequence(factory).then(() => result.sort(suggestCompare)); }
function revealResourcesInOS(resources: URI[], windowsService: IWindowsService, messageService: IMessageService): void { if (resources.length) { sequence(resources.map(r => () => windowsService.showItemInFolder(paths.normalize(r.fsPath, true)))); } else { messageService.show(severity.Info, nls.localize('openFileToReveal', "Open a file first to reveal")); } }
export function provideSuggestionItems(model: IReadOnlyModel, position: Position, snippetConfig: SnippetConfig = 'bottom', onlyFrom?: ISuggestSupport[]): TPromise<ISuggestionItem[]> { const result: ISuggestionItem[] = []; const acceptSuggestion = createSuggesionFilter(snippetConfig); position = position.clone(); // get provider groups, always add snippet suggestion provider const supports = SuggestRegistry.orderedGroups(model); supports.unshift([snippetSuggestSupport]); // add suggestions from contributed providers - providers are ordered in groups of // equal score and once a group produces a result the process stops let hasResult = false; const factory = supports.map(supports => { return () => { // stop when we have a result if (hasResult) { return; } // for each support in the group ask for suggestions return TPromise.join(supports.map(support => { if (!isFalsyOrEmpty(onlyFrom) && onlyFrom.indexOf(support) < 0) { return; } return asWinJsPromise(token => support.provideCompletionItems(model, position, token)).then(container => { const len = result.length; if (container && !isFalsyOrEmpty(container.suggestions)) { for (let suggestion of container.suggestions) { if (acceptSuggestion(suggestion)) { fixOverwriteBeforeAfter(suggestion, container); result.push({ position, container, suggestion, support, resolve: createSuggestionResolver(support, suggestion, model, position) }); } } } if (len !== result.length && support !== snippetSuggestSupport) { hasResult = true; } }, onUnexpectedError); })); }; }); return sequence(factory).then(() => result.sort(getSuggestionComparator(snippetConfig))); }
function revealResourcesInOS(resources: URI[], windowsService: IWindowsService, notificationService: INotificationService, workspaceContextService: IWorkspaceContextService): void { if (resources.length) { sequence(resources.map(r => () => windowsService.showItemInFolder(r))); } else if (workspaceContextService.getWorkspace().folders.length) { windowsService.showItemInFolder(workspaceContextService.getWorkspace().folders[0].uri); } else { notificationService.info(nls.localize('openFileToReveal', "Open a file first to reveal")); } }
const revealInOSHandler = (accessor: ServicesAccessor, resource: URI) => { // Without resource, try to look at the active editor const resources = getMultiSelectedResources(resource, accessor.get(IListService), accessor.get(IWorkbenchEditorService)); if (resources.length) { const windowsService = accessor.get(IWindowsService); sequence(resources.map(r => () => windowsService.showItemInFolder(paths.normalize(r.fsPath, true)))); } else { const messageService = accessor.get(IMessageService); messageService.show(severity.Info, nls.localize('openFileToReveal', "Open a file first to reveal")); } };
export function provideCompletionItems(model: IReadOnlyModel, position: IEditorPosition, groups?: ISuggestSupport[][]): TPromise<ISuggestResult2[]> { if (!groups) { groups = SuggestRegistry.orderedGroups(model); } const result: ISuggestResult2[] = []; const factory = groups.map((supports, index) => { return () => { // stop as soon as a group produced a result if (result.length > 0) { return; } // for each support in the group ask for suggestions return TPromise.join(supports.map(support => { return asWinJsPromise((token) => { return support.provideCompletionItems(model, position, token); }).then(values => { if (!values) { return; } for (let suggestResult of values) { if (!suggestResult || isFalsyOrEmpty(suggestResult.suggestions)) { continue; } result.push({ support, currentWord: suggestResult.currentWord, incomplete: suggestResult.incomplete, suggestions: suggestResult.suggestions }); } }, onUnexpectedError); })); }; }); return sequence(factory).then(() => { // add snippets to the first group const snippets = SnippetsRegistry.getSnippets(model, position); result.push(snippets); return result; }); }
export function rename(model: IReadOnlyModel, position: Position, newName: string): TPromise<WorkspaceEdit> { const supports = RenameProviderRegistry.ordered(model); const rejects: string[] = []; let hasResult = false; const factory = supports.map(support => { return () => { if (!hasResult) { return asWinJsPromise((token) => { return support.provideRenameEdits(model, position, newName, token); }).then(result => { if (!result) { // ignore } else if (!result.rejectReason) { hasResult = true; return result; } else { rejects.push(result.rejectReason); } return undefined; }, err => { onUnexpectedExternalError(err); return TPromise.wrapError<WorkspaceEdit>('provider failed'); }); } return undefined; }; }); return sequence(factory).then((values): WorkspaceEdit => { let result = values[0]; if (rejects.length > 0) { return { edits: undefined, rejectReason: rejects.join('\n') }; } else if (!result) { return { edits: undefined, rejectReason: localize('no result', "No result.") }; } else { return result; } }); }
export function provideSignatureHelp(model: ITextModel, position: Position): TPromise<SignatureHelp> { const supports = SignatureHelpProviderRegistry.ordered(model); let result: SignatureHelp; return sequence(supports.map(support => () => { if (result) { // stop when there is a result return undefined; } return asWinJsPromise(token => support.provideSignatureHelp(model, position, token)).then(thisResult => { result = thisResult; }, onUnexpectedExternalError); })).then(() => result); }
export function getDocumentFormattingEdits(model: IReadOnlyModel, options: FormattingOptions): TPromise<ISingleEditOperation[]> { const providers = DocumentFormattingEditProviderRegistry.ordered(model); // try range formatters when no document formatter is registered if (providers.length === 0) { return getDocumentRangeFormattingEdits(model, model.getFullModelRange(), options); } let result: ISingleEditOperation[]; return sequence(providers.map(provider => { if (isFalsyOrEmpty(result)) { return () => { return asWinJsPromise(token => provider.provideDocumentFormattingEdits(model, options, token)).then(value => { result = value; }, onUnexpectedExternalError); }; } })).then(() => result); }