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