Open changes (compare files) of custom editors using code editor

[safisa]

Hi,
The PR: #13916 added support for using custom editors in the diff viewer (side by side), which is a very nice and important feature (especially for binary custom editors).
I need to add some changes to it:

1. first, for some file extensions I want to use the regular code editor in compare/diff.
2. for all files based on custom editors, I want to add support to use both editors custom and code editor in diff/compare, by adding a new command to the context menu (or another way I need to think of)...
3. both need to apply on git compare too

What classes do I need to override and change to do the above?

Thanks

[safisa]

I have resolved it by overriding the DiffService class:

1. first I have added 2 settings properties, one (boolean) to disable the use of custom editor in diff/comapre, and another one (array) that contains all file extensions that will ignore the custom editor use in diff/compare (in case the first setting is not disabled)
2. overriding the DiffService by extending it and rebind the new class

@injectable()
export class CustomDiffService extends DiffService {

    @inject(PreferenceService)
    protected readonly preferenceService: PreferenceService;

    public async openDiffEditor(left: URI, right: URI, label?: string, options?: OpenerOptions): Promise<void> {
        //super.openDiffEditor(left, right, label, options);

        if (left.scheme === 'file' && right.scheme === 'file') {
            const [resolvedLeft, resolvedRight] = await this.fileService.resolveAll([{ resource: left }, { resource: right }]);
            if (resolvedLeft.success && resolvedRight.success) {
                const leftStat = resolvedLeft.stat;
                const rightStat = resolvedRight.stat;
                if (leftStat && rightStat) {
                    if (!leftStat.isDirectory && !rightStat.isDirectory) {
                        const uri = DiffUris.encode(left, right, label);
                        // my code
                        const opened = await this.openTextEditorDiff(left, right, uri, options);
                        if (opened) {
                            return;
                        }
                        //
                        await open(this.openerService, uri, options);
                    } else {
                        const details = (() => {
                            if (leftStat.isDirectory && rightStat.isDirectory) {
                                return 'Both resource were a directory.';
                            } else {
                                if (leftStat.isDirectory) {
                                    return `'${left.path.base}' was a directory.`;
                                } else {
                                    return `'${right.path.base}' was a directory.`;
                                }
                            }
                        });
                        this.messageService.warn(`Directories cannot be compared. ${details()}`);
                    }
                }
            }
        } else {
            const uri = DiffUris.encode(left, right, label);
            // my code
            const opened = await this.openTextEditorDiff(left, right, uri, options);
            if (opened) {
                return;
            }
            //
            await open(this.openerService, uri, options);
        }
    }

    private async openTextEditorDiff(left: URI, right: URI, uri: URI, options?: OpenerOptions) {
        let useTextEditor = this.preferenceService.get<boolean>("compareFiles.alwaysUseTextEditor");
        let arrExtensionsForTextEditor = this.preferenceService.get<string[]>("compareFiles.useTextEditorForSpecificFileExtensions");
        if (!useTextEditor) {
            arrExtensionsForTextEditor?.forEach(ext => {
                if (right.path?.base?.toLowerCase().endsWith(ext.toLowerCase())) {
                    useTextEditor = true;
                }
            });
        }
        let openers = await this.openerService.getOpeners(uri, options);
        //let customEditorHandler = openers.find(h => h.id.includes("custom-editor"));
        if (useTextEditor) {
            const editorHandler = openers.find(h => h.id === "editor-preview-widget");
            if (editorHandler && editorHandler.canHandle(uri, options)) {
                await editorHandler.open(uri, options);
                return true;
            }
        }
        return false;
    }

}

@pisv Can you confirm that this is OK (especially the openTextEditorDiff method)?

[pisv]

@safisa Looks good to me. You could also inject and use an instance of EditorManager directly instead of looking it up in openers:

@inject(EditorManager)
protected readonly editorManager: EditorManager;
...

    if (useTextEditor && this.editorManager.canHandle(uri, options)) {
        await this.editorManager.open(uri, options);
        return true;
    }

[safisa]

Yes, this is better.
Thanks