jupyterlab_code_formatter 2.2.1 → 3.0.2

package/README.md

@@ -1,31 +1,36 @@
 ![](docs/logo.png)
 
-*A JupyterLab plugin to facilitate invocation of code formatters.*
+[![Extension status](https://img.shields.io/badge/status-ready-success 'ready to be used')](https://jupyterlab-contrib.github.io/)
+[![GitHub Action Status](https://github.com/jupyterlab-contrib/jupyterlab_code_formatter/actions/workflows/build.yml/badge.svg)](https://github.com/jupyterlab-contrib/jupyterlab_code_formatter/actions/workflows/build.yml)
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/jupyterlab-contrib/jupyterlab_code_formatter/master?urlpath=lab)
+[![pypi-version](https://img.shields.io/pypi/v/jupyterlab-code-formatter.svg)](https://python.org/pypi/jupyterlab-code-formatter)
 
-PSA: I can only dedicate a few hours per week for this plugin, bear with me if your request/issue is taking a while to be fixed.
+_A JupyterLab plugin to facilitate invocation of code formatters._
 
-----
+---
 
 Documentation: [Hosted on ReadTheDocs](https://jupyterlab-code-formatter.readthedocs.io/)
 
-----
+---
 
 ## Demo
 
 ![](docs/_static/format-all.gif)
 
-----
+---
 
 ## Quick Start
 
 I recommend you going to the [documentation site](https://jupyterlab-code-formatter.readthedocs.io/#quick-start), but this should work too.
 
 1. **Install the package**
+
 ```bash
 pip install jupyterlab-code-formatter
 ```
 
 2. **Install some supported formatters** (isort+black are default for Python)
+
 ```bash
 # NOTE: Install black and isort,
 #       JL code formatter is configured to invoke isort and black by default
@@ -40,25 +45,30 @@ This plugin includes a server plugin, restart JupyterLab if you have followed th
 
 To configure which/how formatters are invoked, see [configuration](https://jupyterlab-code-formatter.readthedocs.io/configuration.html).
 
-----
+---
+
+## Getting help
+
+If you don't use Discord then feel free to open a [GitHub issue](https://github.com/jupyterlab-contrib/jupyterlab_code_formatter/issues), do note I am a bit slower in responding in GitHub.
+
+---
 
 ## Your Support
 
-I could really use your support in giving me a star on GitHub, recommending features, fixing bugs or maybe even providing monetary support!
+I could really use your support in giving me a star on GitHub, recommending features or fixing bugs.
 
-- [Recommending features via GitHub Issues](https://github.com/ryantam626/jupyterlab_code_formatter/issues)
-- [Sumitting your PR on GitHub](https://github.com/ryantam626/jupyterlab_code_formatter/pulls)
-- [Buy me a coffee](https://www.buymeacoffee.com/ryantam626)
-- [Donating Via Solana](https://solana.com/): 6K7aK5RpskJkhEkwZi1ZQr68LhaVdfnTfWjZEQV3VbbD
+- [Recommending features via GitHub Issues](https://github.com/jupyterlab-contrib/jupyterlab_code_formatter/issues)
+- [Submitting your PR on GitHub](https://github.com/jupyterlab-contrib/jupyterlab_code_formatter/pulls)
 
-----
+---
 
 ## Contributors
 
+This extension was originally developed and maintained by [@ryantam626](https://github.com/ryantam626).
 Massive thanks to the below list of people who made past contributions to the project!
 
-<a href="https://github.com/ryantam626/jupyterlab_code_formatter/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=ryantam626/jupyterlab_code_formatter" />
+<a href="https://github.com/jupyterlab-contrib/jupyterlab_code_formatter/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=jupyterlab-contrib/jupyterlab_code_formatter" />
 </a>
 
 ## License

package/lib/formatter.d.ts

@@ -2,6 +2,9 @@ import { INotebookTracker, Notebook } from '@jupyterlab/notebook';
 import JupyterlabCodeFormatterClient from './client';
 import { IEditorTracker } from '@jupyterlab/fileeditor';
 import { Widget } from '@lumino/widgets';
+type Context = {
+    saving: boolean;
+};
 declare class JupyterlabCodeFormatter {
     working: boolean;
     protected client: JupyterlabCodeFormatterClient;
@@ -13,7 +16,7 @@ export declare class JupyterlabNotebookCodeFormatter extends JupyterlabCodeForma
     constructor(client: JupyterlabCodeFormatterClient, notebookTracker: INotebookTracker);
     formatAction(config: any, formatter?: string): Promise<void>;
     formatSelectedCodeCells(config: any, formatter?: string, notebook?: Notebook): Promise<void>;
-    formatAllCodeCells(config: any, formatter?: string, notebook?: Notebook): Promise<void>;
+    formatAllCodeCells(config: any, context: Context, formatter?: string, notebook?: Notebook): Promise<void>;
     private getCodeCells;
     private getNotebookType;
     private getDefaultFormatters;
@@ -25,7 +28,12 @@ export declare class JupyterlabNotebookCodeFormatter extends JupyterlabCodeForma
 export declare class JupyterlabFileEditorCodeFormatter extends JupyterlabCodeFormatter {
     protected editorTracker: IEditorTracker;
     constructor(client: JupyterlabCodeFormatterClient, editorTracker: IEditorTracker);
-    formatAction(config: any, formatter: string): void;
+    formatAction(config: any, formatter: string): Promise<void>;
+    formatEditor(config: any, context: Context, formatter?: string): Promise<void>;
+    private getEditorType;
+    private getDefaultFormatters;
+    private getFormattersToUse;
+    private applyFormatters;
     applicable(formatter: string, currentWidget: Widget): boolean | null;
 }
 export {};

package/lib/formatter.js

@@ -1,4 +1,4 @@
-import { showErrorMessage } from '@jupyterlab/apputils';
+import { showErrorMessage, Dialog, showDialog } from '@jupyterlab/apputils';
 class JupyterlabCodeFormatter {
     constructor(client) {
         this.working = false;
@@ -21,13 +21,13 @@ export class JupyterlabNotebookCodeFormatter extends JupyterlabCodeFormatter {
         this.notebookTracker = notebookTracker;
     }
     async formatAction(config, formatter) {
-        return this.formatCells(true, config, formatter);
+        return this.formatCells(true, config, { saving: false }, formatter);
     }
     async formatSelectedCodeCells(config, formatter, notebook) {
-        return this.formatCells(true, config, formatter, notebook);
+        return this.formatCells(true, config, { saving: false }, formatter, notebook);
     }
-    async formatAllCodeCells(config, formatter, notebook) {
-        return this.formatCells(false, config, formatter, notebook);
+    async formatAllCodeCells(config, context, formatter, notebook) {
+        return this.formatCells(false, config, context, formatter, notebook);
     }
     getCodeCells(selectedOnly = true, notebook) {
         if (!this.notebookTracker.currentWidget) {
@@ -45,25 +45,39 @@ export class JupyterlabNotebookCodeFormatter extends JupyterlabCodeFormatter {
         return codeCells;
     }
     getNotebookType() {
+        var _a, _b, _c, _d, _e;
+        // If there is no current notebook, there is nothing to do
         if (!this.notebookTracker.currentWidget) {
             return null;
         }
-        const metadata = this.notebookTracker.currentWidget.content.model.sharedModel.metadata;
-        ;
-        if (!metadata) {
-            return null;
-        }
-        // prefer kernelspec language
-        // @ts-ignore
-        if (metadata.kernelspec && metadata.kernelspec.language) {
-            // @ts-ignore
-            return metadata.kernelspec.language.toLowerCase();
+        // first, check the notebook's metadata for language info
+        const metadata = (_b = (_a = this.notebookTracker.currentWidget.content.model) === null || _a === void 0 ? void 0 : _a.sharedModel) === null || _b === void 0 ? void 0 : _b.metadata;
+        if (metadata) {
+            // prefer kernelspec language
+            if (metadata.kernelspec &&
+                metadata.kernelspec.language &&
+                typeof metadata.kernelspec.language === 'string') {
+                return metadata.kernelspec.language.toLowerCase();
+            }
+            // otherwise, check language info code mirror mode
+            if (metadata.language_info && metadata.language_info.codemirror_mode) {
+                const mode = metadata.language_info.codemirror_mode;
+                if (typeof mode === 'string') {
+                    return mode.toLowerCase();
+                }
+                else if (typeof mode.name === 'string') {
+                    return mode.name.toLowerCase();
+                }
+            }
         }
-        // otherwise, check language info code mirror mode
-        // @ts-ignore
-        if (metadata.language_info && metadata.language_info.codemirror_mode) {
-            // @ts-ignore
-            return metadata.language_info.codemirror_mode.name.toLowerCase();
+        // in the absence of metadata, look in the current session's kernel spec
+        const sessionContext = this.notebookTracker.currentWidget.sessionContext;
+        const kernelName = (_d = (_c = sessionContext === null || sessionContext === void 0 ? void 0 : sessionContext.session) === null || _c === void 0 ? void 0 : _c.kernel) === null || _d === void 0 ? void 0 : _d.name;
+        if (kernelName) {
+            const specs = (_e = sessionContext.specsManager.specs) === null || _e === void 0 ? void 0 : _e.kernelspecs;
+            if (specs && kernelName in specs) {
+                return specs[kernelName].language;
+            }
         }
         return null;
     }
@@ -88,15 +102,18 @@ export class JupyterlabNotebookCodeFormatter extends JupyterlabCodeFormatter {
         }
         return formattersToUse;
     }
-    async applyFormatters(selectedCells, formattersToUse, config) {
-        var _a;
+    async applyFormatters(selectedCells, formattersToUse, config, context) {
+        var _a, _b;
         for (const formatterToUse of formattersToUse) {
             if (formatterToUse === 'noop' || formatterToUse === 'skip') {
                 continue;
             }
             const currentTexts = selectedCells.map(cell => cell.model.sharedModel.source);
             const formattedTexts = await this.formatCode(currentTexts, formatterToUse, config[formatterToUse], true, config.cacheFormatters);
-            const showErrors = !((_a = config.suppressFormatterErrors) !== null && _a !== void 0 ? _a : false);
+            console.log(config.suppressFormatterErrorsIFFAutoFormatOnSave, context.saving);
+            const showErrors = !((_a = config.suppressFormatterErrors) !== null && _a !== void 0 ? _a : false) &&
+                !(((_b = config.suppressFormatterErrorsIFFAutoFormatOnSave) !== null && _b !== void 0 ? _b : false) &&
+                    context.saving);
             for (let i = 0; i < selectedCells.length; ++i) {
                 const cell = selectedCells[i];
                 const currentText = currentTexts[i];
@@ -105,7 +122,21 @@ export class JupyterlabNotebookCodeFormatter extends JupyterlabCodeFormatter {
                 if (cellValueHasNotChanged) {
                     if (formattedText.error) {
                         if (showErrors) {
-                            await showErrorMessage('Jupyterlab Code Formatter Error', formattedText.error);
+                            const result = await showDialog({
+                                title: 'Jupyterlab Code Formatter Error',
+                                body: formattedText.error,
+                                buttons: [
+                                    Dialog.createButton({
+                                        label: 'Go to cell',
+                                        actions: ['revealError']
+                                    }),
+                                    Dialog.okButton({ label: 'Dismiss' })
+                                ]
+                            });
+                            if (result.button.actions.indexOf('revealError') !== -1) {
+                                this.notebookTracker.currentWidget.content.scrollToCell(cell);
+                                break;
+                            }
                         }
                     }
                     else {
@@ -120,7 +151,7 @@ export class JupyterlabNotebookCodeFormatter extends JupyterlabCodeFormatter {
             }
         }
     }
-    async formatCells(selectedOnly, config, formatter, notebook) {
+    async formatCells(selectedOnly, config, context, formatter, notebook) {
         if (this.working) {
             return;
         }
@@ -132,10 +163,10 @@ export class JupyterlabNotebookCodeFormatter extends JupyterlabCodeFormatter {
                 return;
             }
             const formattersToUse = await this.getFormattersToUse(config, formatter);
-            await this.applyFormatters(selectedCells, formattersToUse, config);
+            await this.applyFormatters(selectedCells, formattersToUse, config, context);
         }
         catch (error) {
-            await showErrorMessage('Jupyterlab Code Formatter Error', error);
+            await showErrorMessage('Jupyterlab Code Formatter Error', `${error}`);
         }
         this.working = false;
     }
@@ -151,28 +182,90 @@ export class JupyterlabFileEditorCodeFormatter extends JupyterlabCodeFormatter {
         this.editorTracker = editorTracker;
     }
     formatAction(config, formatter) {
+        return this.formatEditor(config, { saving: false }, formatter);
+    }
+    async formatEditor(config, context, formatter) {
         if (this.working) {
             return;
         }
-        const editorWidget = this.editorTracker.currentWidget;
-        this.working = true;
-        const editor = editorWidget.content.editor;
-        const code = editor.model.sharedModel.source;
-        this.formatCode([code], formatter, config[formatter], false, config.cacheFormatters)
-            .then(data => {
-            if (data.code[0].error) {
-                void showErrorMessage('Jupyterlab Code Formatter Error', data.code[0].error);
-                this.working = false;
-                return;
+        try {
+            this.working = true;
+            const formattersToUse = await this.getFormattersToUse(config, formatter);
+            await this.applyFormatters(formattersToUse, config, context);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error : `${error}`;
+            await showErrorMessage('Jupyterlab Code Formatter Error', msg);
+        }
+        this.working = false;
+    }
+    getEditorType() {
+        if (!this.editorTracker.currentWidget) {
+            return null;
+        }
+        const mimeType = this.editorTracker.currentWidget.content.model.mimeType;
+        const mimeTypes = new Map([
+            ['text/x-python', 'python'],
+            ['application/x-rsrc', 'r'],
+            ['application/x-scala', 'scala'],
+            ['application/x-rustsrc', 'rust'],
+            ['application/x-c++src', 'cpp'] // Not sure that this is right, whatever.
+            // Add more MIME types and corresponding programming languages here
+        ]);
+        return mimeTypes.get(mimeType);
+    }
+    getDefaultFormatters(config) {
+        const editorType = this.getEditorType();
+        if (editorType) {
+            const defaultFormatter = config.preferences.default_formatter[editorType];
+            if (defaultFormatter instanceof Array) {
+                return defaultFormatter;
             }
-            this.editorTracker.currentWidget.content.editor.model.sharedModel.source =
-                data.code[0].code;
-            this.working = false;
-        })
-            .catch(error => {
-            this.working = false;
-            void showErrorMessage('Jupyterlab Code Formatter Error', error);
-        });
+            else if (defaultFormatter !== undefined) {
+                return [defaultFormatter];
+            }
+        }
+        return [];
+    }
+    async getFormattersToUse(config, formatter) {
+        const defaultFormatters = this.getDefaultFormatters(config);
+        const formattersToUse = formatter !== undefined ? [formatter] : defaultFormatters;
+        if (formattersToUse.length === 0) {
+            await showErrorMessage('Jupyterlab Code Formatter Error', 'Unable to find default formatters to use, please file an issue on GitHub.');
+        }
+        return formattersToUse;
+    }
+    async applyFormatters(formattersToUse, config, context) {
+        var _a, _b;
+        for (const formatterToUse of formattersToUse) {
+            if (formatterToUse === 'noop' || formatterToUse === 'skip') {
+                continue;
+            }
+            const showErrors = !((_a = config.suppressFormatterErrors) !== null && _a !== void 0 ? _a : false) &&
+                !(((_b = config.suppressFormatterErrorsIFFAutoFormatOnSave) !== null && _b !== void 0 ? _b : false) &&
+                    context.saving);
+            const editorWidget = this.editorTracker.currentWidget;
+            this.working = true;
+            const editor = editorWidget.content.editor;
+            const code = editor.model.sharedModel.source;
+            this.formatCode([code], formatterToUse, config[formatterToUse], false, config.cacheFormatters)
+                .then(data => {
+                if (data.code[0].error) {
+                    if (showErrors) {
+                        void showErrorMessage('Jupyterlab Code Formatter Error', data.code[0].error);
+                    }
+                    this.working = false;
+                    return;
+                }
+                this.editorTracker.currentWidget.content.editor.model.sharedModel.source =
+                    data.code[0].code;
+                this.working = false;
+            })
+                .catch(error => {
+                const msg = error instanceof Error ? error : `${error}`;
+                void showErrorMessage('Jupyterlab Code Formatter Error', msg);
+            });
+        }
     }
     applicable(formatter, currentWidget) {
         const currentEditorWidget = this.editorTracker.currentWidget;

package/lib/index.js

@@ -33,7 +33,7 @@ class JupyterLabCodeFormatter {
                 svgstr: Constants.ICON_FORMAT_ALL_SVG
             }),
             onClick: async () => {
-                await this.notebookCodeFormatter.formatAllCodeCells(this.config, undefined, nb.content);
+                await this.notebookCodeFormatter.formatAllCodeCells(this.config, { saving: false }, undefined, nb.content);
             }
         });
         nb.toolbar.insertAfter('cellType', this.app.commands.label(Constants.FORMAT_ALL_COMMAND), button);
@@ -44,11 +44,28 @@ class JupyterLabCodeFormatter {
     }
     async onSave(context, state) {
         if (state === 'started' && this.config.formatOnSave) {
-            await this.notebookCodeFormatter.formatAllCodeCells(this.config);
+            await context.sessionContext.ready;
+            await this.notebookCodeFormatter.formatAllCodeCells(this.config, { saving: true }, undefined, undefined);
+        }
+    }
+    createNewEditor(widget, context) {
+        // Connect to save(State) signal, to be able to detect document save event
+        context.saveState.connect(this.onSaveEditor, this);
+        // Return an empty disposable, because we don't create any object
+        return new DisposableDelegate(() => { });
+    }
+    async onSaveEditor(context, state) {
+        if (state === 'started' && this.config.formatOnSave) {
+            this.fileEditorCodeFormatter.formatEditor(this.config, { saving: true }, undefined);
         }
     }
     setupWidgetExtension() {
         this.app.docRegistry.addWidgetExtension('Notebook', this);
+        this.app.docRegistry.addWidgetExtension('editor', {
+            createNew: (widget, context) => {
+                return this.createNewEditor(widget, context);
+            }
+        });
     }
     setupContextMenu() {
         this.app.contextMenu.addItem({
@@ -80,7 +97,9 @@ class JupyterLabCodeFormatter {
         });
         this.app.commands.addCommand(Constants.FORMAT_ALL_COMMAND, {
             execute: async () => {
-                await this.notebookCodeFormatter.formatAllCodeCells(this.config);
+                await this.notebookCodeFormatter.formatAllCodeCells(this.config, {
+                    saving: false
+                });
             },
             iconClass: Constants.ICON_FORMAT_ALL,
             iconLabel: 'Format notebook'

package/package.json

@@ -1,15 +1,15 @@
 {
     "name": "jupyterlab_code_formatter",
-    "version": "2.2.1",
+    "version": "3.0.2",
     "description": " A JupyterLab plugin to facilitate invocation of code formatters.",
     "keywords": [
         "jupyter",
         "jupyterlab",
         "jupyterlab-extension"
     ],
-    "homepage": " https://github.com/ryantam626/jupyterlab_code_formatter",
+    "homepage": " https://github.com/jupyterlab-contrib/jupyterlab_code_formatter",
     "bugs": {
-        "url": " https://github.com/ryantam626/jupyterlab_code_formatter/issues"
+        "url": " https://github.com/jupyterlab-contrib/jupyterlab_code_formatter/issues"
     },
     "license": "BSD-3-Clause",
     "author": {
@@ -26,7 +26,7 @@
     "style": "style/index.css",
     "repository": {
         "type": "git",
-        "url": " https://github.com/ryantam626/jupyterlab_code_formatter.git"
+        "url": " https://github.com/jupyterlab-contrib/jupyterlab_code_formatter.git"
     },
     "scripts": {
         "build": "jlpm build:lib && jlpm build:labextension:dev",
@@ -56,36 +56,40 @@
         "watch:labextension": "jupyter labextension watch ."
     },
     "dependencies": {
-        "@jupyterlab/application": "^3.6.0 || ~4.0.0",
-        "@jupyterlab/coreutils": "^5.1.0",
-        "@jupyterlab/fileeditor": "^3.6.0 || ~4.0.0",
-        "@jupyterlab/mainmenu": "^3.6.0 || ~4.0.0",
-        "@jupyterlab/services": "^6.1.0",
-        "@jupyterlab/settingregistry": "^3.6.0 || ~4.0.0"
+        "@jupyterlab/application": "^4.0.0",
+        "@jupyterlab/coreutils": "^6.0.0",
+        "@jupyterlab/fileeditor": "^4.0.0",
+        "@jupyterlab/mainmenu": "^4.0.0",
+        "@jupyterlab/services": "^7.0.0",
+        "@jupyterlab/settingregistry": "^4.0.0"
     },
     "devDependencies": {
-        "@babel/core": "^7.0.0",
-        "@babel/preset-env": "^7.0.0",
-        "@jupyterlab/builder": "^3.6.0 || ~4.0.0",
-        "@jupyterlab/testutils": "^3.6.0 || ~4.0.0",
-        "@types/jest": "^26.0.0",
-        "@typescript-eslint/eslint-plugin": "^4.8.1",
-        "@typescript-eslint/parser": "^4.8.1",
-        "eslint": "^7.14.0",
-        "eslint-config-prettier": "^6.15.0",
-        "eslint-plugin-prettier": "^3.1.4",
-        "jest": "^26.0.0",
+        "@jupyterlab/builder": "^4.2.3",
+        "@jupyterlab/testutils": "^4.0.0",
+        "@types/jest": "^29.2.0",
+        "@types/json-schema": "^7.0.11",
+        "@types/react": "^18.0.26",
+        "@types/react-addons-linked-state-mixin": "^0.14.22",
+        "@typescript-eslint/eslint-plugin": "^6.1.0",
+        "@typescript-eslint/parser": "^6.1.0",
+        "css-loader": "^6.7.1",
+        "eslint": "^8.36.0",
+        "eslint-config-prettier": "^8.8.0",
+        "eslint-plugin-prettier": "^5.0.0",
+        "jest": "^29.2.0",
         "mkdirp": "^1.0.3",
         "npm-run-all": "^4.1.5",
-        "prettier": "^2.1.1",
-        "rimraf": "^3.0.2",
-        "stylelint": "^14.3.0",
-        "stylelint-config-prettier": "^9.0.4",
-        "stylelint-config-recommended": "^6.0.0",
-        "stylelint-config-standard": "~24.0.0",
-        "stylelint-prettier": "^2.0.0",
-        "ts-jest": "^26.0.0",
-        "typescript": "~4.1.3"
+        "prettier": "^3.0.0",
+        "rimraf": "^5.0.1",
+        "source-map-loader": "^1.0.2",
+        "style-loader": "^3.3.1",
+        "stylelint": "^15.10.1",
+        "stylelint-config-recommended": "^13.0.0",
+        "stylelint-config-standard": "^34.0.0",
+        "stylelint-csstree-validator": "^3.0.0",
+        "stylelint-prettier": "^4.0.0",
+        "typescript": "~5.0.2",
+        "yjs": "^13.5.0"
     },
     "sideEffects": [
         "style/*.css",
@@ -177,7 +181,15 @@
         "singleQuote": true,
         "trailingComma": "none",
         "arrowParens": "avoid",
-        "endOfLine": "auto"
+        "endOfLine": "auto",
+        "overrides": [
+            {
+                "files": "package.json",
+                "options": {
+                    "tabWidth": 4
+                }
+            }
+        ]
     },
     "stylelint": {
         "extends": [
@@ -185,7 +197,11 @@
             "stylelint-config-standard",
             "stylelint-prettier/recommended"
         ],
+        "plugins": [
+            "stylelint-csstree-validator"
+        ],
         "rules": {
+            "csstree/validator": true,
             "property-no-vendor-prefix": null,
             "selector-no-vendor-prefix": null,
             "value-no-vendor-prefix": null

package/schema/settings.json

@@ -208,6 +208,13 @@
       "additionalProperties": false,
       "type": "object"
     },
+    "ruffformat": {
+      "properties": {
+        "args": { "type": "array", "items": { "type": "string" } }
+      },
+      "additionalProperties": false,
+      "type": "object"
+    },
     "formatR": {
       "properties": {
         "comment": {
@@ -313,6 +320,10 @@
     "suppressFormatterErrors": {
       "additionalProperties": false,
       "type": "boolean"
+    },
+    "suppressFormatterErrorsIFFAutoFormatOnSave": {
+      "additionalProperties": false,
+      "type": "boolean"
     }
   },
   "properties": {
@@ -403,11 +414,19 @@
       }
     },
     "ruff": {
-      "title": "Ruff Config",
-      "description": "Command line options to be passed to ruff.",
+      "title": "Ruff Check Config",
+      "description": "Command line options to be passed to ruff check.  Default is to organise imports.",
       "$ref": "#/definitions/ruff",
       "default": {
-        "args": ["--select=I"]
+        "args": ["--select=I001"]
+      }
+    },
+    "ruffformat": {
+      "title": "Ruff Format Config",
+      "description": "Command line options to be passed to ruff format.",
+      "$ref": "#/definitions/ruffformat",
+      "default": {
+        "args": []
       }
     },
     "suppressFormatterErrors": {
@@ -415,6 +434,12 @@
       "description": "Whether to suppress all errors reported by formatter while formatting. Useful when you have format on save mode on.",
       "$ref": "#/definitions/suppressFormatterErrors",
       "default": false
+    },
+    "suppressFormatterErrorsIFFAutoFormatOnSave": {
+      "title": "Suppress formatter errors if and only if auto saving.",
+      "description": "Whether to suppress all errors reported by formatter while formatting (if and only if auto saving). Useful when you have format on save mode on and still want to see error when manually formatting.",
+      "$ref": "#/definitions/suppressFormatterErrorsIFFAutoFormatOnSave",
+      "default": false
     }
   },
   "additionalProperties": false,