Configuring Ruff

[charliermarsh]

If you're interested in using Ruff's autofix functionality within Zed, you can add it as an external formatter via the following settings snippet:

 {
    "language_overrides": {
        "Python": {
            "format_on_save": {
                "external": {
                    "command": "ruff",
                    "arguments": [
                        "check",
                        "--exit-zero",
                        "--fix",
                        "--stdin-filename",
                        "{buffer_path}",
                        "-"
                    ]
                }
            }
        }
    }
}

Here's a clip of it in action from Twitter. Thanks @JosephTLyons for encouraging this tip.

[JosephTLyons]

Excited to have learned about Ruff today; going to have to play with it on some projects. :)

[charliermarsh]

Send me feature requests :)

[drcongo]

Ruff is absolutely magnificent, I think I'd probably use Zed as my daily driver if Ruff-lsp support for linting was available.

[Tom-Boscher]

Is it possible to use it in addition to Black? It seems that it's not currently possible to use several formatter at the same time.

[denys-zarubin]

Isn't this implementation better?

"language_overrides": { "Python": { "format_on_save": { "external": { "command": "ruff", "arguments": ["format", "-"] } } } },

Otherwise, how do I use ruff as a linter? Are there any configs for LSP maybe?

[den-is]

Would like to have it working in parallel with Black.
In VScode I use both:

• black for strict autoformatting
• ruff for python imports sorting, and of course for linting (with notifications)
  • vscode has a standalone set of command which control "imports sorting", but right now I manage it by only and the most popular Ruff plugin, and its settings.

[danstewart]

Here's how I got ruff fix and format working:

  "language_overrides": {
    "Python": {
      "format_on_save": "on",
      "formatter": {
        "external": {
          "command": "bash",
          "arguments": [
            "-c",
            "ruff check --exit-zero --fix --unsafe-fixes --stdin-filename {buffer_path} | ruff format --stdin-filename {buffer_path}"
          ]
        }
      }
    }
  }

[tfeldmann]

Sort imports and format with ruff

{
  "language_overrides": {
    "Python": {
      "format_on_save": "on",
      "formatter": {
        "external": {
          "command": "bash",
          "arguments": [
            "-c",
            "ruff check --select=I --fix --stdin-filename {buffer_path} | ruff format --stdin-filename {buffer_path}"
          ]
        }
      }
    }
  }
}

[haeussma]

Configured the formatter as mentioned

"language_overrides": {
    "Python": {
      "format_on_save": "off",
      "formatter": {
        "external": {
          "command": "bash",
          "arguments": ["-c", "ruff format --exit-zero --fix --stdin-filename {buffer_path}"]
      }
    }
  },

But the content of my file is being replaced by the output of ruff.
Any idea where this error is coming from?

[charliermarsh]

I think you should omit --exit-zero --fix -- just ruff format --stdin-filename {buffer_path}.

[tibitTW]

I follow with current configure spec and use this:

    "languages": {
        "Python": {
            "format_on_save": {
                "external": {
                    "command": "ruff",
                    "arguments": [
                        "format",
                        "--stdin-filename",
                        "{buffer_path}"
                    ]
                }
            }
        }
    },

[luccahuguet]

this worked for formatting

  "languages": {
    "Python": {
      "formatter": {
        "external": {
          "command": "ruff",
          "arguments": ["format", "-"]
        }
      },
      "format_on_save": "on"
    }
  }

[radupotop]

this worked for me

[skewty]

How do I get Ruff errors / linting integrated? Will that require an extension? If so, has work started on one? Got a URL for the project (or will it be done 1st party)?

[luccahuguet]

It's here

#7808

[acsardars]

hello!
I am replicating that but no formatting happens when saving!
any idea why?

for example, if I do:
x= 1 it is not formatted into
x = 1

Thanks!

PS: This is my settings.json file

{
  "theme": "Andromeda",
  "vim_mode": true,
  "ui_font_size": 16,
  "buffer_font_size": 14,
  "buffer_font_family": "0xProto Nerd Font Mono",
  "language_overrides": {
    "Python": {
      "format_on_save": {
        "external": {
          "command": "ruff",
          "arguments": [
            "check",
            "--exit-zero",
            "--fix",
            "--stdin-filename",
            "{buffer_path}",
            "-"
          ]
        }
      }
    }
  }
}

[Digit4lSh4d0w]

Hi, I'm new to this whole zed thing and its setup. After reading some of the comments here, I stopped understanding what was going on.

Ruff has two versions of the lsp server, the one written in Python — ruff-lsp and the one written in Rust — ruff server --preview. The zed website says that the editor supports working with lsp. What is the problem? What is the reason we can't use ruff?

I'm sorry for my English, it's not my native language.

[v3ss0n]

We need Ruff LSP + Pyright support

[bersace]

I wrote a custom ruff-combi script:

#!/bin/bash
# Usage: ruff-combi file.py < file.py
set -eu
ruff --quiet check --exit-zero --fix --stdin-filename "$1" - \
| ruff format --stdin-filename "$1" -

Used like this:

{
  "languages": {
    "Python": {
      "formatter": {
        "external": {
          "command": "ruff-combi",
          "arguments": ["{buffer_path}"]
...

This combines import sorting and formatting.

I'd prefer a pylsp base solution with python-lsp-ruff. See #7296

[v3ss0n]

I agree , Ruff + PYright LSP gonna be good

[adorabilis]

You don't need a custom script if you use a shell as the command, -c as the first argument, and the rest of your ruff commands as the second argument. Here's what I have:

{
  "languages": {
    "Python": {
      "formatter": {
        "external": {
          "command": "zsh",
          "arguments": ["-c", "ruff check --select I --fix - | ruff format -"]
        }
      }
    }
  }
}

[bersace]

Why don't you need {buffer_path} ?

[adorabilis]

When using an external command, the buffer is passed into the program on stdin. - is a shorthand for stdin so {buffer_path} is not needed.

[Tom-Boscher]

I'm a bit confused now since the release of the 0.146
Why the difference between formatter and format_on_save? Why format_on_save is not just a boolean to activate/deactivate the format on save?

  "languages": {
    "Python": {
      "format_on_save": { "language_server": { "name": "ruff" } },
      "formatter": { "language_server": { "name": "ruff" } },
      "language_servers": ["pyright", "ruff"]
    }
  }

I would like to sort import too when I save my file, how can I setup this with the new Zed language settings?

[lucaspar]

at least regarding the imports sorting, you need to call the linter with the rule set I: ruff check --select I --fix. The examples above show how to combine both as a formatter.external.arguments field.

Edit: not sure if this approach is compatible with v0.146, but I'd expect so.

[adorabilis]

format_on_save can be on or off (edit: I'm on Zed 0.145.1). See my reply to the comment before yours for import sorting and formatting with ruff.

[bersace]

Using 0.146.0 on Linux.

First, you need to install zed ruff extension before using ruff language server.
Beware you need ruff 0.5.5 or you'll hit missing --preview argument.

ruff extension does not sort imports.

[dhruvmanila]

We've added a setup guide for using the Ruff extension in Zed at https://docs.astral.sh/ruff/editors/setup/#zed.

It includes example configuration:

• For providing server settings
• Running the formatter, organizing imports, and fixing all auto-fixable violations on save

[drcongo]

Amazing, thanks @dhruvmanila. I still can't get pyright to sod off and mind its own business though 😭

[bersace]

My per-project configuration:

$ cat pyrightconfig.json
{
  "venvPath": "dev",
  "venv": "venv-py3.6",
  "pythonVersion": "3.6",
  "typeCheckingMode": "off"
}

[timonviola]

@bersace really useful, thanks for sharing!

I spent a good 15 minutes, trying to figure out why pyright lingers and ruff is not complaining.
I restarted Zed and everything works 🥳

[davidagold]

👋 I'm trying to configure the Ruff extension, but the language server doesn't seem to work. It is not available in the debug: open language server logs panel. I have ruff==0.5.7 installed in a local project .venv and my global Zed settings include

"Python": {
    "language_servers": ["ruff", "pyright"],
    "format_on_save": "on",
    "formatter": [
        {
            "code_actions": {
                "source.organizeImports.ruff": true,
                "source.fixAll.ruff": true
            }
        },
        {
            "language_server": {
                "name": "ruff"
            }
        }
    ]
}

Any help would be appreciated. Thank you 🙏

[majutsushi]

I have the same issue (on Linux); I use the standard configuration above but none of the LSP features work. Formatting doesn't happen whether on save or by manually running the "format" command. I also don't get any diagnostics.

Formatting works fine if I configure Ruff as an external formatter instead of using the LSP server.

I did some investigating by setting RUFF_TRACE=verbose and using lsp-devtools to record the interaction between Zed and Ruff.

The only trace I'm seeing in Zed is this:

   0.002322186s DEBUG ThreadId(04) ruff_server::session::index::ruff_settings: Ignored path via `exclude`: /home/jan/.bin/.git
   0.002531623s DEBUG ThreadId(07) ruff_server::session::index::ruff_settings: Ignored path via `exclude`: /home/jan/.bin/.ruff_cache
   0.009749753s  INFO ruff:main ruff_server::server: Configuration file watcher successfully registered

This is the recording when running the "organize imports" action, but note that no organizing is actually happening:

18:50:47 CLIENT {
                  "jsonrpc": "2.0",
                  "id": 3,
                  "method": "codeAction/resolve",
                  "params": {
                    "title": "Ruff: Organize imports",
                    "kind": "source.organizeImports.ruff",
                    "data": "file:///home/jan/.bin/screensaver-inhibit"
                  }
                }
18:50:47 SERVER {
                  "jsonrpc": "2.0",
                  "id": 3,
                  "result": {
                    "data": "file:///home/jan/.bin/screensaver-inhibit",
                    "edit": {
                      "documentChanges": []
                    },
                    "kind": "source.organizeImports.ruff",
                    "title": "Ruff: Organize imports"
                  }
                }

And this is the recording when running the format command in Zed, again with no formatting actually happening:

18:52:24 CLIENT {
                  "jsonrpc": "2.0",
                  "id": 7,
                  "method": "textDocument/formatting",
                  "params": {
                    "textDocument": {
                      "uri": "file:///home/jan/.bin/screensaver-inhibit"
                    },
                    "options": {
                      "tabSize": 4,
                      "insertSpaces": true,
                      "trimTrailingWhitespace": true,
                      "insertFinalNewline": true,
                      "trimFinalNewlines": true
                    }
                  }
                }
18:52:24 SERVER {
                  "jsonrpc": "2.0",
                  "id": 7,
                  "result": null
                }

[majutsushi]

I should mention that this is with Zed 0.151.1 and Ruff 0.6.4, installed globally with pipx.

[radupotop]

I'm using the same settings, which seem to work fine for me:

zed 0.151.1-1, ruff 0.6.4

  "languages": {
    // https://docs.astral.sh/ruff/editors/setup/#zed
    "Python": {
      "format_on_save": "on",
      "formatter": [
        {
          "code_actions": {
            "source.organizeImports.ruff": true,
            "source.fixAll.ruff": true
          }
        },
        {
          "language_server": {
            "name": "ruff"
          }
        }
      ],
      "language_servers": ["pyright", "ruff"]
    }
  }

The only difference i see is pyright coming before ruff.

Edit: This is on Linux with ruff and pyright being available in the $PATH, but also have the ruff extension installed in zed.

[davidagold]

@dhruvmanila My evaluation that this configuration doesn't work is based on

1. Running editor: format doesn't do anything
2. Examining the language server debug logs I do not see any hint of the Ruff LSP functioning. There is no entry for it.

[majutsushi]

Okay, I finally discovered what the problem is. It is this issue: astral-sh/ruff#12539. In short, the Ruff server doesn't check files that don't have .py extension, and I was editing scripts without an extension the entire time. The same problem happens in VS Code.

This is really unintuitive and essentially means that you can't use the Ruff server for extension-less scripts unless you change the include setting to include all files, which is obviously not desirable.

[MatthewScholefield]

If you enable ruff as the language server, at least from what I can tell right now, it removes go-to-definition support.

For anyone else who wants to retain this while still getting ruff's formatting, here's the latest config to do this (basically @davidagold 's but without ruff in the language_servers field):

{
    "languages": {
        "Python": {
            "language_servers": ["pyright"], // Probably optional, but just to be explicit
            "format_on_save": "on",
            "formatter": [
                {
                    "code_actions": {
                        "source.organizeImports.ruff": true,
                        "source.fixAll.ruff": true
                    }
                },
                {
                    "language_server": {
                        "name": "ruff"
                    }
                }
            ]
        }
    }
}

Note that this of course requires also installing the ruff extension in the extensions panel.

[trpubz]

this needs to be documented somewhere on zed or ruff's pages...
so help me understand what's going on here...the new ruff claims to be backed by an LSP and when I say LSP I mean autocompletes, contextual knowledge (methods, modules, etc) and most importantly goto definition; not the linting and formatting. I have uninstalled ruff-lsp and only have ruff in both the project env and globally, but in my buffers, i cannot goto definitions unless pyright is the first option in the "language_servers" which tells me that pyright is handling the LSP functions and ruff is handling the linting...if this is a poor understanding, does anyone have proof that ruff is supposed to be LSPing?

my environment: ruff v0.7.0, i'm running zed v0.159.6, and have the latest ruff extension v0.1.0...here's my settings file

"languages": {
    "Python": {
      "language_servers": ["pyright", "ruff"],
      "format_on_save": "on",
      "formatter": [
        {
          "code_actions": {
            // Fix all auto-fixable lint violations
            "source.fixAll.ruff": true,
            // Organize imports
            "source.organizeImports.ruff": true
          }
        },
        {
          "language_server": {
            "name": "ruff"
          }
        }
      ]
    }
  },
"lsp": {
    "ruff": {
      "initialization_options": {
        "settings": {
          "path": "./pyproject.toml"
        }
      }
    }
  }

but when ruff is listed first, goto definition does not work.

One interesting thing to note is that trying to run the command ruff server fails when trying to run from within my project .venv with this output ruff failed Cause: disconnected channel...my assumption is this command failing coincides with ruff not providing the LSP features.. but not sure what zed is doing in the background to start the LSP server and why it wouldn't show that the server isn't working. When I run the command ps aux | grep ruff shows that a ruff server is running but not from within the .venv but globally, here, ~/.pyenv/versions/3.8.16/bin/ruff server

curious if anyone has any thoughts on how to configure this correctly, maybe zed doesn't know where my ruff server is running? or maybe I need to shut down the external server and somehow force zed to init the server by itself so it has the context for it??? idk

[dhruvmanila]

So, LSP is just a protocol to communicate between the editor and the language server. The things that you're referring to "autocompletes, contextual knowledge (methods, modules, etc) and most importantly goto definition" are capabilities that the server provides. A language server can implement the protocol but not provide all the capabilities which doesn't mean that the server isn't implementing the protocol, but it's just not providing all the capabilities that are supported by the protocol.

This is the case for Ruff where it implements the Language Server Protocol but only provides certain capabilities because the implementation of Ruff only supports those capabilities. These are mentioned in https://docs.astral.sh/ruff/editors/features/ and in terms of LSP they are text document synchronization, notebook document synchronization, and from language features we support hover (although in a limited sense), diagnostics (both pull and push), code actions, formatting, range formatting, and couple of workspace features.

but when ruff is listed first, goto definition does not work.

Regarding your issue of the language server order, I'm not sure why is this the case but it might be worth opening an issue (if it doesn't exists already) for it as Ruff doesn't support goto definition and doesn't advertise it in the capabilities either.

One interesting thing to note is that trying to run the command ruff server fails when trying to run from within my project .venv with this output ruff failed Cause: disconnected channel...my assumption is this command failing coincides with ruff not providing the LSP features..

That's not true. Invoking ruff server just starts the server and listens for any incoming messages. So, even if you run the command without any client attached to it, there shouldn't be any failure as seen in the video below:

Screen.Recording.2024-11-01.at.10.45.36.AM.mov

[jay-joshy]

Zed version: 0.151.2
I freshly downloaded the ruff extension on Zed's extension panel, but the settings below did not work for me:

"languages": {
    "Python": {
      "language_servers": ["pyright", "ruff"],
      "format_on_save": "on",
      "formatter": [
        {
          "code_actions": {
            "source.organizeImports.ruff": true
            //"source.fixAll.ruff": false
          }
        },
        {
          "language_server": {
            "name": "ruff"
          }
        }
      ]
    }
  },
  "lsp": {
    "pyright": {
      "settings": {
        "python.analysis": {
          "diagnosticMode": "workspace",
          "typeCheckingMode": "strict"
        },
        "python": {
          "pythonPath": ".venv/bin/python"
        }
      }
    },
    "ruff": {
      "initialization_options": {
        "settings": {
          // Ruff server settings goes here
          "lineLength": 80,
          "lint": {
            "extendSelect": ["I"]
          }
        }
      }
    }
  }

However, when I brew installed ruff it all started to work!

[dhruvmanila]

I think Zed does install the ruff binary if one doesn't exists as per the code:

zed/extensions/ruff/src/ruff.rs

Lines 50 to 117 in e64a86c

	zed::set_language_server_installation_status(
	language_server_id,
	&zed::LanguageServerInstallationStatus::CheckingForUpdate,
	);
	let release = zed::latest_github_release(
	"astral-sh/ruff",
	zed::GithubReleaseOptions {
	require_assets: true,
	pre_release: false,
	},
	)?;
	let (platform, arch) = zed::current_platform();
	let asset_stem = format!(
	"ruff-{arch}-{os}",
	arch = match arch {
	zed::Architecture::Aarch64 => "aarch64",
	zed::Architecture::X86 => "x86",
	zed::Architecture::X8664 => "x86_64",
	},
	os = match platform {
	zed::Os::Mac => "apple-darwin",
	zed::Os::Linux => "unknown-linux-gnu",
	zed::Os::Windows => "pc-windows-msvc",
	}
	);
	let asset_name = format!(
	"{asset_stem}.{suffix}",
	suffix = match platform {
	zed::Os::Windows => "zip",
	_ => "tar.gz",
	}
	);
	let asset = release
	.assets
	.iter()
	.find(|asset| asset.name == asset_name)
	.ok_or_else(|| format!("no asset found matching {:?}", asset_name))?;
	let version_dir = format!("ruff-{}", release.version);
	let binary_path = match platform {
	zed::Os::Windows => format!("{version_dir}/ruff.exe"),
	_ => format!("{version_dir}/{asset_stem}/ruff"),
	};
	if !fs::metadata(&binary_path).map_or(false, |stat| stat.is_file()) {
	zed::set_language_server_installation_status(
	language_server_id,
	&zed::LanguageServerInstallationStatus::Downloading,
	);
	let file_kind = match platform {
	zed::Os::Windows => zed::DownloadedFileType::Zip,
	_ => zed::DownloadedFileType::GzipTar,
	};
	zed::download_file(&asset.download_url, &version_dir, file_kind)
	.map_err(|e| format!("failed to download file: {e}"))?;
	let entries =
	fs::read_dir(".").map_err(|e| format!("failed to list working directory {e}"))?;
	for entry in entries {
	let entry = entry.map_err(|e| format!("failed to load directory entry {e}"))?;
	if entry.file_name().to_str() != Some(&version_dir) {
	fs::remove_dir_all(entry.path()).ok();
	}
	}
	}

.

[v3ss0n]

That is how it works for most linters

…

On Tue, Sep 10, 2024, 11:08 AM Jan Larres ***@***.***> wrote: Okay, I finally discovered what the problem is. It is this issue: astral-sh/ruff#12539 <astral-sh/ruff#12539>. In short, the Ruff server doesn't check files that don't have .py extension, and I was editing scripts without an extension the entire time. The same problem happens in VS Code. This is really unintuitive and essentially means that you can't use the Ruff server for extension-less scripts unless you change the include setting to include all files, which is obviously not desirable. — Reply to this email directly, view it on GitHub <#6669 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AADGOFWAT5RJLSIVCDLH77DZVZWDRAVCNFSM6AAAAABCOLZQQKVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTANJZG43TMNA> . You are receiving this because you commented.Message ID: ***@***.***>

[gryevns]

My current setup uses a poetry environment with ruff installed as a dev dependency and ruff config in pyproject.toml which makes it easy to run a lint action on CI.

Using Zed is it possible to use the installed version of ruff within my active poetry environment to format code on save and respect the config in pyproject.toml?

[dhruvmanila]

Regardless of where Ruff is installed, it should pickup the config from the project's pyproject.toml if there's a tool.ruff section in it. Does it not do that?

[gryevns]

I haven't managed to get any combination of settings working with this setup, if you could point me in the right direction I would be grateful!

[nrminor]

Can anyone spot anywhere in my Zed configuration that would lead to getting no in-editor Ruff lints?

"Python": {
        "language_servers": ["ruff", "pyright"],
        "lsp": {
            "pyright": {
                "initialization_options": {
                    "settings": {
                        "python.analysis": {
                            "diagnosticMode": "workspace",
                            "typeCheckingMode": "strict"
                        }
                    }
                }
            },
            "ruff": {
                "initialization_options": {
                    "settings": {
                        "lineLength": 88,
                        "showSyntaxErrors": true,
                        "lint": {
                            "select": ["ALL"],
                            "ignore": ["D", "S101"]
                        }
                    }
                }
            }
        }

I've installed the Ruff Zed extension, brew installed ruff, and am working with the latest version of Zed. Ultimately, I'm trying to recreate these VSCode settings:

  "[python]": {
    "editor.defaultFormatter": "charliermarsh.ruff",
    "editor.codeActionsOnSave": {
      "source.fixAll.ruff": "explicit",
      "source.organizeImports.ruff": "explicit"
    }
  },
  "ruff.lineLength": 88,
  "ruff.lint.select": ["ALL"],
  "ruff.lint.ignore": ["D", "S101", "E501"],
  "ruff.nativeServer": "on",

Any advice would be much appreciated! This is frankly one of the main reasons I keep falling back to VSCode for my mostly python day job.

[dhruvmanila]

I think the hierarchy of the settings isn't correct or outdated with the latest version. So, the "Python", "language_servers", and "lsp" should be like:

{
	"languages": {
		"Python": {
			"language_servers": [ ... ]
		}
	},
	"lsp": {
		"pyright": { ... },
		"ruff": { ... }
	}
}

[nrminor]

Ah! That was it—I was nesting "lsp": { ... } inside of "languages: { "Python": { ... } } instead of of placing it at the top-level of the settings (where, coincidentally, I already had rust-analyzer settings in the right place).

Everything with the Ruff language server now works beautifully. For anyone else running into similar issues, here are the python-specific parts of my Zed user settings:

{

    "lsp": {
        "ruff": {
            "initialization_options": {
                "settings": {
                    "lineLength": 88,
                    "showSyntaxErrors": true,
                    "lint": {
                        "select": ["ALL"],
                        "ignore": ["D", "S101", "E501"]
                    }
                }
            }
        }
    },

        "Python": {
            "language_servers": ["ruff", "pyright"],
            "formatter": [
                {
                    "code_actions": {
                        "source.organizeImports.ruff": true,
                        "source.fixAll.ruff": true
                    }
                },
                {
                    "language_server": {
                        "name": "ruff"
                    }
                }
            ]
        }
    }

}

Thanks for your help, @dhruvmanila!

[simlal]

Yeah I basically have the same thing but with pyright as primary lsp and ruff for formatting. Only issue I have is changeing the source.organizeImports.ruff code actions either to true or false doesn't change the behavior, meaning it always fixes the imports on save. I haven't tried with cli ruff + .toml config to check if the behavior is the same.

"languages": {
        "Python": {
            "language_servers": ["pyright", "ruff"],
            "format_on_save": "on",
            "formatter": [
                {
                    "code_actions": {
                        "source.organizeImports.ruff": false,
                        "source.fixAll.ruff": true
                    }
                },
                {
                    "language_server": {
                        "name": "ruff"
                    }
                }
            ],
            "show_inline_completions": false
        },
},
"lsp": {
        "ruff": {
            "initialization_options": {
                "settings": {
                    // Ruff server settings goes here

                    "lineLength": 120
                    // "lint": {
                    //     "extendSelect": ["I"]
                    // }
                }
            }
        }
}

Not a big issue since all I wanted was ruff fixAll on save and do get the import checks as well.

[simlal]

Ahh never mind Just tested that and it works for the import organize action. My bad