Порівняти коміти

..
Автор SHA1 Повідомлення Дата
l0ng-ai 6d777382fd fix(ui): paint tree row tints as full-width bands
File colours, excluded folders and data source colours were painted as the
row's own background: inset from the tree's edges, rounded per row (file
colours) and dropped under hover and selection (data sources), so a run of
tinted rows read as a ragged stack instead of one block. The tint is now a
full-width band under the row; hover and selection stay rounded on top.
Excluded folders and data source colours use the same rowTint path.
2026-11-16 11:16:43 +08:00
80 змінених файлів з 236 додано та 2248 видалено

No files matched your search

+5 -20
Переглянути файл
@@ -134,10 +134,7 @@ fn codex_meta(line: &serde_json::Value) -> Option<(String, Option<String>)> {
let payload =
line.get("payload").filter(|p| p.get("type").and_then(serde_json::Value::as_str) == Some("session_meta"));
let inner = payload.and_then(|p| p.get("payload")).or_else(|| {
line.get("type")
.and_then(serde_json::Value::as_str)
.filter(|t| *t == "session_meta")
.map(|_| line.get("payload").unwrap_or(line))
line.get("type").and_then(serde_json::Value::as_str).filter(|t| *t == "session_meta").and(Some(line))
})?;
let id = inner.get("id").and_then(serde_json::Value::as_str)?.to_owned();
let cwd = inner.get("cwd").and_then(serde_json::Value::as_str).map(str::to_owned);
@@ -296,28 +293,16 @@ mod tests {
assert_eq!(sessions[0].title, "hello there");
}
#[test]
fn codex_meta_accepts_current_and_legacy_shapes() {
let meta = json!({"id": "thread-1", "cwd": "/work/app"});
for line in [
json!({"type": "session_meta", "payload": meta}),
json!({"payload": {"type": "session_meta", "payload": meta}}),
json!({"type": "session_meta", "id": "thread-1", "cwd": "/work/app"}),
] {
assert_eq!(codex_meta(&line), Some(("thread-1".to_owned(), Some("/work/app".to_owned()))));
}
}
#[test]
fn lists_codex_rollouts_with_meta() {
let tmp = tempfile::tempdir().unwrap();
write(
&tmp.path().join("sessions/2026/01/02/rollout-01.jsonl"),
&[
json!({"timestamp": "t", "type": "session_meta",
"payload": {"id": "thread-1", "cwd": "/work/app"}}),
json!({"timestamp": "t", "type": "event_msg",
"payload": {"type": "user_message", "message": "add tests"}}),
json!({"timestamp": "t", "payload": {"type": "session_meta",
"payload": {"id": "thread-1", "cwd": "/work/app"}}}),
json!({"timestamp": "t", "payload": {"type": "user_message",
"payload": {"message": "add tests"}}}),
],
);
write(&tmp.path().join("sessions/notes.jsonl"), &[json!({"nope": true})]);
+1 -3
Переглянути файл
@@ -14,8 +14,7 @@ pub fn inside_git_repo(dir: &Path) -> bool {
dir.ancestors().any(|d| d.join(".git").exists() || d.join(".jj").exists())
}
/// IDEA's default list, plus `.jj`, rope's `.ropeproject` (pylsp-rope creates it in the
/// project root) and the Windows shell files.
/// IDEA's default list, plus `.jj` and the Windows shell files.
pub const DEFAULT_IGNORED_NAMES: &[&str] = &[
"*.pyc",
"*.pyo",
@@ -26,7 +25,6 @@ pub const DEFAULT_IGNORED_NAMES: &[&str] = &[
".git",
".hg",
".jj",
".ropeproject",
".svn",
"CVS",
"__pycache__",
-3
Переглянути файл
@@ -1347,9 +1347,6 @@ pub struct JavaSettings {
pub jdtls_vm_args: String,
/// Share one JDT LS across builds in an ordinary project window; other windows remain separate.
pub jdtls_shared: bool,
/// JDK homes added by hand (Platform Settings › SDKs › Add JDK from Disk…), listed with the
/// detected ones.
pub added_jdks: Vec<String>,
/// Build Tools › Maven.
pub maven: MavenSettings,
/// Build Tools › Gradle.
+3 -10
Переглянути файл
@@ -1244,18 +1244,11 @@ impl DebugManager {
// rdbg's terminate exits the Ruby process without terminating its children.
let graceful =
terminate && s.request == "launch" && s.adapter != "rdbg" && s.supports("supportsTerminateRequest");
// A program suspended in the debugger cannot act on SIGTERM, and on macOS not even die of
// SIGKILL while the debugger holds it: it is killed (with what it started) and the adapter
// is told to end it. A killed program has no shutdown output to wait for.
let killed = own_terminate && !graceful && s.suspended.get();
if killed {
crate::session::signal_debuggee(s, true).await;
}
if !s.conn.is_closed() {
if graceful {
let _ = s.conn.request_timeout("terminate", json!({ "restart": false }), SHUTDOWN_TIMEOUT).await;
}
if !graceful && (!own_terminate || killed) {
if !graceful && !own_terminate {
let _ = s
.conn
.request_timeout(
@@ -1266,7 +1259,7 @@ impl DebugManager {
.await;
}
}
if own_terminate && !graceful && !killed {
if own_terminate && !graceful {
// Signal before anything else: waiting on a request the adapter may not answer
// would delay the shutdown the console is supposed to show.
crate::session::signal_debuggee(s, false).await;
@@ -1285,7 +1278,7 @@ impl DebugManager {
// lets Run start again into an occupied port, so wait for the program first — with the
// connection still open, so a second Stop can find the session and kill it.
crate::session::wait_for_debuggee(s, terminate).await;
if terminate && s.request == "launch" && !killed {
if terminate && s.request == "launch" {
// The adapter reports `terminated` only after it has drained the program's console
// (java-debug waits up to 5 s for the pump): closing before that drops the last
// shutdown lines from the console.
-46
Переглянути файл
@@ -527,14 +527,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
}
}
"disconnect" => {
// Like Delve: the adapter ends the program it launched.
#[cfg(unix)]
if msg["arguments"]["terminateDebuggee"] == true
&& let Some(pid) = script.debuggee_pid
{
// SAFETY: plain syscall on the test's own child process.
unsafe { libc::kill(pid as i32, libc::SIGKILL) };
}
ok!(msg, Value::Null);
let _ = w.lock().await.shutdown().await;
break;
@@ -2327,44 +2319,6 @@ async fn stop_waits_for_the_launched_program_to_exit() {
h.wait_event(|e| matches!(e, DebugEvent::Terminated)).await;
}
/// Delve and other adapters without `terminate`: a program stopped at a breakpoint cannot
/// handle the SIGTERM Stop sends, so Stop has the adapter end it instead of waiting out the grace period.
#[cfg(unix)]
#[tokio::test]
async fn stop_kills_a_program_suspended_at_a_breakpoint_at_once() {
let mut child = std::process::Command::new("python3")
.args(["-c", "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(30)"])
.spawn()
.unwrap();
let pid = child.id();
let exited = Arc::new(AtomicBool::new(false));
{
let exited = exited.clone();
std::thread::spawn(move || {
let _ = child.wait();
exited.store(true, Ordering::Release);
});
}
let h = harness(Script { debuggee_pid: Some(pid), supports_terminate: false, ..Default::default() });
let id = h.start(config()).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
let session = h.manager.session(id).unwrap();
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
tokio::time::sleep(Duration::from_millis(200)).await; // let the program install its trap
let started = Instant::now();
h.manager.stop(id).await.unwrap();
let elapsed = started.elapsed();
assert!(elapsed < Duration::from_secs(3), "stop waited {elapsed:?} for a suspended program");
assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], true);
let deadline = Instant::now() + Duration::from_secs(2);
while !exited.load(Ordering::Acquire) {
assert!(Instant::now() < deadline, "the suspended program was left running");
tokio::time::sleep(Duration::from_millis(10)).await;
}
}
#[cfg(unix)]
#[tokio::test]
async fn a_second_stop_kills_the_program_instead_of_waiting() {
-9
Переглянути файл
@@ -190,7 +190,6 @@ impl Host {
open_locks: Default::default(),
};
host.apply_proxy();
host.apply_added_jdks();
ops::agent::move_user_mcp_values(&host);
host
}
@@ -565,11 +564,3 @@ mod tests {
host.close_project("main");
}
}
impl Host {
/// Lists the JDKs added by hand (global Settings › SDKs) with the detected ones.
pub fn apply_added_jdks(&self) {
let homes = self.global_settings.effective().languages.java.added_jdks;
ide_sdk::java::set_added_jdks(homes.into_iter().map(PathBuf::from));
}
}
-3
Переглянути файл
@@ -232,9 +232,6 @@ pub fn set_settings(
if key == "ssh" || key.starts_with("ssh.") {
host.ssh.set_configs(host.global_settings.effective().ssh.configs);
}
if key == "languages" || key == "languages.java" || key.starts_with("languages.java.addedJdks") {
host.apply_added_jdks();
}
if is_proxy {
host.apply_proxy();
}
-14
Переглянути файл
@@ -37,9 +37,6 @@ pub struct ProjectInterpreter {
pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<Vec<Sdk>> {
host.require_trust(window)?;
let project = host.project(window).ok();
if kind == SdkKind::Jdk {
host.apply_added_jdks();
}
let root = project.as_ref().map(|p| p.root.clone());
// The interpreter the project uses is a choice even where detection doesn't look (a
// virtualenv in a subfolder, one picked by path), so it shows by name and version.
@@ -375,20 +372,9 @@ pub async fn sdk_python_pip(
result?
}
/// The JDK whose home is `path` (a macOS bundle too), as the SDK list shows it; `None` when
/// `path` is no JDK home (Add JDK from Disk…).
pub async fn sdk_jdk_at(path: String) -> IdeResult<Option<Sdk>> {
tokio::task::spawn_blocking(move || {
ide_sdk::java::jdk_at(std::path::Path::new(&path)).map(|j| ide_sdk::jdk_sdk(&j))
})
.await
.map_err(join_err)
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("sdk_detect", |c| async move { sdk_detect(&c.host, &c.window, c.arg("kind")?).await });
d.add("sdk_jdk_at", |c| async move { sdk_jdk_at(c.arg("path")?).await });
d.add(
"sdk_python_project_interpreters",
|c| async move { sdk_python_project_interpreters(&c.host, &c.window).await },
+3 -8
Переглянути файл
@@ -677,14 +677,9 @@ impl Shared {
}
let previous =
self.setting_snapshots.lock().insert((client.map(str::to_owned), pkg.id().into()), current.clone());
match previous {
// First contact since the plugin loaded (fresh install, update,
// re-enable): hand over every current key, so the synthetic
// post-install `settings-changed` wakes the plugin instead of being
// dropped for having no diff yet.
None => current.into_keys().collect(),
Some(old) => current.into_iter().filter(|(k, v)| old.get(k) != Some(v)).map(|(k, _)| k).collect(),
}
previous
.map(|old| current.into_iter().filter(|(k, v)| old.get(k) != Some(v)).map(|(k, _)| k).collect())
.unwrap_or_default()
}
pub fn status_snapshot(&self, client: &str) -> Vec<super::PluginStatusItem> {
+2 -39
Переглянути файл
@@ -144,7 +144,7 @@ impl Host {
let lsp = LspManager::new(root.clone(), languages.clone(), sink.clone());
crate::plugins::injections::configure_lsp(&lsp);
lsp.set_execution_allowed(trusted.load(Ordering::Acquire));
lsp.set_content_roots(language_server_roots(&root, extra_roots.clone()));
lsp.set_content_roots(extra_roots.clone());
lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
&root,
&settings.effective().languages.java.maven.linked_projects,
@@ -1224,7 +1224,7 @@ impl Project {
return;
}
let (roots, excludes) = (self.content_roots(), self.exclude_globs());
self.lsp.set_content_roots(language_server_roots(&self.root, roots.clone()));
self.lsp.set_content_roots(roots.clone());
self.lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
&self.root,
&self.settings.effective().languages.java.maven.linked_projects,
@@ -1369,22 +1369,6 @@ fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cac
extra_content_roots(settings, root, build_cache)
}
/// The content roots plus the projects attached inside this one. The index covers those
/// already, but each is a project of its own (a git worktree under the project, a nested
/// Cargo workspace), so its files get a language server rooted there, not at this root.
fn language_server_roots(root: &Path, mut roots: Vec<PathBuf>) -> Vec<PathBuf> {
if let Ok(Some(workspace)) = ide_workspace::workspace::Workspace::load(root)
&& !workspace.is_container(root)
{
for path in workspace.projects {
if path != root && path.starts_with(root) && !roots.contains(&path) {
roots.push(path);
}
}
}
roots
}
/// The roots a file may navigate into: its own root (the workspace member containing it, or
/// the project root) plus that root's configured dependencies. A workspace member depends
/// only on the roots picked per member in Project Structure › Dependencies —
@@ -2179,25 +2163,4 @@ mod content_roots_tests {
let roots = content_roots(&settings, &root, &tmp.path().join("build"));
assert_eq!(roots, vec![shared, dep]);
}
#[test]
fn projects_attached_inside_the_root_get_their_own_language_server_root() {
let tmp = tempfile::tempdir().unwrap();
let ws = dunce::canonicalize(tmp.path()).unwrap();
let (root, nested, other) = (ws.join("app"), ws.join("app/.wt/feature"), ws.join("other"));
for dir in [&nested, &other] {
std::fs::create_dir_all(dir).unwrap();
}
let settings = ide_core::settings::Settings::default();
let build = ws.join("build");
assert!(super::language_server_roots(&root, content_roots(&settings, &root, &build)).is_empty());
ide_workspace::workspace::Workspace::attach(&root, "app", vec![root.clone(), nested.clone(), other.clone()])
.unwrap();
// The index walks the nested project as part of the root ...
let roots = content_roots(&settings, &root, &build);
assert_eq!(roots, vec![other.clone()]);
// ... while its files go to a language server of its own.
assert_eq!(super::language_server_roots(&root, roots), vec![other, nested]);
}
}
+2 -26
Переглянути файл
@@ -6271,15 +6271,10 @@ fn api14_settings_and_input_events_use_other_and_capture_the_editor() {
assert!(f.host.wait_events(Duration::from_secs(5)));
let received: serde_json::Value = serde_json::from_str(&f.run("api14", "events", None).unwrap().unwrap()).unwrap();
let events = received.as_array().unwrap();
assert_eq!(events.len(), 4, "{received}");
// The first synthetic post hands over the current keys ("enabled": false);
// the second is a real diff to true. Keys come from the recomputed
// snapshot, never from the event payload ("another-plugin-key").
assert_eq!(events.len(), 3, "{received}");
assert_eq!(events[0]["kind"], "settings-changed");
assert_eq!(events[0]["data"], "[\"enabled\"]");
assert_eq!(events[1]["kind"], "settings-changed");
assert_eq!(events[1]["data"], "[\"enabled\"]");
assert_eq!(events[3]["kind"], "input-mode-changed");
assert_eq!(events[2]["kind"], "input-mode-changed");
assert_eq!(events[2]["editor"][0], path);
assert_eq!(events[2]["editor"][1][0], serde_json::json!([0, 0, 0, 0]));
}
@@ -7021,22 +7016,3 @@ fn the_language_server_grant_needs_api_1_9() {
let err = f.host.install_from_dir(&pkg, &Consent::all()).unwrap_err();
assert!(err.message.contains("new in plugin API 1.9"), "{err:?}");
}
/// The UI's synthetic post-install `SettingsChanged([])` reaches a plugin that
/// subscribes to `on-event:settings-changed`, though it carries no keys.
#[test]
fn a_freshly_installed_plugin_gets_the_post_install_settings_event() {
let f = fixture(Limits::default());
f.install(&sample("api14"));
use ide_plugin::WorkbenchEvent as E;
// What refreshEventKinds() posts right after commandsChanged (install).
f.host.post_events(Some("main"), vec![E::SettingsChanged(Vec::new())]);
f.host.flush_events_at(Instant::now() + Duration::from_secs(2));
assert!(f.host.wait_events(Duration::from_secs(5)));
let received: serde_json::Value = serde_json::from_str(&f.run("api14", "events", None).unwrap().unwrap()).unwrap();
let events = received.as_array().unwrap();
assert!(
events.iter().any(|e| e["kind"] == "settings-changed"),
"freshly installed plugin got no post-install event: {received}"
);
}
+2 -15
Переглянути файл
@@ -679,7 +679,7 @@ mod tests {
let got: Vec<(&str, bool)> = cfg
.language_servers
.iter()
.filter(|s| !s.require_root_marker && s.features.is_empty())
.filter(|s| !s.require_root_marker)
.map(|s| (s.name.as_str(), s.fallback))
.collect();
let expected: Vec<(&str, bool)> = servers.iter().enumerate().map(|(i, name)| (*name, i > 0)).collect();
@@ -779,26 +779,13 @@ mod tests {
assert_eq!(served("lib/src/Parser.php"), None);
}
#[test]
fn pylsp_adds_only_rope_refactorings_to_python() {
let reg = reg();
let cfg = reg.get(&LanguageId::new("python")).unwrap();
let pylsp = cfg.language_servers.iter().find(|s| s.name == "pylsp").unwrap();
assert!(!pylsp.fallback && !pylsp.require_root_marker);
assert_eq!(pylsp.features, ["code-action"]);
assert_eq!(pylsp.code_action_kinds, ["refactor"]);
let plugins = pylsp.initialization_options.as_ref().unwrap()["pylsp"]["plugins"].as_table().unwrap();
assert_eq!(plugins["jedi_completion"]["enabled"].as_bool(), Some(false));
assert!(plugins.values().all(|p| p["enabled"].as_bool() == Some(false)));
}
#[test]
fn ruff_serves_python_files_only_below_its_config() {
let reg = reg();
let cfg = reg.get(&LanguageId::new("python")).unwrap();
let names: Vec<&str> = cfg.language_servers.iter().map(|s| s.name.as_str()).collect();
// After the fallbacks: hover, rename and symbols stay with the type checker.
assert_eq!(names, ["basedpyright", "pyright", "ty", "pyrefly", "ruff", "pylsp"]);
assert_eq!(names, ["basedpyright", "pyright", "ty", "pyrefly", "ruff"]);
let ruff = cfg.language_servers.iter().find(|s| s.name == "ruff").unwrap();
assert_eq!((ruff.command.as_str(), ruff.args.as_slice()), ("ruff", ["server".to_string()].as_slice()));
assert!(ruff.require_root_marker && !ruff.fallback);
-2
Переглянути файл
@@ -885,8 +885,6 @@ pub fn jdk_sdk(j: &crate::java::Jdk) -> Sdk {
"JAVA_HOME"
} else if crate::java::is_downloaded(&j.home) {
"downloaded"
} else if crate::java::is_added(&j.home) {
"added"
} else {
version_managers::manager_of(&j.home).unwrap_or("system")
};
-41
Переглянути файл
@@ -138,26 +138,6 @@ pub fn add_jdk_root(dir: &Path) {
}
}
/// JDK homes added by hand (Settings › SDKs › Add JDK from Disk…).
static ADDED: Mutex<Vec<PathBuf>> = Mutex::new(Vec::new());
/// Sets the JDK homes added by hand; the next scan lists them (a change drops the cached scan).
pub fn set_added_jdks(homes: impl IntoIterator<Item = PathBuf>) {
let homes: Vec<PathBuf> = homes.into_iter().filter(|h| !h.as_os_str().is_empty()).collect();
let mut added = ADDED.lock().unwrap_or_else(|e| e.into_inner());
if *added != homes {
*added = homes;
drop(added);
*JDKS.lock().unwrap_or_else(|e| e.into_inner()) = None;
}
}
/// Whether `home` is a JDK added by hand.
pub fn is_added(home: &Path) -> bool {
let added = ADDED.lock().unwrap_or_else(|e| e.into_inner());
added.iter().any(|h| jdk_at(h).is_some_and(|j| j.home == home))
}
/// Whether `home` lies in a folder registered with [`add_jdk_root`].
pub fn is_downloaded(home: &Path) -> bool {
let roots = EXTRA_ROOTS.lock().unwrap_or_else(|e| e.into_inner());
@@ -210,7 +190,6 @@ fn scan() -> Vec<Jdk> {
for (dir, _) in ide_core::version_managers::installs(ide_core::version_managers::Tool::Java) {
homes.extend([dir.join("Contents/Home"), dir]);
}
homes.extend(ADDED.lock().unwrap_or_else(|e| e.into_inner()).iter().cloned());
let mut out: Vec<Jdk> = Vec::new();
for h in homes {
if let Some(jdk) = jdk_at(&h)
@@ -1385,26 +1364,6 @@ mod tests {
assert!(is_downloaded(&home) && !is_downloaded(Path::new("/elsewhere")));
}
#[test]
fn jdks_added_by_hand_are_listed_until_removed() {
let tmp = tempfile::tempdir().unwrap();
// A macOS bundle picked as its folder: listed by its `Contents/Home`.
let bundle = tmp.path().join("odd place/my-jdk.jdk");
let home = bundle.join("Contents/Home");
std::fs::create_dir_all(home.join("bin")).unwrap();
std::fs::write(home.join("release"), "JAVA_VERSION=\"17.0.9\"\nIMPLEMENTOR=\"Acme\"\n").unwrap();
std::fs::write(home.join("bin").join(crate::exe("java")), "").unwrap();
let home = dunce::canonicalize(&home).unwrap();
set_added_jdks([bundle.clone()]);
assert!(installed_jdks().iter().any(|j| j.home == home && j.major == 17));
assert!(is_added(&home));
let sdk = crate::jdk_sdk(&jdk_at(&bundle).unwrap());
assert_eq!((sdk.name.as_str(), sdk.source.as_str()), ("Acme 17.0.9", "added"));
set_added_jdks(Vec::new());
assert!(!installed_jdks().iter().any(|j| j.home == home));
assert!(!is_added(&home));
}
#[test]
fn jdtls_runs_on_the_chosen_server_jdk() {
let fixtures = tempfile::tempdir().unwrap();
+2 -50
Переглянути файл
@@ -92,10 +92,6 @@ pub struct ToolInfo {
/// The interchangeable servers this one belongs to, in preference order: a
/// server and the `fallback` ones after it. Empty when it has none.
pub alternatives: Vec<String>,
/// A language server used for part of what its languages need (`features` in its
/// definition: pylsp-rope's refactorings next to basedpyright). Not offered for install
/// when missing; the Language Servers page lists it.
pub companion: bool,
}
/// Streamed install progress.
@@ -335,7 +331,6 @@ struct Usage {
args: Vec<String>,
initialization_options: Option<String>,
alternatives: Vec<String>,
companion: bool,
}
fn usages(langs: &[LanguageConfig]) -> BTreeMap<String, Usage> {
@@ -369,11 +364,6 @@ fn usages(langs: &[LanguageConfig]) -> BTreeMap<String, Usage> {
add(name, &d.command, ToolKind::Debugger, d.install_hint.as_ref(), &l.name);
}
}
for s in langs.iter().flat_map(|l| &l.language_servers).filter(|s| !s.features.is_empty()) {
if let Some(u) = map.get_mut(&s.name) {
u.companion = true;
}
}
for (plugin, host) in registry::PLUGIN_HOSTS {
let languages = map.get(*host).map(|u| u.languages.clone()).unwrap_or_default();
map.entry(plugin.to_string()).or_default().languages = languages;
@@ -759,7 +749,6 @@ impl Tools {
default_args: u.args.clone(),
default_initialization_options: u.initialization_options.clone(),
alternatives: u.alternatives.clone(),
companion: u.companion,
})
.map(|info| self.apply_custom(info, None));
};
@@ -786,7 +775,6 @@ impl Tools {
default_args: usage.map(|u| u.args.clone()).unwrap_or_default(),
default_initialization_options: usage.and_then(|u| u.initialization_options.clone()),
alternatives: usage.map(|u| u.alternatives.clone()).unwrap_or_default(),
companion: usage.is_some_and(|u| u.companion),
})
.map(|info| self.apply_custom(info, Some(spec)))
}
@@ -1268,42 +1256,6 @@ impl Tools {
Err(IdeError::new(ErrorKind::Io, format!("pip install {package} failed ({status})")))
}
/// A command running pip, before its arguments. The interpreter's own pip when it has one;
/// a virtualenv made by uv has none, so then pip through `uv tool run`, or another Python
/// on `PATH` that has it.
fn pip_command(&self, python: PathBuf, emit: Emit) -> Command {
let has_pip = |python: &Path| {
let mut c = self.python_command(python);
c.args(["-m", "pip", "--version"]);
run_quiet(c, Duration::from_secs(20)).is_some_and(|(ok, _)| ok)
};
let module = |python: &Path| {
let mut c = self.python_command(python);
c.args(["-m", "pip"]);
c
};
if has_pip(&python) {
return module(&python);
}
let note = format!("{} has no pip", python.display());
if let Some(uv) = self.which("uv") {
emit(InstallEvent::Line { text: format!("{note}; running pip with uv") });
// pip runs in uv's own Python: the same private working directory applies.
let mut c = self.python_command(uv);
c.args(["tool", "run", "pip"]);
return c;
}
let other = ["python3", "python"]
.into_iter()
.filter_map(|name| ide_core::tool_path::find_command(name, &self.system_path, &self.root))
.find(|p| *p != python && has_pip(p));
if let Some(other) = other {
emit(InstallEvent::Line { text: format!("{note}; using {}", other.display()) });
return module(&other);
}
module(&python)
}
/// The universal (`py3-none-any`) wheel, so the copy works with every interpreter
/// version a project selects, not just the one that installed it.
fn install_pip_target(
@@ -1317,8 +1269,8 @@ impl Tools {
let _ = std::fs::remove_dir_all(&dir);
let lib = python_lib_dir(&self.root, spec.name);
std::fs::create_dir_all(&lib)?;
let mut c = self.pip_command(self.python().expect("checked"), emit);
c.args(["install", "--disable-pip-version-check", "--no-deps", "--upgrade", "--target"])
let mut c = self.python_command(self.python().expect("checked"));
c.args(["-m", "pip", "install", "--disable-pip-version-check", "--no-deps", "--upgrade", "--target"])
.arg(&lib)
.args(["--only-binary=:all:", "--platform", "any", "--implementation", "py"])
.arg(package);
-11
Переглянути файл
@@ -289,17 +289,6 @@ pub static TOOLS: &[ToolSpec] = &[
homepage: "https://docs.astral.sh/ty/",
needs: &[],
},
ToolSpec {
name: "pylsp",
display: "pylsp-rope (Python refactorings)",
kind: LanguageServer,
commands: &["pylsp"],
method: Method::PipVenv { package: "pylsp-rope" },
fallback: None,
version: ver("pylsp"),
homepage: "https://github.com/python-rope/pylsp-rope",
needs: &[],
},
ToolSpec {
name: "pyrefly",
display: "Pyrefly (Python)",
-51
Переглянути файл
@@ -380,7 +380,6 @@ fn install_joined_after_it_finished_returns_the_result() {
default_args: vec![],
default_initialization_options: None,
alternatives: vec![],
companion: false,
};
release_install_slot("marksman", &slot);
slot.finish(Ok(ok));
@@ -896,14 +895,9 @@ esac
}
}
/// Installs of one tool name share a process-wide slot: tests installing debugpy take turns.
#[cfg(unix)]
static DEBUGPY_INSTALL: parking_lot::Mutex<()> = parking_lot::Mutex::new(());
#[cfg(unix)]
#[test]
fn selected_python_is_used_for_pip_and_uv_even_with_a_versioned_filename() {
let _guard = DEBUGPY_INSTALL.lock();
let env = Env::new();
env.script(&env.sys, "python3", "exit 99");
let sdk = env._tmp.path().join("python-sdk");
@@ -941,51 +935,6 @@ exit 1
assert!(args.contains(&format!("--python {}", sdk.join("python3.14").display())), "{args}");
}
/// A virtualenv made by uv has no pip: debugpy's private copy is made with pip through uv.
#[cfg(unix)]
#[test]
fn debugpy_installs_through_uv_when_the_selected_python_has_no_pip() {
let _guard = DEBUGPY_INSTALL.lock();
let env = Env::new();
let venv = env._tmp.path().join("project/.venv/bin");
env.script(&venv, "python", "echo \"$(basename \"$0\"): No module named pip\" >&2; exit 1");
let log = env._tmp.path().join("uv.log");
env.script(
&env.sys,
"uv",
&format!(
r#"
echo "$@" >> '{log}'
while [ $# -gt 0 ]; do
if [ "$1" = "--target" ]; then
/bin/mkdir -p "$2/debugpy" "$2/debugpy-1.8.0.dist-info"
/usr/bin/touch "$2/debugpy/__init__.py"
exit 0
fi
shift
done
exit 1
"#,
log = log.display()
),
);
let tools = env.tools().with_runtime(BTreeMap::from([("python".into(), venv.join("python"))]), BTreeMap::new());
let lines = Mutex::new(Vec::new());
let info = tools
.install("debugpy", &langs(), &CancellationToken::new(), &|e| {
if let InstallEvent::Line { text } = e {
lines.lock().push(text);
}
})
.unwrap();
assert_eq!(info.status, ToolStatus::Installed);
assert_eq!(info.version.as_deref(), Some("1.8.0"));
let args = fs::read_to_string(log).unwrap();
assert!(args.starts_with("tool run pip install "), "{args}");
assert!(args.contains("--platform any"), "{args}");
assert!(lines.lock().iter().any(|l| l.contains("has no pip")));
}
#[test]
fn a_cancelled_install_leaves_the_previous_one_in_place() {
let tmp = tempfile::tempdir().unwrap();
+1 -2
Переглянути файл
@@ -1159,8 +1159,7 @@ impl Repo {
write::stage_patch(self, patch, &|path| encoding(path).map(Into::into))
}
/// Discards unstaged changes: tracked paths are restored from the index (staged
/// changes are kept), untracked files and directories are deleted. A submodule goes back
/// to the commit the index records, with its tracked files restored.
/// changes are kept), untracked files and directories are deleted.
pub fn discard(&self, paths: &[PathBuf]) -> IdeResult<()> {
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
write::discard(self, paths)
+6 -9
Переглянути файл
@@ -25,19 +25,16 @@ pub(crate) fn save(r: &Repo, message: &str) -> IdeResult<()> {
if run(r.root(), &["status", "--porcelain", "--untracked-files=no"], None)?.stdout_str().trim().is_empty() {
return Ok(());
}
let before = stash_top(r);
let before = run(r.root(), &["rev-parse", "-q", "--verify", "refs/stash"], None).map(|o| o.stdout_str()).ok();
run(r.root(), &["stash", "push", "-q", "-m", message], None)?;
// A stash that succeeds without a new entry found nothing it saves: the status above also
// lists submodules at another commit or with changes inside, which a stash leaves in place.
let Some(id) = stash_top(r).filter(|id| Some(id) != before.as_ref()) else { return Ok(()) };
std::fs::write(marker, id)?;
let id = run(r.root(), &["rev-parse", "refs/stash"], None)?.stdout_str();
if before.as_deref().map(str::trim) == Some(id.trim()) {
return Err(IdeError::invalid("could not save the local changes"));
}
std::fs::write(marker, id.trim())?;
Ok(())
}
fn stash_top(r: &Repo) -> Option<String> {
run(r.root(), &["rev-parse", "-q", "--verify", "refs/stash"], None).ok().map(|o| o.stdout_str().trim().to_owned())
}
/// Brings the saved changes back once no operation is in progress. Fails when they come
/// back with conflicts (they then also stay in the stash).
pub(crate) fn restore(r: &Repo) -> IdeResult<()> {
+6 -17
Переглянути файл
@@ -391,24 +391,18 @@ pub(crate) fn discard(r: &Repo, paths: &[PathBuf]) -> IdeResult<()> {
let rel = r.rel_paths(paths)?;
// `git restore --worktree` refuses unmerged paths: roll those back to HEAD first.
discard_unmerged(r, &rel)?;
let (mut tracked, mut untracked, mut submodules) = (Vec::new(), Vec::new(), Vec::new());
let (mut tracked, mut untracked) = (Vec::new(), Vec::new());
{
let repo = r.gix()?;
let index = repo.index_or_empty().map_err(gx)?;
for p in rel {
let exact = index.entry_index_by_path(BStr::new(p.as_bytes())).ok().map(|i| &index.entries()[i]);
let exact = index.entry_index_by_path(BStr::new(p.as_bytes())).is_ok();
let dir_prefix = if p == "." { String::new() } else { format!("{}/", p.trim_end_matches('/')) };
let children = index.prefixed_entries(BStr::new(dir_prefix.as_bytes()));
if let Some(entry) = exact {
if entry.mode.is_submodule() {
submodules.push(p);
} else {
tracked.push(p);
}
let has_tracked_children = index.prefixed_entries(BStr::new(dir_prefix.as_bytes())).is_some();
if exact {
tracked.push(p);
} else if r.abs_path(&p).is_dir() {
if let Some(children) = children {
submodules
.extend(children.iter().filter(|e| e.mode.is_submodule()).map(|e| e.path(&index).to_string()));
if has_tracked_children {
tracked.push(p.clone());
}
untracked.push(p);
@@ -418,11 +412,6 @@ pub(crate) fn discard(r: &Repo, paths: &[PathBuf]) -> IdeResult<()> {
}
}
run_paths(r, &["restore", "--worktree"], &tracked)?;
// A plain restore leaves a submodule alone. This one checks out the commit the index
// records there and restores its tracked files, keeping its untracked ones.
if crate::execution_allowed() {
run_paths(r, &["restore", "--recurse-submodules", "--worktree"], &submodules)?;
}
if !untracked.is_empty() {
// `git clean` keeps ignored files and refuses paths outside the worktree.
run_paths(r, &["clean", "-f", "-d", "-q"], &untracked)?;
+1 -69
Переглянути файл
@@ -69,8 +69,7 @@ impl Fixture {
fn push_from_other(&self, bare: &Path, rel: &str, content: &str) {
let other = self.tmp.path().join(format!("other-{}", rel.replace('/', "_")));
if !other.exists() {
let (bare, other_dir) = (bare.to_str().unwrap(), other.to_str().unwrap());
git_in(self.tmp.path(), &["clone", "-q", "-c", "core.autocrlf=false", bare, other_dir]);
git_in(self.tmp.path(), &["clone", "-q", bare.to_str().unwrap(), other.to_str().unwrap()]);
configure(&other);
}
git_in(&other, &["pull", "-q", "--rebase"]);
@@ -637,73 +636,6 @@ fn update_with_rebase_keeps_a_file_added_then_deleted_added_to_the_index() {
assert!(fx.git(&["status", "--porcelain", "--", "ad.txt"]).starts_with('A'), "still added");
}
/// Submodules `dirty` and `moved` (each with commits "one" and "two", at "two") committed in
/// the clone of [`Fixture::with_origin`] and pushed; then `dirty` gets an uncommitted edit of a
/// tracked file plus an untracked file, and `moved` is checked out at "one". Returns the commit
/// the superproject records for `moved`.
fn with_changed_submodules(fx: &Fixture) -> String {
for name in ["dirty", "moved"] {
let lib = fx.tmp.path().join(format!("lib-{name}"));
std::fs::create_dir(&lib).unwrap();
git_in(&lib, &["init", "-q"]);
configure(&lib);
std::fs::write(lib.join("f.txt"), "one\n").unwrap();
git_in(&lib, &["add", "-A"]);
git_in(&lib, &["commit", "-q", "-m", "one"]);
std::fs::write(lib.join("f.txt"), "two\n").unwrap();
git_in(&lib, &["commit", "-q", "-am", "two"]);
let url = lib.to_str().unwrap();
fx.git(&["-c", "protocol.file.allow=always", "-c", "core.autocrlf=false", "submodule", "add", "-q", url, name]);
configure(&fx.path(name));
}
fx.commit_all("submodules");
fx.git(&["push", "-q", "origin", "main"]);
let recorded = git_in(&fx.path("moved"), &["rev-parse", "HEAD"]);
fx.write("dirty/f.txt", "edited\n");
fx.write("dirty/untracked.txt", "u\n");
git_in(&fx.path("moved"), &["checkout", "-q", "HEAD~1"]);
recorded
}
/// git lists submodules at another commit or with changes inside among the superproject's
/// changes, but its stash leaves them in place, so Update Project has nothing to put aside (#3632).
#[test]
fn update_with_changed_submodules_and_no_other_local_changes() {
for (rebase, earlier_stash) in [(false, false), (false, true), (true, false), (true, true)] {
let (fx, bare) = Fixture::with_origin();
let recorded = with_changed_submodules(&fx);
if earlier_stash {
fx.write("a.txt", "stashed\n");
fx.git(&["stash", "push", "-q", "-m", "earlier"]);
}
fx.push_from_other(&bare, "remote.txt", "r\n");
let repo = fx.repo();
let (cancel, out) = quiet();
repo.pull(rebase, &cancel, &out).unwrap_or_else(|e| panic!("rebase={rebase} stash={earlier_stash}: {e}"));
assert!(fx.exists("remote.txt"));
assert_eq!(fx.read("dirty/f.txt"), "edited\n");
assert_ne!(git_in(&fx.path("moved"), &["rev-parse", "HEAD"]), recorded);
let stashes = fx.git(&["stash", "list"]);
assert_eq!(stashes.lines().count(), usize::from(earlier_stash), "{stashes}");
assert!(!fx.dir.join(".git/openidea-saved-changes").exists());
}
}
#[test]
fn rollback_changed_submodules_restores_the_recorded_commit_and_tracked_files() {
for whole_root in [false, true] {
let (fx, _bare) = Fixture::with_origin();
let recorded = with_changed_submodules(&fx);
let repo = fx.repo();
let paths = if whole_root { vec![fx.dir.clone()] } else { vec![fx.path("dirty"), fx.path("moved")] };
repo.discard(&paths).unwrap();
assert_eq!(fx.read("dirty/f.txt"), "two\n", "whole_root={whole_root}");
assert_eq!(git_in(&fx.path("moved"), &["rev-parse", "HEAD"]), recorded);
assert_eq!(fx.read("dirty/untracked.txt"), "u\n", "untracked files of a submodule are kept");
assert_eq!(fx.git(&["status", "--porcelain", "--ignore-submodules=untracked"]), "");
}
}
#[test]
fn reset_to_the_remote_branch_drops_local_commits_and_keeps_local_changes() {
let (fx, bare) = Fixture::with_origin();
+8 -60
Переглянути файл
@@ -441,26 +441,13 @@ impl SettingsStore {
#[serde(rename_all = "camelCase")]
pub struct JetBrainsSettings {
pub entries: Vec<String>,
/// Entry name → text, for the files OpenIDEA reads: `colors/*.icls`, `keymaps/*.xml`,
/// `codestyles/*.xml` and some of `options/`.
/// Entry name → text, for `colors/*.icls` and the `options/*.xml` files OpenIDEA reads.
pub files: BTreeMap<String, String>,
}
const JETBRAINS_MARKER: &str = "IntelliJ IDEA Global Settings";
const JETBRAINS_OPTIONS: [&str; 9] = [
"options/editor-font.xml",
"options/terminal-font.xml",
"options/colors.scheme.xml",
"options/code.style.schemes.xml",
"options/editor.xml",
"options/ide.general.xml",
// The active keymap is stored per operating system.
"options/mac/keymap.xml",
"options/windows/keymap.xml",
"options/linux/keymap.xml",
];
/// Folders whose files are all read: (folder, extension).
const JETBRAINS_READ_DIRS: [(&str, &str); 3] = [("colors/", ".icls"), ("keymaps/", ".xml"), ("codestyles/", ".xml")];
const JETBRAINS_OPTIONS: [&str; 4] =
["options/editor-font.xml", "options/colors.scheme.xml", "options/editor.xml", "options/ide.general.xml"];
const JETBRAINS_MAX_TEXT: u64 = 4 << 20;
/// The settings of a JetBrains IDE: an exported `settings.zip`, or the IDE's own settings folder
@@ -471,23 +458,11 @@ pub fn read_jetbrains_settings(path: &Path) -> IdeResult<JetBrainsSettings> {
fn is_mapped_jetbrains_file(name: &str) -> bool {
JETBRAINS_OPTIONS.contains(&name)
|| JETBRAINS_READ_DIRS
.iter()
.any(|(dir, ext)| name.strip_prefix(dir).is_some_and(|n| !n.contains('/') && n.ends_with(ext)))
|| name.strip_prefix("colors/").is_some_and(|n| !n.contains('/') && n.ends_with(".icls"))
}
/// Folders of the settings folder whose files are listed (their names say what the user customised).
const JETBRAINS_LISTED_DIRS: [&str; 9] = [
"options",
"options/mac",
"options/windows",
"options/linux",
"colors",
"keymaps",
"codestyles",
"templates",
"inspection",
];
const JETBRAINS_LISTED_DIRS: [&str; 6] = ["options", "colors", "keymaps", "codestyles", "templates", "inspection"];
fn read_jetbrains_folder(dir: &Path) -> IdeResult<JetBrainsSettings> {
use std::io::Read;
@@ -961,25 +936,11 @@ mod tests {
("options/editor-font.xml", "<application/>"),
("options/vcs.xml", "<application/>"),
("keymaps/macOS.xml", "<keymap/>"),
("keymaps/nested/ignored.xml", "<keymap/>"),
("codestyles/Default.xml", "<code_scheme/>"),
("options/mac/keymap.xml", "<application/>"),
("options/terminal-font.xml", "<application/>"),
],
);
let read = read_jetbrains_settings(&ok).unwrap();
assert_eq!(read.entries.len(), 9);
assert_eq!(
read.files.keys().collect::<Vec<_>>(),
[
"codestyles/Default.xml",
"colors/_@user_Darcula.icls",
"keymaps/macOS.xml",
"options/editor-font.xml",
"options/mac/keymap.xml",
"options/terminal-font.xml"
]
);
assert_eq!(read.entries.len(), 5);
assert_eq!(read.files.keys().collect::<Vec<_>>(), ["colors/_@user_Darcula.icls", "options/editor-font.xml"]);
assert!(read_jetbrains_settings(&write("other.zip", &[("options/editor.xml", "")])).is_err());
std::fs::write(tmp.path().join("plain.zip"), "not a zip").unwrap();
assert!(read_jetbrains_settings(&tmp.path().join("plain.zip")).is_err());
@@ -998,31 +959,18 @@ mod tests {
put("colors/nested/ignored.icls", "<scheme/>");
put("options/editor-font.xml", "<application/>");
put("options/vcs.xml", "<application/>");
put("options/mac/keymap.xml", "<application/>");
put("keymaps/macOS.xml", "<keymap/>");
put("codestyles/Default.xml", "<code_scheme/>");
put("plugins/Tools/lib/tools.jar", "jar");
let read = read_jetbrains_settings(&config).unwrap();
assert_eq!(
read.files.keys().collect::<Vec<_>>(),
[
"codestyles/Default.xml",
"colors/_@user_Darcula.icls",
"keymaps/macOS.xml",
"options/editor-font.xml",
"options/mac/keymap.xml"
]
);
assert_eq!(read.files.keys().collect::<Vec<_>>(), ["colors/_@user_Darcula.icls", "options/editor-font.xml"]);
assert_eq!(
read.entries,
[
"options/editor-font.xml",
"options/vcs.xml",
"options/mac/keymap.xml",
"colors/_@user_Darcula.icls",
"keymaps/macOS.xml",
"codestyles/Default.xml",
"installed.txt"
]
);
-83
Переглянути файл
@@ -819,86 +819,3 @@ test("keeps ordered, bulleted and task list markers unclipped inside measured ro
expect(cb.offsetFromRowLeft).toBeGreaterThanOrEqual(0);
}
});
test("indents process-run thoughts and tool calls clearly and aligns output-less tool icons", async ({ page }) => {
await openReply(page, "All checks passed.");
await page.evaluate(async (task) => {
const storePath = "/src/features/agents/store.ts";
const store = await import(storePath);
store.useAgents.setState({
tasks: new Map([[task.id, { ...task, status: "running" as const }]]),
entries: new Map([
[
task.id,
[
{ type: "thought", text: "**Checking CI Status**\n\nInspecting workflow runs." },
{
type: "tool",
id: "t1",
title: "gh pr checks 3631 --repo l0ng-ai/openidea",
kind: "execute",
status: "completed",
locations: [],
output: "All checks pending",
diffs: [],
},
{ type: "thought", text: "**Tracking Continuous Integration**\n\nWaiting for E2E." },
{
type: "tool",
id: "t2",
title: "read_bash",
kind: "other",
status: "completed",
locations: [],
output: "E2E pass",
diffs: [],
},
{
type: "tool",
id: "t3",
title: "read_bash",
kind: "other",
status: "running",
locations: [],
output: "",
diffs: [],
},
],
],
]),
});
store.openTaskInEditorLocation(task.id);
}, TASK);
const stream = page.locator("[class*='_stream_']:visible");
const summary = stream.locator("[class*='_processSummary_']").first();
await summary.click();
await expect(stream.getByText("Checking CI Status")).toBeVisible();
const layout = await stream.evaluate((root) => {
const summaryChevron = root.querySelector<SVGElement>("[class*='_processChevron_']")!.getBoundingClientRect();
const processBody = root.querySelector<HTMLElement>("[class*='_processBody_']")!.getBoundingClientRect();
const thoughtChevron = root.querySelector<SVGElement>("[class*='_thoughtChevron_']")!.getBoundingClientRect();
const toolRows = [...root.querySelectorAll<HTMLElement>("[class*='_tool_']")];
const expandableToolChevron = toolRows[0]!
.querySelector<SVGElement>("[class*='_toolChevron_']")!
.getBoundingClientRect();
const completedReadIcon = [...toolRows[1]!.querySelectorAll("svg")].at(-1)!.getBoundingClientRect();
const runningReadIcon = toolRows[2]!.querySelector("svg")!.getBoundingClientRect();
return {
summaryChevronCenter: summaryChevron.left + summaryChevron.width / 2,
guideLeft: processBody.left,
summaryToThoughtIndent: thoughtChevron.left - summaryChevron.left,
thoughtToToolIndent: expandableToolChevron.left - thoughtChevron.left,
iconLeftDiff: Math.abs(completedReadIcon.left - runningReadIcon.left),
};
});
// Guide line drops from the center of the process summary chevron.
expect(Math.abs(layout.guideLeft - layout.summaryChevronCenter)).toBeLessThanOrEqual(1.5);
// Thoughts indent clearly inside the process run, and tool calls indent under their thought step.
expect(layout.summaryToThoughtIndent).toBeGreaterThanOrEqual(20);
expect(layout.thoughtToToolIndent).toBeGreaterThanOrEqual(14);
// Output-less running tool rows align their kind icon with expandable tool rows.
expect(layout.iconLeftDiff).toBeLessThanOrEqual(1);
});
-33
Переглянути файл
@@ -59,39 +59,6 @@ root-markers = ["ruff.toml", ".ruff.toml", "pyproject.toml#tool.ruff"]
require-root-marker = true
install-hint = "pip install ruff (or: uv tool install ruff)"
# Refactorings only (Extract Method / Variable, Inline, Introduce Parameter) from rope,
# next to the type checker: pylsp's own completion, hover, linting and formatting
# stay off, and its other code actions (quick fixes on every line) are dropped.
[[language-servers]]
name = "pylsp"
command = "pylsp"
features = ["code-action"]
code-action-kinds = ["refactor"]
root-markers = ["pyproject.toml", "setup.py", "setup.cfg", "requirements.txt", "Pipfile"]
install-hint = "pip install pylsp-rope (or: uv tool install python-lsp-server --with pylsp-rope)"
[language-servers.initialization-options.pylsp.plugins]
autopep8 = { enabled = false }
flake8 = { enabled = false }
folding = { enabled = false }
jedi_completion = { enabled = false }
jedi_definition = { enabled = false }
jedi_highlight = { enabled = false }
jedi_hover = { enabled = false }
jedi_references = { enabled = false }
jedi_rename = { enabled = false }
jedi_signature_help = { enabled = false }
jedi_symbols = { enabled = false }
mccabe = { enabled = false }
preload = { enabled = false }
pycodestyle = { enabled = false }
pydocstyle = { enabled = false }
pyflakes = { enabled = false }
pylint = { enabled = false }
rope_autoimport = { enabled = false }
rope_completion = { enabled = false }
yapf = { enabled = false }
[debugger]
adapter = "debugpy"
command = "python3"
-4
Переглянути файл
@@ -36,10 +36,6 @@ body,
opacity: 0;
pointer-events: none;
}
/* A question asked while the window opens (Trust Project?) shows over the splash (platform/splash.ts). */
.splash.splash-under-dialogs {
z-index: calc(var(--z-dialog, 900) - 1);
}
:root[data-theme^="dark"] .splash {
color: var(--fg-muted, var(--boot-fg, #8c8f95));
}
-1
Переглянути файл
@@ -489,7 +489,6 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
sdk::sdk_python_interpreter,
sdk::sdk_python_effective,
sdk::sdk_php_effective,
sdk::sdk_jdk_at,
sdk::sdk_container_python,
sdk::sdk_container_python_refresh,
sdk::sdk_php_xdebug,
-7
Переглянути файл
@@ -17,13 +17,6 @@ pub async fn sdk_detect(window: Window, state: State<'_, AppState>, kind: SdkKin
ide_host::ops::sdk::sdk_detect(&state.host, window.label(), kind).await
}
/// The JDK whose home is `path`, as the SDK list shows it; `None` when it is no JDK home.
#[tauri::command]
#[specta::specta]
pub async fn sdk_jdk_at(path: String) -> IdeResult<Option<Sdk>> {
ide_host::ops::sdk::sdk_jdk_at(path).await
}
/// The Python interpreters of the recently opened projects, each with its project.
#[tauri::command]
#[specta::specta]
+1 -7
Переглянути файл
@@ -330,13 +330,7 @@ pub fn menu_model(app: AppHandle, state: State<'_, AppState>, menu_state: State<
/// disabled in place (no rebuild).
#[tauri::command]
#[specta::specta]
pub fn menu_set_disabled(window: WebviewWindow, app: AppHandle, menu_state: State<'_, MenuState>, ids: Vec<String>) {
// The window whose menu runs: a project window also while its Settings window is focused.
if menu::native_menu_bar()
&& windows::target_window(&app).is_some_and(|target| !owns_menu_config(window.label(), target.label()))
{
return;
}
pub fn menu_set_disabled(app: AppHandle, menu_state: State<'_, MenuState>, ids: Vec<String>) {
let disabled: std::collections::HashSet<String> = ids.into_iter().collect();
if *menu_state.disabled.lock() == disabled {
return;
+14 -13
Переглянути файл
@@ -373,24 +373,25 @@ pub(crate) fn dispatch_menu_action(app: &tauri::AppHandle, id: &str) {
let Some(route) = menu::route(&menu::spec(menu::Os::current()), id) else { return };
match windows::target_window(app) {
Some(w) => {
// The window to bring back to the front once what the action shows is closed (Settings).
let mut return_to = None;
let label = match windows::menu_destination(w.label(), &route.action) {
windows::MenuDestination::Own => w.label(),
windows::MenuDestination::Parent { label, raise } => {
if raise && let Some(parent) = app.get_webview_window(label) {
windows::focus(&parent);
return_to = Some(w.label());
}
label
// App-level items of an auxiliary window go to its project window. Settings is modal for it:
// nothing else gets through. Others handle their own items; Close Tab closes the window.
let label = match windows::auxiliary(w.label()) {
Some((_, parent))
if matches!(
route.action.as_str(),
"app.quit" | "file.settings" | "file.projectStructure" | "file.newProjectsSettings"
) =>
{
parent
}
windows::MenuDestination::Close => {
Some((kind, _)) if kind.modal() => return,
Some(_) if route.action == "editor.closeTab" => {
let _ = w.close();
return;
}
_ => w.label(),
};
let event = menu::MenuEvent { route: &route, return_to };
if let Err(e) = app.emit_to(label, menu::MENU_EVENT, &event) {
if let Err(e) = app.emit_to(label, menu::MENU_EVENT, &route) {
tracing::warn!("failed to deliver menu event {id}: {e}");
}
}
-11
Переглянути файл
@@ -904,17 +904,6 @@ pub struct MenuRoute {
pub arg: Option<String>,
}
/// Payload of [`MENU_EVENT`]: the route, and the window that was in front when the item was
/// chosen if the action runs in another one (a Settings window's project window).
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MenuEvent<'a> {
#[serde(flatten)]
pub route: &'a MenuRoute,
#[serde(skip_serializing_if = "Option::is_none")]
pub return_to: Option<&'a str>,
}
/// Maps a clicked item id to the action to run. `None` for ids that are not
/// IDE items (native roles, placeholders).
pub fn route(spec: &[Entry], id: &str) -> Option<MenuRoute> {
+2 -51
Переглянути файл
@@ -360,8 +360,8 @@ impl AuxKind {
self != AuxKind::Settings
}
/// Has no actions of its own: menu items run in its project window.
fn runs_menu_in_parent(self) -> bool {
/// Modal for its parent: menu items other than app-level ones are dropped.
pub fn modal(self) -> bool {
self == AuxKind::Settings
}
@@ -386,34 +386,6 @@ pub fn auxiliary(label: &str) -> Option<(AuxKind, &str)> {
})
}
/// Where a menu item chosen while window `label` is focused runs.
#[derive(Debug, PartialEq, Eq)]
pub enum MenuDestination<'a> {
/// The window's own frontend.
Own,
/// The project window `label`; `raise` brings it to the front so what the action shows is seen.
Parent { label: &'a str, raise: bool },
/// The window itself is the tab: Close Tab closes it.
Close,
}
/// Actions an auxiliary window always leaves to its project window.
const PARENT_ACTIONS: [&str; 4] = ["app.quit", "file.settings", "file.projectStructure", "file.newProjectsSettings"];
/// Where menu item `action` runs while window `label` is focused. As in IDEA, the menu stays usable
/// with Settings open: it runs in the project window, whose enablement (no focused editor) the menu shows.
pub fn menu_destination<'a>(label: &'a str, action: &str) -> MenuDestination<'a> {
match auxiliary(label) {
None => MenuDestination::Own,
Some((_, parent)) if PARENT_ACTIONS.contains(&action) => {
MenuDestination::Parent { label: parent, raise: false }
}
Some((kind, parent)) if kind.runs_menu_in_parent() => MenuDestination::Parent { label: parent, raise: true },
Some(_) if action == "editor.closeTab" => MenuDestination::Close,
Some(_) => MenuDestination::Own,
}
}
/// The project window an auxiliary window belongs to (`settings-main` → `main`).
pub fn auxiliary_parent(label: &str) -> Option<&str> {
auxiliary(label).map(|(_, parent)| parent)
@@ -2377,27 +2349,6 @@ mod tests {
assert_eq!(sorted_labels(labels.into_iter().filter(|l| auxiliary_parent(l).is_none())), ["main", "project-2"]);
}
#[test]
fn menu_items_chosen_in_settings_run_in_its_project_window() {
use MenuDestination::*;
for (label, action, expected) in [
("main", "app.about", Own),
("main", "editor.closeTab", Own),
// #3625: Settings has no actions of its own; the rest of the menu runs in the project window.
("settings-main", "app.checkForUpdates", Parent { label: "main", raise: true }),
("settings-project-2", "file.newFile", Parent { label: "project-2", raise: true }),
("settings-main", "editor.closeTab", Parent { label: "main", raise: true }),
("settings-main", "file.settings", Parent { label: "main", raise: false }),
("settings-main", "app.quit", Parent { label: "main", raise: false }),
("comparison-main-0", "app.quit", Parent { label: "main", raise: false }),
("comparison-main-0", "editor.closeTab", Close),
("diff-main-1", "vcs.diff.next", Own),
("deployment-main", "app.about", Own),
] {
assert_eq!(menu_destination(label, action), expected, "{label} {action}");
}
}
#[test]
fn settings_bounds_fit_current_work_area() {
for (parent, size, work, expected) in [
-1
Переглянути файл
@@ -513,7 +513,6 @@ scaffold_requirements always project_host bin
sdk_container_python trusted project_host bindings sync
sdk_container_python_refresh trusted project_host bindings async
sdk_detect trusted project_host bindings async
sdk_jdk_at trusted project_host bindings async
sdk_locate_tools trusted project_host bindings async
sdk_php_composer_install trusted project_host bindings async
sdk_php_effective trusted project_host bindings sync
+1 -35
Переглянути файл
@@ -1096,26 +1096,6 @@ export const commands = {
sdkPythonEffective: (near: string | null) => typedError<string | null, IdeError>(__TAURI_INVOKE("sdk_python_effective", { near })),
/** The PHP interpreter chosen in Settings › Languages & Frameworks › PHP; `None`: the `php` on `PATH`. */
sdkPhpEffective: () => typedError<string | null, IdeError>(__TAURI_INVOKE("sdk_php_effective")),
/** The JDK whose home is `path`, as the SDK list shows it; `None` when it is no JDK home. */
sdkJdkAt: (path: string) => typedError<{
/**
* Executable (`python`, `node`, `pnpm`) or directory (Rust toolchain bin
* dir, GOROOT, TypeScript `lib` dir) that the setting stores.
*/
path: IpcPath,
/** Display name, e.g. `Python 3.12 (.venv)` or `stable-aarch64-apple-darwin`. */
name: string,
version: string | null,
/**
* Where it was found: `venv` | `system` | `pyenv` | `conda` | `uv` | `nvm` |
* `rustup` | `bundled` | `workspace` | `path` …
*/
source: string,
/** Environment / toolchain root (virtualenv dir, rustup toolchain dir, GOROOT). */
home: IpcPath | null,
/** Rust standard library sources, Go default GOPATH. */
extra: IpcPath | null,
} | null, IdeError>(__TAURI_INVOKE("sdk_jdk_at", { path })),
/** The project interpreter when it is a Docker or Compose run target's, with its snapshot. */
sdkContainerPython: () => typedError<{
/** The run target's id. */
@@ -6740,11 +6720,6 @@ export type JavaSettings = {
jdtlsVmArgs?: string,
/** Share one JDT LS across builds in an ordinary project window; other windows remain separate. */
jdtlsShared?: boolean,
/**
* JDK homes added by hand (Platform Settings › SDKs › Add JDK from Disk…), listed with the
* detected ones.
*/
addedJdks?: string[],
/** Build Tools › Maven. */
maven?: MavenSettings,
/** Build Tools › Gradle. */
@@ -6773,10 +6748,7 @@ export type JdkVendor = {
*/
export type JetBrainsSettings = {
entries: string[],
/**
* Entry name → text, for the files OpenIDEA reads: `colors/*.icls`, `keymaps/*.xml`,
* `codestyles/*.xml` and some of `options/`.
*/
/** Entry name → text, for `colors/*.icls` and the `options/*.xml` files OpenIDEA reads. */
files: { [key in string]: string },
};
@@ -10747,12 +10719,6 @@ export type ToolInfo = {
* server and the `fallback` ones after it. Empty when it has none.
*/
alternatives: string[],
/**
* A language server used for part of what its languages need (`features` in its
* definition: pylsp-rope's refactorings next to basedpyright). Not offered for install
* when missing; the Language Servers page lists it.
*/
companion: boolean,
};
export type ToolKind = "languageServer" | "debugger" |
+1 -2
Переглянути файл
@@ -134,8 +134,7 @@ class LensWidget extends WidgetType {
const guides = this.inline
? null
: guideVars(Math.floor(this.indent / this.indentUnit), this.indentUnit, this.rainbow);
if (!this.inline)
dom.style.paddingLeft = `calc(${LINE_INSET}px + ${this.indent} * var(--openidea-space, ${view.defaultCharacterWidth}px))`;
if (!this.inline) dom.style.paddingLeft = `${Math.round(this.indent * view.defaultCharacterWidth) + LINE_INSET}px`;
if (guides) {
dom.style.setProperty("--openidea-guide-images", guides.images);
dom.style.setProperty("--openidea-guide-positions", guides.positions);
+10 -38
Переглянути файл
@@ -1,4 +1,4 @@
import { afterEach, describe, expect, it, vi } from "vitest";
import { afterEach, describe, expect, it } from "vitest";
import { Compartment, EditorState, type Extension } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { indentUnit } from "@codemirror/language";
@@ -46,25 +46,23 @@ describe("indent guides", () => {
expect(guideVars(1, 4)).toBeNull();
expect(guideVars(3, 4)).toEqual({
images: "var(--openidea-guide), var(--openidea-guide)",
positions: "calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
positions: "calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0",
});
});
it("positions each guide the same way on lines of different depth", () => {
const v = mount(SOURCE);
expect(line(v, 1).classList.contains("cm-openidea-guides")).toBe(false);
expect(line(v, 2).style.getPropertyValue("--openidea-guide-positions")).toBe(
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0",
);
expect(line(v, 2).style.getPropertyValue("--openidea-guide-positions")).toBe("calc(0.5px + 4ch) 0");
expect(line(v, 3).style.getPropertyValue("--openidea-guide-positions")).toBe(
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
"calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0",
);
});
it("keeps guides through blank lines inside a block", () => {
const v = mount(SOURCE);
expect(line(v, 4).style.getPropertyValue("--openidea-guide-positions")).toBe(
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
"calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0",
);
});
@@ -79,9 +77,7 @@ describe("indent guides", () => {
]);
const [implLens, fnLens] = [...v.contentDOM.querySelectorAll<HTMLElement>(".cm-openidea-lens")];
expect(v.contentDOM.classList.contains("cm-openidea-guidesOn")).toBe(true);
expect(fnLens!.style.getPropertyValue("--openidea-guide-positions")).toBe(
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0",
);
expect(fnLens!.style.getPropertyValue("--openidea-guide-positions")).toBe("calc(0.5px + 4ch) 0");
expect(implLens!.style.getPropertyValue("--openidea-guide-positions")).toBe("");
});
});
@@ -140,7 +136,7 @@ describe("rainbow indent guides", () => {
expect(guideVars(1, 4, true)).toBeNull();
expect(guideVars(3, 4, true)).toEqual({
images: "var(--openidea-guide-1), var(--openidea-guide-2)",
positions: "calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
positions: "calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0",
});
const deep = guideVars(8, 2, true)!;
expect(deep.images.split(", ")).toEqual([1, 2, 3, 4, 5, 1, 2].map((n) => `var(--openidea-guide-${n})`));
@@ -160,9 +156,7 @@ describe("rainbow indent guides", () => {
expect(images(line(v, 2))).toBe("var(--openidea-guide-1)");
expect(images(line(v, 3))).toBe("var(--openidea-guide-1), var(--openidea-guide-2)");
expect(images(line(v, 4))).toBe("var(--openidea-guide-1), var(--openidea-guide-2)");
expect(positions(line(v, 4))).toBe(
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
);
expect(positions(line(v, 4))).toBe("calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0");
expect(images(line(v, 6))).toBe("var(--openidea-guide-1)");
});
@@ -176,27 +170,7 @@ describe("rainbow indent guides", () => {
spaces.destroy();
const tabs = mount(body("\t"), [EditorState.tabSize.of(4)], rainbowIndentGuides, "\t");
expect(images(deepest(tabs))).toBe(expected);
expect(positions(deepest(tabs)).split(/, (?=calc)/)[1]).toBe("calc(0.5px + 8 * var(--openidea-space, 1ch)) 0");
});
it("measures a column as the font's space width, so a proportional font keeps guides in the indentation", () => {
const rect = vi.spyOn(HTMLElement.prototype, "getBoundingClientRect").mockImplementation(function (
this: HTMLElement,
) {
const sample = this.textContent ?? "";
const width = /^ +$/.test(sample) ? sample.length * 3.5 : 0;
return { width, height: 0, top: 0, left: 0, right: width, bottom: 0, x: 0, y: 0, toJSON: () => ({}) };
});
try {
const v = mount(SOURCE);
(v as unknown as { measure(): void }).measure();
expect(v.scrollDOM.style.getPropertyValue("--openidea-space")).toBe("3.5px");
v.destroy();
expect(v.scrollDOM.style.getPropertyValue("--openidea-space")).toBe("");
view = undefined;
} finally {
rect.mockRestore();
}
expect(positions(deepest(tabs)).split(", ")[1]).toBe("calc(0.5px + 8ch) 0");
});
it("does not count a partial indent unit as a level", () => {
@@ -237,9 +211,7 @@ describe("rainbow indent guides", () => {
});
const lens = () => view!.contentDOM.querySelector<HTMLElement>(".cm-openidea-lens")!;
expect(images(lens())).toBe("var(--openidea-guide-1), var(--openidea-guide-2)");
expect(positions(lens())).toBe(
"calc(0.5px + 4 * var(--openidea-space, 1ch)) 0, calc(0.5px + 8 * var(--openidea-space, 1ch)) 0",
);
expect(positions(lens())).toBe("calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0");
view.dispatch({ effects: guides.reconfigure(indentGuides) });
expect(images(lens())).toBe("var(--openidea-guide), var(--openidea-guide)");
});
+3 -33
Переглянути файл
@@ -7,9 +7,7 @@
* the smaller level of their neighbours and code lens rows the level of the
* line they annotate (`guideVars`), so guides stay continuous. With rainbow
* guides each depth gets its own image, coloured from `--syn-rainbow-*`. The
* guide the caret is on takes the selected colour (`caretGuide`). A column is
* the editor font's space width (`--openidea-space`, measured), not `ch`: in a
* proportional font a space is narrower than "0", and guides would drift into the code.
* guide the caret is on takes the selected colour (`caretGuide`).
*/
import { countColumn, Facet, RangeSetBuilder, type EditorState, type Extension } from "@codemirror/state";
import { Decoration, EditorView, ViewPlugin, type DecorationSet, type ViewUpdate } from "@codemirror/view";
@@ -19,11 +17,6 @@ import { LINE_INSET } from "./lineInset";
/** How far (px) a guide sits left of its column, so a caret in that column is right of it (IDEA's indent guide shift). */
const GUIDE_SHIFT = 2;
/** One column of indentation: a space in the editor font, as measured by the guides plugin. */
const SPACE = "var(--openidea-space, 1ch)";
const SPACE_SAMPLE = 64;
/** Number of `--openidea-guide-<n>` rainbow colours; deeper guides repeat them. */
export const GUIDE_COLORS = 5;
@@ -57,7 +50,7 @@ export function guideVars(
? `var(--openidea-guide-${((level - 1) % GUIDE_COLORS) + 1})`
: "var(--openidea-guide)",
);
positions.push(`calc(${LINE_INSET - GUIDE_SHIFT}px + ${level * step} * ${SPACE}) 0`);
positions.push(`calc(${LINE_INSET - GUIDE_SHIFT}px + ${level * step}ch) 0`);
}
return { images: images.join(", "), positions: positions.join(", ") };
}
@@ -194,33 +187,10 @@ export const indentGuides: Extension = [
ViewPlugin.fromClass(
class {
decorations: DecorationSet;
private probe: HTMLElement;
constructor(readonly view: EditorView) {
// Inherits the editor font from the scroller, outside the content CodeMirror observes;
// the measured width goes on the scroller, where lines and code lens rows pick it up.
this.probe = document.createElement("span");
this.probe.setAttribute("aria-hidden", "true");
this.probe.style.cssText = "position: absolute; top: 0; left: 0; visibility: hidden; white-space: pre";
this.probe.textContent = " ".repeat(SPACE_SAMPLE);
view.scrollDOM.appendChild(this.probe);
constructor(view: EditorView) {
this.decorations = build(view);
this.measure();
}
measure() {
this.view.requestMeasure({
key: this,
read: (view) => this.probe.getBoundingClientRect().width / (view.scaleX || 1) / SPACE_SAMPLE,
write: (width, view) => {
if (width > 0) view.scrollDOM.style.setProperty("--openidea-space", `${+width.toFixed(3)}px`);
},
});
}
destroy() {
this.probe.remove();
this.view.scrollDOM.style.removeProperty("--openidea-space");
}
update(u: ViewUpdate) {
if (u.geometryChanged) this.measure();
if (
u.docChanged ||
u.selectionSet ||
+1 -34
Переглянути файл
@@ -1,6 +1,5 @@
import { afterEach, describe, expect, it, vi } from "vitest";
import { EditorState, StateEffect } from "@codemirror/state";
import { showTooltip, type Tooltip } from "@codemirror/view";
import { EditorState } from "@codemirror/state";
import { indentUnit, language as languageFacet } from "@codemirror/language";
import { HEAVY_LIMIT, onEditorEvent, registerSaveParticipant, remoteChange, shownAgain } from "@/editor/api";
import { createMemoryBackend, type MemoryBackend } from "../backend";
@@ -17,15 +16,6 @@ const host: SlotHost = {
onContextMenu: () => {},
};
const testTooltip: Tooltip = {
pos: 0,
create: () => {
const dom = document.createElement("div");
dom.className = "test-tab-tooltip";
return { dom };
},
};
async function settle() {
for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
}
@@ -372,29 +362,6 @@ describe("DocumentManager + slots", () => {
manager.stop();
});
it("takes a hidden tab's tooltips off the page with its view, and back when it shows again (#3647)", async () => {
const { manager } = setup({ "/p/a.txt": "abc" });
const model = await manager.acquire("/p/a.txt");
const slot = new EditorSlot(model, "t1", host);
const other = new EditorSlot(model, "t2", host);
const tooltip = () => document.querySelector(".cm-tooltip.test-tab-tooltip");
const view = slot.mount(document.body);
// Any tooltip of the tab (a hint, hover, completion…): they live in `document.body`, outside the view.
view.dispatch({ effects: StateEffect.appendConfig.of(showTooltip.of(testTooltip)) });
expect(tooltip()).not.toBeNull();
slot.unmount();
other.mount(document.body);
expect(tooltip()).toBeNull();
other.unmount();
expect(slot.mount(document.body)).toBe(view);
expect(tooltip()).not.toBeNull();
// Disposing the tab leaves nothing of it in the page.
slot.dispose();
other.dispose();
expect(tooltip()).toBeNull();
manager.stop();
});
it("destroys the least recently hidden views beyond the kept ones, and kept views on dispose", async () => {
const { manager } = setup({ "/p/a.txt": "abc" });
const model = await manager.acquire("/p/a.txt");
+1 -11
Переглянути файл
@@ -20,7 +20,7 @@ import {
type TransactionSpec,
} from "@codemirror/state";
import { historyField } from "@codemirror/commands";
import { EditorView, ViewPlugin, keymap, tooltips, type ViewUpdate } from "@codemirror/view";
import { EditorView, ViewPlugin, keymap, type ViewUpdate } from "@codemirror/view";
import {
_addEditor,
_removeEditor,
@@ -69,11 +69,6 @@ export class EditorSlot {
view: EditorView | null = null;
/** The view kept, detached from the document, while the tab is hidden. */
private kept: EditorView | null = null;
/**
* The tab's tooltips (hints, hover, completion…). They live outside the view, in `document.body`,
* so they leave the page with the view when the tab is hidden instead of floating over the next tab.
*/
private readonly tooltipLayer = typeof document === "undefined" ? null : document.createElement("div");
/** The view's scroll offset, tracked so hiding it needn't read layout. */
private scrollPos = { top: 0, left: 0 };
handle: TextEditorHandle | null = null;
@@ -171,8 +166,6 @@ export class EditorSlot {
}
}),
Prec.highest(keymap.of([{ key: "Escape", run: () => this.host.onEscape?.(this) ?? false }])),
// Ahead of the shared `document.body` parent (the tooltip space still comes from it).
this.tooltipLayer ? Prec.highest(tooltips({ parent: this.tooltipLayer })) : [],
EditorView.domEventObservers({
scroll: (_e, view) => {
if (view === this.view) this.scrollPos = { top: view.scrollDOM.scrollTop, left: view.scrollDOM.scrollLeft };
@@ -207,7 +200,6 @@ export class EditorSlot {
mount(parent: HTMLElement): EditorView {
if (this.view) return this.view;
if (this.tooltipLayer && !this.tooltipLayer.isConnected) document.body.appendChild(this.tooltipLayer);
const kept = this.kept;
let view: EditorView;
if (kept) {
@@ -251,7 +243,6 @@ export class EditorSlot {
this.kept = view;
if (!keep) return this.release();
view.dom.remove();
this.tooltipLayer?.remove();
keptSlots.push(this);
if (keptSlots.length > KEPT_VIEWS) keptSlots.shift()!.release();
}
@@ -267,7 +258,6 @@ export class EditorSlot {
this.scroll = scrollSnapshotAt(view, this.scrollPos);
this.stored = view.state;
view.destroy();
this.tooltipLayer?.remove();
}
dispose() {
+4 -4
Переглянути файл
@@ -74,8 +74,9 @@ export function showHint(
clearTimeout(timers.get(view));
timers.set(
view,
// Also while the view is hidden: it would show the hint again when its tab is shown.
setTimeout(() => hideHint(view), opts.timeout ?? 4000),
setTimeout(() => {
if (view.dom.isConnected && view.state.field(hintField, false)) view.dispatch({ effects: setHint.of(null) });
}, opts.timeout ?? 4000),
);
}
@@ -103,10 +104,9 @@ export function showPendingHint(view: EditorView, content: string): () => void {
}, PENDING_HINT_DELAY_MS);
return () => {
clearTimeout(timer);
// Also when the request ended by opening another tab, which hid this view.
if (shown && view.state.field(hintField, false) === shown) {
clearTimeout(timers.get(view));
hideHint(view);
if (view.dom.isConnected) hideHint(view);
}
};
}
+3 -5
Переглянути файл
@@ -89,13 +89,11 @@ export function cellLspExtensions(ctx: EditorDocContext): Extension[] {
}
/**
* A diff pane showing a file's open document: hover / quick docs, ⌘/Ctrl-click
* navigation and semantic highlighting, so colours match the editor while
* reviewing. Editing features stay with text editors; panes without a document
* (revisions) get nothing from the semantic extension (`docOf` is null).
* A diff pane showing a file's open document: hover / quick docs and ⌘/Ctrl-click navigation,
* so references can be followed while reviewing. Editing features stay with text editors.
*/
export function diffLspExtensions(ctx: EditorDocContext): Extension[] {
return [lspDoc.of(ctx), lspTheme, hintExtension(), hoverExtension(), navigationExtension(), semanticExtension()];
return [lspDoc.of(ctx), lspTheme, hintExtension(), hoverExtension(), navigationExtension()];
}
export function activate(): () => void {
-21
Переглянути файл
@@ -70,27 +70,6 @@ describe("slow navigation feedback", () => {
expect(document.querySelector(".cm-lsp-hint")).toBeNull();
});
it("clears the progress hint when the target opens in another tab and hides this view (#3647)", async () => {
let resolve!: (result: Awaited<ReturnType<typeof commands.lspGotoImplementation>>) => void;
lspGotoImplementation.mockImplementationOnce(() => new Promise((r) => (resolve = r)));
// Opening the target's tab detaches this tab's view, as `EditorSlot.unmount` does.
openFile.mockImplementationOnce(async () => view.dom.remove());
const pending = gotoTargets(view, "implementation");
await vi.advanceTimersByTimeAsync(250);
expect(document.querySelector(".cm-lsp-hint")?.textContent).toBe("Finding navigation target…");
resolve({
status: "ok",
data: [{ path: "/p/Impl.java", range: { start: { line: 1, col: 0 }, end: { line: 1, col: 4 } }, uri: null }],
});
await pending;
expect(openFile).toHaveBeenCalled();
expect(view.dom.isConnected).toBe(false);
expect(document.querySelector(".cm-lsp-hint")).toBeNull();
// Shown again, the tab has no stale progress hint.
document.body.appendChild(view.dom);
expect(document.querySelector(".cm-lsp-hint")).toBeNull();
});
it("shows progress while the chooser's rows load after a quick answer, until the chooser opens", async () => {
let finish!: (files: Map<string, string[]>) => void;
vi.spyOn(files, "readManyFileLines").mockImplementationOnce(() => new Promise((r) => (finish = r)));
-3
Переглянути файл
@@ -146,9 +146,6 @@ export function classifyAction(action: Pick<CodeAction, "kind" | "title">): Refa
)
)
return null;
// rope: a module-level method has no IDEA counterpart; a module-level variable is a constant.
if (/\bglobal method\b/i.test(title)) return null;
if (/\bglobal variable\b/i.test(title)) return "extractConstant";
if (is(/function|method/i)) return "extractMethod";
if (is(/field|member|property/i)) return "extractField";
if (is(/parameter|argument/i)) return "extractParameter";
-8
Переглянути файл
@@ -153,14 +153,6 @@ describe("catalog", () => {
expect(c("Move to a new file", "refactor")).toBe("move");
expect(c("Inline variable", "refactor")).toBe("inline");
expect(c("Convert to template string", "refactor")).toBeNull();
// pylsp-rope (Python).
expect(c("Extract method including similar statements", "refactor.extract")).toBe("extractMethod");
expect(c("Extract global method", "refactor.extract")).toBeNull();
expect(c("Extract variable", "refactor.extract")).toBe("extractVariable");
expect(c("Extract global variable including similar statements", "refactor.extract")).toBe("extractConstant");
expect(c("Inline method/variable/parameter", "refactor.inline")).toBe("inline");
expect(c("Introduce parameter", "refactor")).toBe("extractParameter");
expect(c("To method object", "refactor.rewrite")).toBeNull();
});
it("knows which kinds an advertised list can produce", () => {
-4
Переглянути файл
@@ -69,10 +69,6 @@ describe("occurrenceVariants", () => {
expect(occurrenceVariants([one, all])).toEqual({ one, all });
expect(occurrenceVariants([one])).toBeNull();
expect(occurrenceVariants([one, action("Extract to field"), all])).toBeNull();
// rope's "similar statements" are the other occurrences.
const rope = action("Extract variable");
const similar = action("Extract variable including similar statements");
expect(occurrenceVariants([similar, rope])).toEqual({ one: rope, all: similar });
});
});
+1 -1
Переглянути файл
@@ -102,7 +102,7 @@ export async function chooseExpressionFirst(view: EditorView, then: () => unknow
// ---------------------------------------------------------------------------
// Occurrences chooser
const ALL_OCCURRENCES = /\b(all|every) (the )?occurrences?\b|\breplace all\b|\bincluding similar statements\b/i;
const ALL_OCCURRENCES = /\b(all|every) (the )?occurrences?\b|\breplace all\b/i;
/** The single-occurrence / all-occurrences pair among a refactoring's actions, if the server offers both. */
export function occurrenceVariants(actions: readonly CodeAction[]): { one: CodeAction; all: CodeAction } | null {
+2 -41
Переглянути файл
@@ -66,7 +66,7 @@ import {
} from "./composerModel";
import { referenceExtensions, setReferences } from "./composerEditor";
import { referenceHover } from "./ReferenceChip";
import { composerDraft, provideIdeContext, setIdeContext, updateComposer, useAgents } from "./store";
import { composerDraft, updateComposer, useAgents } from "./store";
import { ImagePreview, imageSrc } from "./ImagePreview";
import { useAgentSettings } from "./agentSettings";
import styles from "./Composer.module.css";
@@ -933,27 +933,6 @@ export function Composer(props: ComposerProps) {
return { path: activePath, rel };
}, [activePath, projectRoot, root, text]);
const ideContext = useAgents((s) => s.ideContext);
useEffect(
() =>
provideIdeContext(id, () => {
const active = useEditorRegistry.getState().active;
const path = active?.ctx.path;
if (!active || !path || isVirtualUri(path)) return null;
const rel = relativeTo([projectRoot, root], path);
if (!rel || rel === ".") return null;
const { doc, selection } = active.view.state;
const { from, to } = selection.main;
if (from === to) return { path, rel };
const first = doc.lineAt(from).number;
const end = doc.lineAt(to);
// A selection ending at the start of a line does not take that line.
const last = end.from === to && end.number > first ? end.number - 1 : end.number;
return { path, rel, lines: { from: first, to: last } };
}),
[id, projectRoot, root],
);
const showContext = images.length > 0 || attached.length > 0 || !!suggested;
return (
@@ -1077,14 +1056,7 @@ export function Composer(props: ComposerProps) {
)}
{showContext && (
<div className={styles.context} onMouseDown={(e) => e.stopPropagation()}>
{suggested && ideContext && (
<span className={styles.attachment} title={tx`${suggested.rel} is added to your request`}>
<Icon name={fileIconName(basename(suggested.rel), suggested.rel)} size={14} />
<span className={styles.attachmentName}>{basename(suggested.rel)}</span>
<span className={styles.suggestionHint}>{tx("Current File")}</span>
</span>
)}
{suggested && !ideContext && (
{suggested && (
<button
type="button"
className={styles.suggestion}
@@ -1155,17 +1127,6 @@ export function Composer(props: ComposerProps) {
replace(from, to, before && !/\s/.test(before) ? " @" : "@");
}}
/>
<IconButton
icon="file-code"
title={
ideContext
? "IDE Context Enabled: the current file and selection are added to your request"
: "IDE Context Disabled: the current file and selection are not added to your request"
}
pressed={ideContext}
className={styles.composerButton}
onClick={() => setIdeContext(!ideContext)}
/>
<IconButton
icon="image"
title="Attach Image…"
+8 -31
Переглянути файл
@@ -404,13 +404,6 @@
.agentName {
display: none;
}
.processBody,
.turnBody {
padding-left: var(--space-2);
}
.processBody > .thoughtEntry ~ .toolEntry {
padding-left: var(--space-3);
}
}
.messageActions {
display: inline-flex;
@@ -778,10 +771,6 @@
margin-bottom: 0;
}
.thoughtEntry,
.toolEntry {
min-width: 0;
}
.thought summary,
.toolDetails > summary {
cursor: pointer;
@@ -794,18 +783,15 @@
.thought summary {
display: flex;
align-items: center;
gap: var(--space-1-5);
gap: var(--space-1);
min-width: 0;
min-height: var(--h-row);
padding: 0 calc(var(--space-2) / 2);
border-radius: var(--radius-row);
color: var(--fg-muted);
font-size: var(--agent-fs-small, var(--fs-small));
-webkit-user-select: none;
user-select: none;
}
.thought summary:hover {
background: var(--bg-hover);
color: var(--fg);
}
.thoughtChevron {
@@ -821,9 +807,7 @@
transform: rotate(90deg);
}
.thoughtBody {
margin: var(--space-1-5) 0 var(--space-1) 10px;
padding-left: var(--space-3);
border-left: 1px solid var(--border);
margin-top: var(--space-2);
color: var(--fg-secondary);
}
.thoughtText {
@@ -837,7 +821,7 @@
.tool {
display: flex;
align-items: center;
gap: var(--space-1-5);
gap: var(--space-2);
min-width: 0;
box-sizing: border-box;
min-height: var(--h-row);
@@ -864,10 +848,6 @@
.toolChevron {
flex: none;
}
.toolChevronSpacer {
width: 12px;
flex: none;
}
.toolDetails[open] > summary .toolChevron {
transform: rotate(90deg);
}
@@ -947,15 +927,12 @@
gap: var(--space-0-5);
max-height: calc(var(--h-row) * 16);
overflow-y: auto;
margin: 2px 0 0 10px;
padding-left: var(--space-3);
margin-top: 2px;
padding-left: 10px;
border-left: 1px solid var(--border);
}
.processBody > .thoughtEntry ~ .toolEntry {
padding-left: var(--space-4);
}
.output {
margin: 4px 0 4px 22px;
margin: 4px 0 0;
max-height: 240px;
overflow: auto;
padding: 8px 10px;
@@ -1851,8 +1828,8 @@
display: flex;
flex-direction: column;
gap: var(--space-2);
margin: 2px 0 0 10px;
padding-left: var(--space-3);
margin-top: 2px;
padding-left: 10px;
border-left: 1px solid var(--border);
}
+4 -7
Переглянути файл
@@ -1426,7 +1426,7 @@ function ThoughtEntry({
if (working && open) onDiagramDrawn();
}, [shown, working, open, onDiagramDrawn]);
return (
<div className={clsx(styles.process, styles.thoughtEntry)}>
<div className={styles.process}>
<Fold
className={clsx(styles.thought, thinking === "auto" && working && styles.thoughtLive)}
open={open}
@@ -2072,15 +2072,12 @@ const ToolEntry = memo(function ToolEntry({
);
if (!entry.output)
return (
<div className={clsx(styles.process, styles.toolEntry)}>
<div className={styles.tool}>
<span className={styles.toolChevronSpacer} aria-hidden="true" />
{head}
</div>
<div className={styles.process}>
<div className={styles.tool}>{head}</div>
</div>
);
return (
<div className={clsx(styles.process, styles.toolEntry)}>
<div className={styles.process}>
<Fold
className={styles.toolDetails}
open={liveTool(entry) || expandToolOutput}
+1 -45
Переглянути файл
@@ -14,7 +14,6 @@ const pathCompletions = vi.fn();
const fsProbe = vi.fn();
const fsEntryKind = vi.fn();
const findSymbols = vi.fn();
const agentPrompt = vi.fn((..._args: unknown[]) => Promise.resolve({ status: "ok", data: null }));
vi.mock("@/platform/ipc", async (importOriginal) => {
const real = await importOriginal<typeof import("@/platform/ipc")>();
@@ -29,7 +28,6 @@ vi.mock("@/platform/ipc", async (importOriginal) => {
fsProbe: (path: string) => fsProbe(path),
fsEntryKind: (path: string) => fsEntryKind(path),
findSymbols: (query: string, filter: string, limit: number) => findSymbols(query, filter, limit),
agentPrompt: (...args: unknown[]) => agentPrompt(...args),
},
};
});
@@ -37,7 +35,7 @@ vi.mock("@/platform/ipc", async (importOriginal) => {
import { Composer } from "./Composer";
import { registerAgentContextSource } from "@/workbench/contributions";
import { useEditorRegistry, type TextEditorHandle } from "@/editor/api";
import { composerDraft, sendMessage, setIdeContext, updateComposer, useAgents } from "./store";
import { composerDraft, updateComposer } from "./store";
import { emptyDraft, toPrompt } from "./composerModel";
const ID = "folders-test";
@@ -320,7 +318,6 @@ describe("Composer editing", () => {
describe("Composer current file", () => {
it("offers the focused editor's file until the draft references it", () => {
const view = {} as TextEditorHandle["view"];
act(() => setIdeContext(false));
act(() =>
useEditorRegistry.setState({ active: { view, ctx: { path: "/p/src/main.ts" } as TextEditorHandle["ctx"] } }),
);
@@ -339,47 +336,6 @@ describe("Composer current file", () => {
});
});
describe("Composer IDE context", () => {
it("sends the focused editor's file, or its selected lines, while IDE context is on", async () => {
const view = new EditorView({ doc: "a\nb\nc\nd\n" });
act(() => setIdeContext(true));
act(() =>
useEditorRegistry.setState({ active: { view, ctx: { path: "/p/src/main.ts" } as TextEditorHandle["ctx"] } }),
);
try {
renderComposer();
const toggle = screen.getByRole("button", { name: /IDE Context Enabled/ });
expect(toggle).toHaveAttribute("aria-pressed", "true");
expect(screen.queryByRole("button", { name: /main\.ts/ })).toBeNull();
expect(screen.getByTitle("src/main.ts is added to your request")).toHaveTextContent("Current File");
const send = async (text: string) => {
updateComposer(ID, { text });
await sendMessage(ID, false);
return agentPrompt.mock.lastCall?.[1];
};
expect(await send("explain")).toEqual({ text: "explain", files: ["/p/src/main.ts"], images: [] });
// Lines 2–3: the selection ends at the start of line 4.
view.dispatch({ selection: { anchor: 2, head: 6 } });
expect(await send("explain")).toEqual({
text: "explain\n\n@src/main.ts:2-3",
files: ["/p/src/main.ts"],
images: [],
});
// A draft that already references the file is sent as written.
expect(await send("see @src/main.ts:1")).toEqual({ text: "see @src/main.ts:1", files: [], images: [] });
fireEvent.click(toggle);
expect(useAgents.getState().ideContext).toBe(false);
expect(screen.getByRole("button", { name: /IDE Context Disabled/ })).toHaveAttribute("aria-pressed", "false");
expect(await send("explain")).toEqual({ text: "explain", files: [], images: [] });
} finally {
act(() => useEditorRegistry.setState({ active: null }));
view.destroy();
}
});
});
describe("Composer pasted code and terminal output", () => {
const paste = (box: HTMLElement, text: string) =>
act(() => {
-30
Переглянути файл
@@ -317,36 +317,6 @@ export function mentionOf(rel: string, lines?: { from: number; to: number }): st
export const isMentioned = (text: string, rel: string) =>
new RegExp(`@${escapeRe(rel)}(?![\\w./-])|@${escapeRe(rel)}:`).test(text);
/** The file in the focused editor and the lines selected in it, for IDE context. */
export interface IdeContext {
path: string;
rel: string;
/** 1-based lines of a non-empty selection. */
lines?: { from: number; to: number };
}
/**
* `draft` with the editor's current file added (as an attachment), or its selection as a
* line-range mention after the text; unchanged when the draft already references the file.
*/
export function withIdeContext(draft: ComposerDraft, context: IdeContext | null): ComposerDraft {
if (
!context ||
isMentioned(draft.text, context.rel) ||
draft.files.some((f) => f.path === context.path && f.attached)
)
return draft;
if (!context.lines)
return { ...draft, files: [...draft.files, { path: context.path, rel: context.rel, attached: true }] };
const mention = mentionOf(context.rel, context.lines);
const text = draft.text.trim();
return {
...draft,
text: text ? `${text}\n\n${mention}` : mention,
files: [...draft.files, { path: context.path, rel: context.rel }],
};
}
/** The prompt to send: attached files, files still mentioned in the text (each once), and the images. */
export function toPrompt(draft: ComposerDraft): AgentPrompt {
const seen = new Set<string>();
+2 -31
Переглянути файл
@@ -14,7 +14,6 @@ import type {
AgentImage,
AgentLimit,
AgentModelCatalog,
AgentPrompt,
AgentProvider,
AgentTask,
ExternalSession,
@@ -36,10 +35,8 @@ import {
isMentioned,
isPerModelOption,
toPrompt,
withIdeContext,
type ComposerDraft,
type FileRef,
type IdeContext,
} from "./composerModel";
import { withQuote } from "./conversation";
import {
@@ -130,8 +127,6 @@ interface AgentsState {
/** Side conversations by task id: kept out of the task list, discarded when their view closes. */
ephemeral: ReadonlySet<string>;
pinnedModels: string[];
/** Whether messages carry the editor's current file and selection. */
ideContext: boolean;
}
const DRAFT_KEY = "openidea.agents.draft.v2";
@@ -139,7 +134,6 @@ const HISTORY_KEY = "openidea.agents.history.v1";
const HISTORY_SIZE = 50;
const SESSION_LOCATION_KEY = "openidea.agents.sessionLocation.v1";
const PINNED_MODELS_KEY = "openidea.agents.pinnedModels.v1";
const IDE_CONTEXT_KEY = "openidea.agents.ideContext.v1";
function load<T>(key: string, fallback: T): T {
try {
@@ -204,7 +198,6 @@ export const useAgents = create<AgentsState>(() => ({
homeOpen: false,
ephemeral: new Set<string>(),
pinnedModels: load<string[]>(PINNED_MODELS_KEY, []),
ideContext: load<boolean>(IDE_CONTEXT_KEY, true),
scrollPositions: new Map(),
}));
@@ -979,7 +972,7 @@ export async function startTask(
const task = await call(
commands.agentCreate({
projectRoot,
prompt: promptOf(HOME, composer),
prompt: toPrompt(composer),
provider: draft.provider,
config,
isolation,
@@ -1093,28 +1086,6 @@ export async function importExternalSessions(
void showError(title, failures.join("\n"));
}
export function setIdeContext(on: boolean) {
useAgents.setState({ ideContext: on });
save(IDE_CONTEXT_KEY, on);
}
/** The IDE context of each mounted composer, by draft key. */
const ideContexts = new Map<string, () => IdeContext | null>();
/** Registers what composer `key` sends as IDE context; returns the unregister. */
export function provideIdeContext(key: string, context: () => IdeContext | null): () => void {
ideContexts.set(key, context);
return () => {
if (ideContexts.get(key) === context) ideContexts.delete(key);
};
}
/** The prompt of composer `key`, with the IDE context when it is on. */
function promptOf(key: string, composer: ComposerDraft): AgentPrompt {
const context = useAgents.getState().ideContext ? (ideContexts.get(key)?.() ?? null) : null;
return toPrompt(withIdeContext(composer, context));
}
function remember(text: string) {
if (!text) return;
const history = [text, ...useAgents.getState().history.filter((h) => h !== text)].slice(0, HISTORY_SIZE);
@@ -1127,7 +1098,7 @@ export async function sendMessage(task: string, now: boolean): Promise<void> {
const composer = composerDraft(task);
if (!canSend(composer)) return;
const started = generation;
await call(commands.agentPrompt(task, promptOf(task, composer), now));
await call(commands.agentPrompt(task, toPrompt(composer), now));
clearSubmittedComposer(task, composer, started);
}
+18 -207
Переглянути файл
@@ -11,13 +11,7 @@ const component = (name: string, options: Record<string, string>) =>
.map(([k, v]) => `<option name="${k}" value="${v}" />`)
.join("")}</component></application>`;
const settings = {
editor: { fontFamily: "JetBrains Mono", fontSize: 13, customSchemes: {}, colorOverrides: {} },
customKeymaps: {},
};
/** JetBrains Maple Mono's metrics (ascent 1.02em, descent 0.3em), for any family. */
const fontHeight = (_family: string, size: number) => Math.ceil(size * 1.02) + Math.ceil(size * 0.3);
const editor = { fontSize: 13, customSchemes: {}, colorOverrides: {} };
/** A WebStorm export, trimmed to what the import reads. */
const webstorm = {
@@ -57,8 +51,8 @@ const webstorm = {
};
describe("planJetBrainsImport", () => {
it("maps a WebStorm export to the settings it has, and lists what is left out", async () => {
const plan = await planJetBrainsImport(webstorm, settings, fontHeight);
it("maps a WebStorm export to the settings it has, and lists what is left out", () => {
const plan = planJetBrainsImport(webstorm, editor);
const writes = Object.fromEntries(plan.writes);
const schemes = writes["editor.customSchemes"] as Record<string, { name: string; parent: string }>;
const [id, scheme] = Object.entries(schemes)[0]!;
@@ -68,15 +62,12 @@ describe("planJetBrainsImport", () => {
"editor.colorScheme": id,
"editor.fontFamily": "JetBrains Maple Mono",
"editor.fontSize": 17,
// (18 + 6) × the default spacing 1.2, rounded up, as WebStorm draws it.
"editor.lineHeight": 29,
"editor.ligatures": true,
"files.trimTrailingWhitespace": true,
"editor.general.stripTrailingScope": "all",
"files.ensureFinalNewline": true,
"editor.stickyScroll": false,
"editor.softWrap": false,
"console.softWrap": true,
"general.confirmExit": false,
});
expect(plan.rows).toContainEqual({
@@ -88,12 +79,12 @@ describe("planJetBrainsImport", () => {
label: "Remove trailing spaces on:",
value: "All lines",
});
expect(plan.skipped).toEqual(["Code Style options other than Tabs and Indents", "Inspections", "Plugins"]);
expect(plan.skipped).toEqual(["Keymap", "Code Style", "Inspections", "Plugins"]);
expect(plan.invalid).toEqual([]);
});
it("writes only the keys present, and derives the line height from IDEA's spacing", async () => {
const plan = await planJetBrainsImport(
it("writes only the keys present, and derives the line height from IDEA's spacing", () => {
const plan = planJetBrainsImport(
{
entries: [],
files: {
@@ -106,213 +97,33 @@ describe("planJetBrainsImport", () => {
}),
},
},
settings,
fontHeight,
editor,
);
expect(plan.writes).toEqual([
// (14 + 4) × 1.5
["editor.lineHeight", 27],
["editor.lineHeight", 20],
["files.trimTrailingWhitespace", false],
["editor.softWrap", true],
["console.softWrap", true],
]);
expect(plan.skipped).toEqual([]);
});
it("re-importing replaces the earlier copy of a scheme and drops its edits", async () => {
const first = Object.fromEntries((await planJetBrainsImport(webstorm, settings, fontHeight)).writes);
const customs = first["editor.customSchemes"] as typeof settings.editor.customSchemes;
it("re-importing replaces the earlier copy of a scheme and drops its edits", () => {
const first = Object.fromEntries(planJetBrainsImport(webstorm, editor).writes);
const customs = first["editor.customSchemes"] as typeof editor.customSchemes;
const [id] = Object.keys(customs);
const again = await planJetBrainsImport(
webstorm,
{
...settings,
editor: {
...settings.editor,
customSchemes: customs,
colorOverrides: { [id!]: { keyword: { bold: true } }, other: {} },
},
},
fontHeight,
);
const again = planJetBrainsImport(webstorm, {
...editor,
customSchemes: customs,
colorOverrides: { [id!]: { keyword: { bold: true } }, other: {} },
});
const writes = Object.fromEntries(again.writes);
expect(Object.keys(writes["editor.customSchemes"] as object)).toEqual([id]);
expect(writes["editor.colorOverrides"]).toEqual({ other: {} });
expect(writes["editor.colorScheme"]).toBe(id);
});
it("falls back to the font size when the font cannot be measured", async () => {
const plan = await planJetBrainsImport(
{ entries: [], files: { "options/editor-font.xml": component("DefaultFont", { FONT_SIZE: "20" }) } },
settings,
() => undefined,
);
expect(plan.writes).toEqual([
["editor.fontSize", 20],
["editor.lineHeight", 29],
]);
});
it("imports the keymaps and makes the active one current", async () => {
const keymap =
'<keymap version="1" name="macOS copy" parent="Mac OS X 10.5+">' +
'<action id="NextTab"><keyboard-shortcut first-keystroke="ctrl right" /></action>' +
'<action id="GotoSuperMethod" /><action id="RunAnything" /></keymap>';
const active =
'<application><component name="KeymapManager"><active_keymap name="macOS copy" /></component></application>';
const bundle = {
entries: ["keymaps/macOS copy.xml", "keymaps/broken.xml"],
files: {
"keymaps/macOS copy.xml": keymap,
"keymaps/broken.xml": "<nope",
// The active keymap is stored per operating system; the host picks its own.
"options/mac/keymap.xml": active,
"options/windows/keymap.xml": active,
"options/linux/keymap.xml": active,
},
};
const plan = await planJetBrainsImport(bundle, settings);
const expected = {
name: "macOS copy",
parent: "intellij-macos",
overrides: { "editor.nextTab": ["Ctrl+Right"], "navigate.superMethod": [] },
};
expect(plan.writes).toEqual([
["customKeymaps", { "custom.macos-copy": expected }],
["keymap", "custom.macos-copy"],
]);
expect(plan.rows).toEqual([
{ label: "Keymap", value: "macOS copy" },
{ label: "Current keymap", value: "macOS copy" },
]);
expect(plan.unknownActions).toEqual(["RunAnything"]);
expect(plan.invalid).toEqual(["broken.xml"]);
// Importing again replaces the earlier copy and keeps the user's other keymaps.
const mine = { name: "Mine", parent: "vscode-macos", overrides: {} };
const again = await planJetBrainsImport(bundle, {
...settings,
customKeymaps: { "custom.macos-copy": { ...expected, overrides: {} }, "custom.mine": mine },
});
expect(again.writes[0]).toEqual(["customKeymaps", { "custom.macos-copy": expected, "custom.mine": mine }]);
});
it("imports the terminal font", async () => {
const plan = await planJetBrainsImport(
{
entries: [],
files: {
"options/terminal-font.xml": component("TerminalFontOptions", {
VERSION: "1",
FONT_SIZE: "17",
FONT_SIZE_2D: "17.0",
FONT_FAMILY: "MesloLGS NF",
LINE_SPACING: "1.1",
}),
},
},
settings,
);
expect(plan.writes).toEqual([
["terminal.useEditorFont", false],
["terminal.fontFamily", "MesloLGS NF"],
["terminal.fontSize", 17],
["terminal.lineHeight", 1.1],
]);
});
it("imports tabs and indents of the current code style scheme onto the languages' own styles", async () => {
const scheme = (name: string, body: string) => `<code_scheme name="${name}" version="173">${body}</code_scheme>`;
const plan = await planJetBrainsImport(
{
entries: ["codestyles/Default.xml", "codestyles/Team.xml"],
files: {
"options/code.style.schemes.xml": component("CodeStyleSchemeSettings", { CURRENT_SCHEME_NAME: "Team" }),
"codestyles/Default.xml": scheme(
"Default",
'<codeStyleSettings language="Python"><indentOptions><option name="INDENT_SIZE" value="8" /></indentOptions></codeStyleSettings>',
),
"codestyles/Team.xml": scheme(
"Team",
'<option name="RIGHT_MARGIN" value="100" />' +
'<option name="OTHER_INDENT_OPTIONS"><value><option name="TAB_SIZE" value="8" />' +
'<option name="USE_TAB_CHARACTER" value="true" /></value></option>' +
'<JSCodeStyleSettings version="0"><option name="USE_SEMICOLON_AFTER_STATEMENT" value="false" /></JSCodeStyleSettings>' +
'<codeStyleSettings language="TypeScript"><option name="SPACE_WITHIN_BRACKETS" value="true" />' +
'<indentOptions><option name="INDENT_SIZE" value="2" /><option name="CONTINUATION_INDENT_SIZE" value="2" />' +
'<option name="TAB_SIZE" value="2" /></indentOptions></codeStyleSettings>' +
'<codeStyleSettings language="HTML"><option name="LINE_COMMENT_AT_FIRST_COLUMN" value="false" />' +
'<indentOptions><option name="USE_TAB_CHARACTER" value="true" /></indentOptions></codeStyleSettings>' +
'<codeStyleSettings language="Brainfuck"><indentOptions><option name="INDENT_SIZE" value="3" /></indentOptions></codeStyleSettings>',
),
},
},
{
...settings,
editor: {
...settings.editor,
codeStyle: { languages: { typescript: { hardWrapAt: 90 }, go: { tabSize: 8 } } },
},
},
);
expect(plan.writes).toEqual([
["editor.codeStyle.hardWrapAt", 100],
["editor.tabSize", 8],
["editor.insertSpaces", false],
[
"editor.codeStyle.languages",
{
typescript: { hardWrapAt: 90, indent: 2, tabSize: 2 },
typescriptreact: { indent: 2, tabSize: 2 },
html: { useTab: true, lineCommentAtFirstColumn: false },
go: { tabSize: 8 },
},
],
]);
expect(plan.rows).toContainEqual({ label: "Code Style › TypeScript", value: "Indent 2, Tab size 2" });
expect(plan.rows).toContainEqual({ label: "Use tab character", value: "On" });
expect(plan.skipped).toEqual(["Code Style options other than Tabs and Indents"]);
});
it("imports the editor options that have a setting here", async () => {
const xml =
"<application>" +
component("EditorSettings", {
IS_SMOOTH_CARET_BLINKING: "true",
IS_BLOCK_CURSOR: "true",
ARE_LINE_NUMBERS_SHOWN: "false",
LINE_NUMERATION: "HYBRID",
SHOW_BREADCRUMBS_ABOVE: "true",
CARET_BLINKING_PERIOD: "700",
IS_ANIMATED_SCROLLING: "false",
}).replace(/<\/?application>/g, "") +
component("CodeInsightSettings", {
AUTOINSERT_PAIR_QUOTE: "false",
REFORMAT_ON_PASTE: "2",
SMART_BACKSPACE: "1",
PARAMETER_INFO_DELAY: "500",
COMPLETION_CASE_SENSITIVE: "2",
}).replace(/<\/?application>/g, "") +
"</application>";
const plan = await planJetBrainsImport({ entries: [], files: { "options/editor.xml": xml } }, settings);
expect(Object.fromEntries(plan.writes)).toEqual({
"editor.appearance.lineNumberMode": "hybrid",
"editor.breadcrumbs.placement": "top",
"editor.appearance.smoothCaretBlinking": true,
"editor.appearance.blockCaret": true,
"editor.appearance.lineNumbers": false,
"editor.appearance.caretBlinkPeriod": 700,
"editor.smartKeys.pairQuotes": false,
"editor.completion.parameterInfoDelay": 500,
"editor.smartKeys.reformatOnPaste": "indentBlock",
"editor.smartKeys.backspaceUnindent": "nearest",
});
expect(plan.rows).toContainEqual({ label: "Unindent", value: "To nearest indent position" });
expect(plan.rows).toContainEqual({ label: "Show line numbers", value: "Hybrid" });
});
it("skips colour schemes that cannot be read", async () => {
const plan = await planJetBrainsImport({ entries: [], files: { "colors/broken.icls": "<nope" } }, settings);
it("skips colour schemes that cannot be read", () => {
const plan = planJetBrainsImport({ entries: [], files: { "colors/broken.icls": "<nope" } }, editor);
expect(plan.invalid).toEqual(["broken.icls"]);
expect(plan.writes).toEqual([]);
});
+2 -5
Переглянути файл
@@ -4,7 +4,7 @@ import { act, fireEvent, render, screen } from "@testing-library/react";
const read = vi.fn();
const set = vi.fn();
const notify = vi.fn();
const editor = { fontFamily: "JetBrains Mono", fontSize: 13, customSchemes: {}, colorOverrides: {} };
const editor = { fontSize: 13, customSchemes: {}, colorOverrides: {} };
vi.mock("@/platform/ipc", async (original) => {
const actual = await original<typeof import("@/platform/ipc")>();
@@ -44,8 +44,6 @@ beforeEach(() => {
},
});
set.mockResolvedValue({ status: "ok", data: { editor } });
// jsdom has no canvas: the import falls back to the font size for the line height.
vi.spyOn(HTMLCanvasElement.prototype, "getContext").mockReturnValue(null);
});
it.each(["Cancel", "Import"])("confirms folder settings before applying them: %s", async (button) => {
@@ -58,7 +56,7 @@ it.each(["Cancel", "Import"])("confirms folder settings before applying them: %s
expect(screen.getByText("Monaco")).toBeInTheDocument();
expect(screen.getByText("17")).toBeInTheDocument();
expect(screen.getAllByText("Custom")).toHaveLength(2);
expect(screen.getByText(/Not imported:/)).toHaveTextContent("Plugins");
expect(screen.getByText(/Not imported:/)).toHaveTextContent("Keymap, Plugins");
expect(set).not.toHaveBeenCalled();
await act(async () => {
fireEvent.click(screen.getByRole("button", { name: button }));
@@ -80,7 +78,6 @@ it.each(["Cancel", "Import"])("confirms folder settings before applying them: %s
"editor.colorScheme": id,
"editor.fontFamily": "Monaco",
"editor.fontSize": 17,
"editor.lineHeight": 25,
});
expect(notify).toHaveBeenCalledWith(expect.objectContaining({ title: "Settings imported" }));
}
-79
Переглянути файл
@@ -15,7 +15,6 @@ import {
installMenuBridge,
menuAccelerator,
menuActionIds,
returnFocusAfterMenu,
routeMenuEvent,
} from "../menuBridge";
@@ -55,84 +54,6 @@ describe("menu state from the frontend", () => {
}
});
it("pushes enablement once when the window loses focus, for its Settings window (#3625)", async () => {
vi.useFakeTimers();
vi.spyOn(ipc, "isTauri").mockReturnValue(true);
const hasFocus = vi.spyOn(document, "hasFocus").mockReturnValue(true);
vi.spyOn(ipc.commands, "appBuildInfo").mockRejectedValue(new Error("No build info in tests"));
vi.spyOn(ipc.commands, "menuConfigure").mockResolvedValue();
vi.spyOn(ipc.commands, "menuModel").mockResolvedValue([
{ kind: "action", id: "test.menuBlur", label: "Test", hint: null, arg: null, checked: null },
]);
const pushDisabled = vi.spyOn(ipc.commands, "menuSetDisabled").mockResolvedValue();
const offAction = registerAction({ id: "test.menuBlur", title: "Test", when: "testMenuBlurEditor", run: () => {} });
setContext("testMenuBlurEditor", true);
const dispose = installMenuBridge();
try {
await vi.advanceTimersByTimeAsync(120);
expect(pushDisabled).toHaveBeenCalledExactlyOnceWith([]);
pushDisabled.mockClear();
// Focus moves to the Settings window: the editor loses focus, then the window blurs.
hasFocus.mockReturnValue(false);
setContext("testMenuBlurEditor", false);
window.dispatchEvent(new Event("blur"));
await vi.advanceTimersByTimeAsync(120);
expect(pushDisabled).toHaveBeenCalledExactlyOnceWith(["test.menuBlur"]);
pushDisabled.mockClear();
// Later changes in a background window are not pushed.
setContext("testMenuBlurEditor", true);
await vi.advanceTimersByTimeAsync(120);
expect(pushDisabled).not.toHaveBeenCalled();
} finally {
dispose();
offAction();
clearContext("testMenuBlurEditor");
vi.useRealTimers();
vi.restoreAllMocks();
}
});
it("brings Settings back once the dialog opened from its menu closes (#3625)", async () => {
vi.useFakeTimers();
vi.spyOn(document, "hasFocus").mockReturnValue(true);
const focusSettings = vi.fn(async () => {});
try {
// About opens a dialog: Settings waits under it.
const about = returnFocusAfterMenu(
Promise.resolve(true)
.then(() => setContext("popupOpen", true))
.then(() => true),
focusSettings,
);
await vi.advanceTimersByTimeAsync(1000);
expect(focusSettings).not.toHaveBeenCalled();
setContext("popupOpen", false);
await about;
expect(focusSettings).toHaveBeenCalledOnce();
// An action that opens nothing: Settings comes back right away.
focusSettings.mockClear();
const saveAll = returnFocusAfterMenu(Promise.resolve(true), focusSettings);
await vi.advanceTimersByTimeAsync(300);
await saveAll;
expect(focusSettings).toHaveBeenCalledOnce();
// Focus moved on (a new window or a native dialog): Settings stays where it is.
focusSettings.mockClear();
vi.mocked(document.hasFocus).mockReturnValue(false);
const open = returnFocusAfterMenu(Promise.resolve(true), focusSettings);
await vi.advanceTimersByTimeAsync(300);
await open;
expect(focusSettings).not.toHaveBeenCalled();
} finally {
clearContext("popupOpen");
vi.useRealTimers();
vi.restoreAllMocks();
}
});
it("lists registered tool windows by title and saved layouts", () => {
localStorage.clear();
_reloadLayouts();
-2
Переглянути файл
@@ -8,8 +8,6 @@ vi.mock("@tauri-apps/api/core", () => ({
Channel: class {
onmessage: (p: unknown) => void = () => {};
},
// Balloons are mirrored to a system notification (`showSystemNotification`).
invoke: async () => null,
}));
type Channel = { onmessage: (p: UpdateProgress) => void };
-50
Переглянути файл
@@ -748,53 +748,3 @@ describe("explicit project-window requests", () => {
}
});
});
describe("trust is asked before a new project window opens", () => {
const openProjectPath = (arg: unknown) =>
windowActions()
.find((a) => a.id === "file.openProjectPath")!
.run({ arg } as never);
const newWindowEntries: [string, () => unknown][] = [
["Open… from a project window", () => openProjectInWindow("/p/b", false)],
["Open in New Window", () => openProjectInWindow("/p/b", true)],
["Open project in: New Window", () => openProjectWithPolicy("/p/b")],
["a plugin's new-window request", () => openProjectPath({ path: "/p/b", newWindow: true })],
];
it.each(newWindowEntries)("%s asks in this window first", async (_, open) => {
useProject.setState({ ...projectState("/p/a"), settings: { general: { openProjectIn: "new" } } } as never);
windowOpenProject.mockResolvedValue(ok({ kind: "opened", label: "project-1" }));
await open();
expect(confirmProjectTrust).toHaveBeenCalledWith("/p/b", "local");
expect(vi.mocked(confirmProjectTrust).mock.invocationCallOrder[0]).toBeLessThan(
windowOpenProject.mock.invocationCallOrder[0]!,
);
expect(windowOpenProject).toHaveBeenCalledWith("/p/b", true, []);
});
it.each(newWindowEntries)("%s opens no window when the user chooses Don't Open", async (_, open) => {
useProject.setState({ ...projectState("/p/a"), settings: { general: { openProjectIn: "new" } } } as never);
vi.mocked(confirmProjectTrust).mockRejectedValueOnce(new IpcError({ kind: "cancelled", message: "Cancelled" }));
await open();
expect(windowOpenProject).not.toHaveBeenCalled();
expect(notify).not.toHaveBeenCalled();
expect(useProject.getState().project?.root).toBe("/p/a");
});
it("leaves a WSL folder to the remote window, which asks about the distribution's project", async () => {
useProject.setState(projectState("/p/a") as never);
wslResolve.mockResolvedValue({ target: { kind: "wsl", distro: "Debian" }, path: "/srv/app" });
windowOpenProject.mockResolvedValue(ok({ kind: "opened", label: "project-1" }));
await openProjectInWindow("\\\\wsl.localhost\\Debian\\srv\\app", true);
expect(confirmProjectTrust).not.toHaveBeenCalled();
expect(windowOpenProject).toHaveBeenCalled();
});
it("asks only once, from openProject, when the project opens in this window", async () => {
windowOpenProject.mockResolvedValue(ok({ kind: "current" }));
await openProjectInWindow("/p/b", false);
expect(windowOpenProject).toHaveBeenCalledWith("/p/b", false, []);
expect(confirmProjectTrust).not.toHaveBeenCalled();
expect(openProject).toHaveBeenCalledWith("/p/b");
});
});
-123
Переглянути файл
@@ -1,123 +0,0 @@
/**
* JetBrains option names (as the IDE writes them to `options/editor.xml` and
* `codestyles/*.xml`) and the OpenIDEA settings of the same meaning. Each entry
* carries the label the option has in Settings, for the import confirmation.
*/
type Mapped = readonly [key: string, label: string];
/** `<component name="EditorSettings">`: on/off options. */
export const EDITOR_FLAGS: Record<string, Mapped> = {
IS_WHEEL_FONTCHANGE_ENABLED: ["editor.general.wheelZoom", "Change font size with Ctrl/Command+Mouse Wheel"],
IS_DND_ENABLED: ["editor.general.dragAndDrop", "Enable drag-and-drop functionality in editor"],
USE_CUSTOM_SOFT_WRAP_INDENT: ["editor.general.softWrapIndent", "Use original line's indent for wrapped parts"],
ADDITIONAL_PAGE_AT_BOTTOM: ["editor.general.scrollPastEnd", "Show virtual space at file bottom"],
KEEP_TRAILING_SPACE_ON_CARET_LINE: ["editor.general.keepTrailingOnCaretLine", "Keep trailing spaces on caret line"],
REMOVE_TRAILING_BLANK_LINES: [
"editor.general.removeTrailingBlankLines",
"Remove trailing blank lines at the end of saved files",
],
IS_CARET_BLINKING: ["editor.appearance.caretBlinking", "Caret blinking (ms):"],
IS_SMOOTH_CARET_BLINKING: ["editor.appearance.smoothCaretBlinking", "Use smooth caret blinking"],
IS_BLOCK_CURSOR: ["editor.appearance.blockCaret", "Use block caret"],
IS_SMOOTH_CARET_MOVEMENT: ["editor.appearance.smoothCaretMovement", "Use smooth caret movement"],
IS_RIGHT_MARGIN_SHOWN: [
"editor.appearance.hardWrapGuides",
"Show hard wrap and visual guides (configured in Code Style options)",
],
ARE_LINE_NUMBERS_SHOWN: ["editor.appearance.lineNumbers", "Show line numbers"],
IS_LEADING_WHITESPACES_SHOWN: ["editor.appearance.whitespaceLeading", "Leading"],
IS_INNER_WHITESPACES_SHOWN: ["editor.appearance.whitespaceInner", "Inner"],
IS_TRAILING_WHITESPACES_SHOWN: ["editor.appearance.whitespaceTrailing", "Trailing"],
IS_INDENT_GUIDES_SHOWN: ["editor.appearance.indentGuides", "Show indent guides"],
SHOW_INTENTION_BULB: ["editor.appearance.intentionBulb", "Show intention bulb"],
ENABLE_RENDERED_DOC: ["editor.appearance.renderDocComments", "Render documentation comments"],
SHOW_BREADCRUMBS: ["editor.breadcrumbs.show", "Show breadcrumbs:"],
IS_FOLDING_OUTLINE_SHOWN: ["editor.folding.showOutline", "Show code folding outline"],
SMART_HOME: ["editor.smartKeys.smartHome", "Home moves caret to first non-whitespace character"],
IS_CAMEL_WORDS: ["editor.smartKeys.camelHumps", 'Use "CamelHumps" words'],
IS_HIGHLIGHT_SELECTION_OCCURRENCES: ["editor.codeEditing.highlightSelection", "Occurrences of selected text"],
SHOW_QUICK_DOC_ON_MOUSE_OVER_ELEMENT: ["editor.codeEditing.quickDocOnHover", "Show quick documentation on hover"],
INSERT_PARENTHESES_AUTOMATICALLY: [
"editor.completion.insertParentheses",
"Insert parentheses automatically when applicable",
],
};
/** `<component name="EditorSettings">`: numbers. */
export const EDITOR_NUMBERS: Record<string, Mapped> = {
CARET_BLINKING_PERIOD: ["editor.appearance.caretBlinkPeriod", "Caret blinking (ms):"],
STICKY_LINES_LIMIT: ["editor.codeEditing.stickyLinesMax", "Maximum number of lines"],
TOOLTIPS_DELAY_MS: ["editor.codeEditing.quickDocDelay", "Tooltip delay"],
};
/** `<component name="CodeInsightSettings">`: on/off options. */
export const CODE_INSIGHT_FLAGS: Record<string, Mapped> = {
AUTOINSERT_PAIR_BRACKET: ["editor.smartKeys.pairBrackets", "Insert paired brackets (), [], {}"],
AUTOINSERT_PAIR_QUOTE: ["editor.smartKeys.pairQuotes", "Insert pair quote"],
SURROUND_SELECTION_ON_QUOTE_TYPED: [
"editor.smartKeys.surroundSelection",
"Surround selection on typing quote or brace",
],
TAB_EXITS_BRACKETS_AND_QUOTES: ["editor.smartKeys.tabOutOfPair", "Jump outside closing bracket/quote with Tab"],
SMART_INDENT_ON_ENTER: ["editor.smartKeys.smartIndent", "Smart indent"],
JAVADOC_STUB_ON_ENTER: ["editor.smartKeys.insertDocStub", "Insert documentation comment stub"],
HIGHLIGHT_IDENTIFIER_UNDER_CARET: ["editor.codeEditing.highlightUsages", "Usages of element at caret"],
HIGHLIGHT_BRACES: ["editor.codeEditing.highlightBraces", "Matched brace"],
AUTO_POPUP_COMPLETION_LOOKUP: ["editor.completion.autoPopup", "Show suggestions as you type"],
AUTOCOMPLETE_ON_CODE_COMPLETION: ["editor.completion.autoInsertSingle", "Automatically insert single suggestions"],
AUTO_POPUP_JAVADOC_INFO: ["editor.completion.showDocumentation", "Show the documentation popup in"],
AUTO_POPUP_PARAMETER_INFO: ["editor.completion.parameterInfo", "Show the parameter info popup in"],
};
/** `<component name="CodeInsightSettings">`: numbers. */
export const CODE_INSIGHT_NUMBERS: Record<string, Mapped> = {
JAVADOC_INFO_DELAY: ["editor.completion.documentationDelay", "Show the documentation popup in"],
PARAMETER_INFO_DELAY: ["editor.completion.parameterInfoDelay", "Show the parameter info popup in"],
};
/** `REFORMAT_ON_PASTE` (IDEA's `CodeInsightSettings` constants) → `editor.smartKeys.reformatOnPaste`, its label. */
export const REFORMAT_ON_PASTE: Record<string, Mapped> = {
"1": ["none", "None"],
"2": ["indentBlock", "Indent Block"],
"3": ["indentEachLine", "Indent Each Line"],
};
/** `SMART_BACKSPACE` (IDEA's `SmartBackspaceMode` ordinals) → `editor.smartKeys.backspaceUnindent`, its label. */
export const SMART_BACKSPACE: Record<string, Mapped> = {
"0": ["none", "Disabled"],
"1": ["nearest", "To nearest indent position"],
"2": ["autoindent", "To proper indent position"],
};
/** `<codeStyleSettings language=…>` → the language ids that share that code style here. */
export const CODE_STYLE_LANGUAGES: Record<string, readonly string[]> = {
JAVA: ["java"],
kotlin: ["kotlin"],
Groovy: ["groovy"],
Scala: ["scala"],
JavaScript: ["javascript", "javascriptreact"],
TypeScript: ["typescript", "typescriptreact"],
Vue: ["vue"],
HTML: ["html"],
XML: ["xml"],
CSS: ["css"],
SCSS: ["scss"],
SASS: ["sass"],
LESS: ["less"],
JSON: ["json", "jsonc"],
yaml: ["yaml"],
TOML: ["toml"],
Markdown: ["markdown"],
Python: ["python"],
go: ["go"],
Rust: ["rust"],
PHP: ["php"],
ruby: ["ruby"],
Dart: ["dart"],
Swift: ["swift"],
"C#": ["csharp"],
Lua: ["lua"],
SQL: ["sql"],
"Shell Script": ["shellscript"],
};
+18 -228
Переглянути файл
@@ -1,32 +1,20 @@
/**
* Import Settings… with a JetBrains `settings.zip`: maps the archive's colour
* schemes, keymaps, fonts, tabs and indents, and the editor / general options
* OpenIDEA has to settings writes, after a confirmation listing them. Only keys
* present in the archive are written (JetBrains leaves defaults out). The rest
* is listed as not imported.
* schemes and the editor / general options OpenIDEA has to settings writes, after
* a confirmation listing them. Only keys present in the archive are written
* (JetBrains leaves defaults out). Keymaps, code styles and the rest are listed
* as not imported.
*/
import { Fragment } from "react";
import type { CustomKeymap, JetBrainsSettings, LanguageCodeStyle } from "@/bindings";
import type { JetBrainsSettings } from "@/bindings";
import { customSchemes } from "@/platform/colorScheme";
import { createFontProbeCanvas, fontsLoaded, monoFontFamily } from "@/platform/fonts";
import { tx } from "@/platform/i18n";
import { importScheme, parseIcls } from "@/platform/icls";
import { addIdeaKeymap, parseIdeaKeymap } from "@/platform/ideaKeymap";
import { call, commands } from "@/platform/ipc";
import { guessOs } from "@/platform/platformInfo";
import { useProject } from "@/platform/project";
import { notifications } from "@/workbench/contributions";
import { ask } from "@/workbench/messages";
import styles from "./app.module.css";
import {
CODE_INSIGHT_FLAGS,
CODE_INSIGHT_NUMBERS,
CODE_STYLE_LANGUAGES,
EDITOR_FLAGS,
EDITOR_NUMBERS,
REFORMAT_ON_PASTE,
SMART_BACKSPACE,
} from "./jetbrainsOptions";
export interface JetBrainsImportPlan {
/** Settings writes, in order: `settingsSet("global", key, JSON.stringify(value))`. */
@@ -35,22 +23,14 @@ export interface JetBrainsImportPlan {
rows: { label: string; value: string }[];
/** Categories present in the archive that are not imported (translated). */
skipped: string[];
/** Colour scheme and keymap files that could not be read. */
/** `.icls` files that could not be read. */
invalid: string[];
/** IDEA action ids the imported keymaps bind that have no counterpart here. */
unknownActions: string[];
}
/** The settings the import builds on (`settingsGetGlobal`). */
interface CurrentSettings {
editor: {
fontFamily: string;
fontSize: number | null;
customSchemes: unknown;
colorOverrides: Record<string, unknown>;
codeStyle?: { languages?: Record<string, LanguageCodeStyle> };
};
customKeymaps?: Record<string, CustomKeymap>;
interface EditorState {
fontSize: number | null;
customSchemes: unknown;
colorOverrides: Record<string, unknown>;
}
const USER_PREFIX = "_@user_";
@@ -83,67 +63,8 @@ const num = (v: string | undefined) => {
const onOff = (v: boolean) => (v ? tx("On") : tx("Off"));
/** IDEA's `LINE_SPACING` when the export leaves it out. */
const DEFAULT_LINE_SPACING = 1.2;
/** The font's own line height in px, as IDEA's editor takes it from Java's FontMetrics. */
export type FontHeight = (family: string, size: number) => Promise<number | undefined> | number | undefined;
/** WebKit reports whole-pixel metrics; measured this large, they keep the font's fractions. */
const PROBE_SIZE = 1000;
async function measuredFontHeight(family: string, size: number): Promise<number | undefined> {
// The editor's own stack: WKWebView draws an installed font only through its loaded alias.
const stack = monoFontFamily(family);
await fontsLoaded(stack, size);
const canvas = createFontProbeCanvas();
try {
const ctx = canvas.getContext("2d");
if (!ctx) return undefined;
ctx.font = `${PROBE_SIZE}px ${stack}`;
const m = ctx.measureText("M");
// Java rounds the ascent and the descent up separately (anything past .05 of a pixel).
const px = (v: number) => Math.floor((v / PROBE_SIZE) * size + 0.95);
const h = px(m.fontBoundingBoxAscent) + px(m.fontBoundingBoxDescent);
return Number.isFinite(h) && h > 0 ? h : undefined;
} finally {
canvas.remove();
}
}
/** `<option name value>` children of `parent`. */
function optionValues(parent: Element | null | undefined): Map<string, string> {
const out = new Map<string, string>();
for (const o of Array.from(parent?.children ?? [])) {
const name = o.getAttribute("name");
const value = o.getAttribute("value");
if (o.tagName === "option" && name && value !== null) out.set(name, value);
}
return out;
}
const childOf = (parent: Element, tag: string, name?: string) =>
Array.from(parent.children).find((c) => c.tagName === tag && (name === undefined || c.getAttribute("name") === name));
/** The code style scheme called `name` among `codestyles/*.xml`. */
function codeScheme(files: Record<string, string>, name: string): Element | undefined {
for (const [file, text] of Object.entries(files)) {
if (!file.startsWith("codestyles/")) continue;
const doc = new DOMParser().parseFromString(text, "application/xml");
const root = doc.documentElement;
if (!doc.querySelector("parsererror") && root.tagName === "code_scheme" && root.getAttribute("name") === name)
return root;
}
return undefined;
}
export async function planJetBrainsImport(
bundle: JetBrainsSettings,
current: CurrentSettings,
fontHeight: FontHeight = measuredFontHeight,
): Promise<JetBrainsImportPlan> {
const { editor } = current;
const plan: JetBrainsImportPlan = { writes: [], rows: [], skipped: [], invalid: [], unknownActions: [] };
export function planJetBrainsImport(bundle: JetBrainsSettings, editor: EditorState): JetBrainsImportPlan {
const plan: JetBrainsImportPlan = { writes: [], rows: [], skipped: [], invalid: [] };
const add = (key: string, value: string | number | boolean | undefined, label: string, shown?: string) => {
if (value === undefined) return;
plan.writes.push([key, value]);
@@ -179,63 +100,15 @@ export async function planJetBrainsImport(
if (id) add("editor.colorScheme", id, tx("Current color scheme"), customs[id]?.name);
}
let keymaps = current.customKeymaps ?? {};
const importedKeymaps = new Map<string, string>(); // name in the keymap file → keymap id
for (const [file, text] of Object.entries(bundle.files)) {
if (!file.startsWith("keymaps/")) continue;
let parsed;
try {
parsed = parseIdeaKeymap(text);
} catch {
plan.invalid.push(file.slice("keymaps/".length));
continue;
}
// Overwrites an earlier import of the same keymap, as colour schemes do.
const next = addIdeaKeymap(keymaps, parsed);
keymaps = next.customs;
importedKeymaps.set(parsed.name, next.id);
plan.unknownActions.push(...parsed.unknownActions.filter((id) => !plan.unknownActions.includes(id)));
plan.rows.push({ label: tx("Keymap"), value: keymaps[next.id]?.name ?? parsed.name });
}
if (importedKeymaps.size) {
plan.writes.push(["customKeymaps", keymaps]);
// The active keymap is stored per operating system; a bundled one keeps OpenIDEA's choice.
const os = { macos: "mac", windows: "windows", linux: "linux", web: "" }[guessOs()];
const active = options(bundle.files[`options/${os}/keymap.xml`], "KeymapManager", "active_keymap").get("");
const id = importedKeymaps.get(active ?? "");
if (id) add("keymap", id, tx("Current keymap"), keymaps[id]?.name);
}
const font = options(bundle.files["options/editor-font.xml"], "DefaultFont");
const family = font.get("FONT_FAMILY")?.trim() || undefined;
add("editor.fontFamily", family, tx("Font"));
add("editor.fontFamily", font.get("FONT_FAMILY")?.trim() || undefined, tx("Font"));
const size = num(font.get("FONT_SIZE"));
add("editor.fontSize", size, tx("Size"));
const spacing = num(font.get("LINE_SPACING"));
// IDEA spaces lines by the font's own height, not its size, so a tall font keeps its
// spacing; and the default spacing still applies when only the font changed.
const base = size ?? editor.fontSize;
if (base && (family || size || spacing)) {
const natural = (await fontHeight(family ?? editor.fontFamily, base)) ?? base * DEFAULT_LINE_SPACING;
add("editor.lineHeight", Math.ceil(natural * (spacing ?? DEFAULT_LINE_SPACING)), tx("Line height"));
}
add("editor.lineHeight", spacing && base ? Math.round(base * spacing) : undefined, tx("Line height"));
add("editor.ligatures", bool(font.get("USE_LIGATURES")), tx("Enable ligatures"));
const terminal = options(bundle.files["options/terminal-font.xml"], "TerminalFontOptions");
const terminalFamily = terminal.get("FONT_FAMILY")?.trim() || undefined;
const terminalSize = num(terminal.get("FONT_SIZE"));
// A terminal font of its own: stop following the editor font (the font rows below say so).
if (terminalFamily || terminalSize) plan.writes.push(["terminal.useEditorFont", false]);
add("terminal.fontFamily", terminalFamily, tx("Terminal font"));
add("terminal.fontSize", terminalSize, tx("Terminal font size"));
add("terminal.lineHeight", num(terminal.get("LINE_SPACING")), tx("Terminal line height"));
add("terminal.columnWidth", num(terminal.get("COLUMN_SPACING")), tx("Terminal column width"));
add(
"terminal.fallbackFontFamily",
terminal.get("SECONDARY_FONT_FAMILY")?.trim() || undefined,
tx("Terminal fallback font"),
);
const ed = options(bundle.files["options/editor.xml"], "EditorSettings");
const strip = ed.get("STRIP_TRAILING_SPACES"); // None | Changed | Whole
if (strip === "Changed" || strip === "Whole") {
@@ -262,95 +135,13 @@ export async function planJetBrainsImport(
wraps === undefined ? undefined : wraps.split(",").includes("MAIN_EDITOR"),
tx("Soft-wrap files"),
);
add(
"console.softWrap",
wraps === undefined ? undefined : wraps.split(",").includes("CONSOLE"),
tx("Use soft wraps in console"),
);
add("editor.general.softWrapFiles", ed.get("SOFT_WRAP_FILE_MASKS")?.trim() || undefined, tx("File patterns"));
const numeration = { ABSOLUTE: "Absolute", RELATIVE: "Relative", HYBRID: "Hybrid" }[ed.get("LINE_NUMERATION") ?? ""];
add("editor.appearance.lineNumberMode", numeration?.toLowerCase(), tx("Show line numbers"), tx(numeration ?? ""));
const above = bool(ed.get("SHOW_BREADCRUMBS_ABOVE"));
add(
"editor.breadcrumbs.placement",
above === undefined ? undefined : above ? "top" : "bottom",
tx("Show breadcrumbs:"),
tx(above ? "Top" : "Bottom"),
);
const insight = options(bundle.files["options/editor.xml"], "CodeInsightSettings");
for (const [source, flags, numbers] of [
[ed, EDITOR_FLAGS, EDITOR_NUMBERS],
[insight, CODE_INSIGHT_FLAGS, CODE_INSIGHT_NUMBERS],
] as const) {
for (const [name, [key, label]] of Object.entries(flags)) add(key, bool(source.get(name)), tx(label));
for (const [name, [key, label]] of Object.entries(numbers)) add(key, num(source.get(name)), tx(label));
}
const paste = REFORMAT_ON_PASTE[insight.get("REFORMAT_ON_PASTE") ?? ""];
add("editor.smartKeys.reformatOnPaste", paste?.[0], tx("Reformat on paste"), tx(paste?.[1] ?? ""));
const backspace = SMART_BACKSPACE[insight.get("SMART_BACKSPACE") ?? ""];
add("editor.smartKeys.backspaceUnindent", backspace?.[0], tx("Unindent"), tx(backspace?.[1] ?? ""));
// Tabs and Indents of the current code style scheme; its other formatting options have no setting here.
const schemeName =
options(bundle.files["options/code.style.schemes.xml"], "CodeStyleSchemeSettings").get("CURRENT_SCHEME_NAME") ??
"Default";
const scheme = codeScheme(bundle.files, schemeName);
if (scheme) {
const root = optionValues(scheme);
add("editor.codeStyle.hardWrapAt", num(root.get("RIGHT_MARGIN")), tx("Hard wrap at"));
add(
"editor.codeStyle.detectIndents",
bool(root.get("AUTODETECT_INDENTS")),
tx("Detect and use existing file indents for editing"),
);
// "Other File Types": the indent of languages without a code style of their own.
const other = optionValues(childOf(childOf(scheme, "option", "OTHER_INDENT_OPTIONS") ?? scheme, "value"));
add("editor.tabSize", num(other.get("TAB_SIZE")), tx("Tab size"));
const otherTabs = bool(other.get("USE_TAB_CHARACTER"));
add(
"editor.insertSpaces",
otherTabs === undefined ? undefined : !otherTabs,
tx("Use tab character"),
otherTabs === undefined ? undefined : onOff(otherTabs),
);
const languages = { ...editor.codeStyle?.languages };
let changed = false;
for (const block of Array.from(scheme.children)) {
const ids = CODE_STYLE_LANGUAGES[block.getAttribute("language") ?? ""];
if (block.tagName !== "codeStyleSettings" || !ids) continue;
const own = optionValues(block);
const indent = optionValues(childOf(block, "indentOptions"));
const style: Partial<LanguageCodeStyle> = {};
const shown: string[] = [];
const set = <K extends keyof LanguageCodeStyle>(
key: K,
value: LanguageCodeStyle[K] | undefined,
label: string,
) => {
if (value === undefined) return;
style[key] = value;
shown.push(`${tx(label)} ${typeof value === "boolean" ? onOff(value) : value}`);
};
set("indent", num(indent.get("INDENT_SIZE")), "Indent");
set("tabSize", num(indent.get("TAB_SIZE")), "Tab size");
set("useTab", bool(indent.get("USE_TAB_CHARACTER")), "Use tab character");
set("hardWrapAt", num(own.get("RIGHT_MARGIN")), "Hard wrap at");
set("lineCommentAtFirstColumn", bool(own.get("LINE_COMMENT_AT_FIRST_COLUMN")), "Line comment at first column");
set("lineCommentAddSpace", bool(own.get("LINE_COMMENT_ADD_SPACE")), "Add a space at line comment start");
if (!shown.length) continue;
for (const id of ids) languages[id] = { ...languages[id], ...style } as LanguageCodeStyle;
changed = true;
plan.rows.push({ label: `${tx("Code Style")} › ${block.getAttribute("language")}`, value: shown.join(", ") });
}
if (changed) plan.writes.push(["editor.codeStyle.languages", languages]);
}
const general = options(bundle.files["options/ide.general.xml"], "GeneralSettings");
add("general.confirmExit", bool(general.get("confirmExit")), tx("Confirm before exiting the IDE"));
const has = (prefix: string) => bundle.entries.some((e) => e.startsWith(prefix));
if (has("codestyles/")) plan.skipped.push(tx("Code Style options other than Tabs and Indents"));
if (has("keymaps/")) plan.skipped.push(tx("Keymap"));
if (has("codestyles/")) plan.skipped.push(tx("Code Style"));
if (has("templates/")) plan.skipped.push(tx("Live templates"));
if (has("inspection/")) plan.skipped.push(tx("Inspections"));
if (has("installed.txt")) plan.skipped.push(tx("Plugins"));
@@ -359,7 +150,6 @@ export async function planJetBrainsImport(
function Summary({ plan }: { plan: JetBrainsImportPlan }) {
const left = [...plan.skipped, ...plan.invalid];
const unknown = plan.unknownActions;
return (
<div className={styles.importSummary}>
<div>{tx("These settings will be imported:")}</div>
@@ -376,7 +166,6 @@ function Summary({ plan }: { plan: JetBrainsImportPlan }) {
{tx("Not imported:")} {left.join(", ")}
</div>
)}
{unknown.length > 0 && <div>{tx`Not available in OpenIDEA (${unknown.length}): ${unknown.join(", ")}.`}</div>}
</div>
);
}
@@ -384,7 +173,8 @@ function Summary({ plan }: { plan: JetBrainsImportPlan }) {
/** Reads `path`, asks, then writes the mapped settings to the global layer. */
export async function importJetBrainsSettings(path: string) {
const bundle = await call(commands.settingsReadJetbrains(path));
const plan = await planJetBrainsImport(bundle, await commands.settingsGetGlobal());
const { editor } = await commands.settingsGetGlobal();
const plan = planJetBrainsImport(bundle, editor);
if (!plan.writes.length) {
notifications().notify({
level: "warning",
+4 -53
Переглянути файл
@@ -8,7 +8,7 @@
* equivalent while the JS keymap stays the only dispatcher (see src-tauri/src/menu.rs).
*/
import { executeActionFrom, getAction, isActionEnabled, useActions } from "@/platform/actions";
import { getContext, useContextKeys } from "@/platform/context";
import { useContextKeys } from "@/platform/context";
import { keysWithPrefix, t, tx, useI18n } from "@/platform/i18n";
import { commands, isTauri, type DynamicItem, type MenuConfig, type MenuNode } from "@/platform/ipc";
import {
@@ -32,8 +32,6 @@ export const MENU_EVENT = "openidea://menu";
export interface MenuRoute {
action: string;
arg?: string | null;
/** The window in front when the item was chosen, if it is not this one (this window's Settings). */
returnTo?: string;
}
export function isMenuRoute(v: unknown): v is MenuRoute {
@@ -49,36 +47,6 @@ export function routeMenuEvent(
return run(payload.action, payload.arg ?? undefined);
}
/** How long an action chosen from the menu may take to open its dialog or popup. */
const OPEN_DELAY_MS = 300;
const layersClosed = () =>
new Promise<void>((resolve) => {
if (!getContext().popupOpen) return resolve();
const off = useContextKeys.subscribe((ctx) => {
if (ctx.popupOpen) return;
off();
resolve();
});
});
/**
* After an item chosen in this window's Settings window ran here (the backend brought this window
* forward): once the dialog or popup it opened closes, or right away if it opened none, Settings comes
* back to the front, as IDEA's Settings dialog stays under the dialogs opened from the menu. Not when
* focus has moved on (a new window, a native dialog).
*/
export async function returnFocusAfterMenu(
ran: Promise<boolean>,
focusWindow: () => Promise<void>,
delay = OPEN_DELAY_MS,
): Promise<void> {
await ran;
await new Promise((r) => setTimeout(r, delay));
await layersClosed();
if (document.hasFocus()) await focusWindow();
}
/**
* Keymap key names a macOS key equivalent can show. Mirrors the names muda's accelerator
* parser accepts: Tauri drops an accelerator it cannot parse, and the item shows no shortcut.
@@ -199,36 +167,22 @@ export function installMenuBridge(): () => void {
void import("@tauri-apps/api/webviewWindow").then(async ({ getCurrentWebviewWindow }) => {
// Window-scoped: a global `listen` would also receive other windows' menu events.
const off = await getCurrentWebviewWindow().listen(MENU_EVENT, ({ payload }) => {
const ran = routeMenuEvent(payload);
const returnTo = isMenuRoute(payload) ? payload.returnTo : undefined;
if (returnTo)
void returnFocusAfterMenu(ran, async () => {
const { Window } = await import("@tauri-apps/api/window");
await (await Window.getByLabel(returnTo))?.setFocus();
}).catch(() => {});
});
const off = await getCurrentWebviewWindow().listen(MENU_EVENT, ({ payload }) => void routeMenuEvent(payload));
if (disposed) off();
else unlisten = off;
});
// Enablement of the native items follows this window's context (IDEA greys out
// what cannot run). Recomputed shortly after context changes, sent only when it changed.
// Also once on blur: the menu still runs here while this window's Settings window is focused,
// with nothing focused here (editor actions disabled). The backend ignores it for other windows.
let ids: Set<string> | null = null;
let lastDisabled = "";
let forceEnablement = false;
let afterBlur = false;
let enableTimer: ReturnType<typeof setTimeout> | undefined;
const pushEnablement = (force = false, blurred = false) => {
const pushEnablement = (force = false) => {
forceEnablement ||= force;
afterBlur ||= blurred;
clearTimeout(enableTimer);
enableTimer = setTimeout(() => {
const unfocused = !document.hasFocus();
if (!ids || disposed || (unfocused && !afterBlur)) return;
afterBlur = false;
if (!ids || disposed || !document.hasFocus()) return;
const dynamic = Object.values(dynamicMenuItems()).flatMap((items) => items.map((d) => d.action));
const disabled = disabledMenuActions(new Set([...ids, ...dynamic]));
const key = disabled.join(",");
@@ -255,8 +209,6 @@ export function installMenuBridge(): () => void {
// The backend edits only submenus whose visible items changed, so switching project
// tabs does not redraw the macOS menu bar.
window.addEventListener("focus", onFocus);
const onBlur = () => pushEnablement(true, true);
window.addEventListener("blur", onBlur);
const unsubs = [
useI18n.subscribe((s, prev) => {
if (s.messages !== prev.messages) push();
@@ -285,7 +237,6 @@ export function installMenuBridge(): () => void {
clearTimeout(timer);
clearTimeout(enableTimer);
window.removeEventListener("focus", onFocus);
window.removeEventListener("blur", onBlur);
unlisten?.();
unsubs.forEach((u) => u());
};
+2 -13
Переглянути файл
@@ -130,17 +130,6 @@ export async function openPaths(
if (dir) await openProjectWithPolicy(dir);
}
/**
* `window_open_project`. When that may create a window, the trust question is asked here
* first (IntelliJ IDEA asks before the project frame opens): the new window would otherwise
* show its Welcome screen under the question. A WSL folder opens as a remote project, whose
* window asks about the distribution's folder itself.
*/
async function openProjectWindow(path: string, newWindow: boolean, files: readonly string[] = []) {
if (newWindow && !(await commands.wslResolve(path).catch(() => null))) await confirmProjectTrust(path, "local");
return call(commands.windowOpenProject(path, newWindow, [...files]));
}
/**
* Opens `path`, focusing the window that already has it. `newWindow`: always a
* new window; otherwise this window unless it already has a project or LightEdit
@@ -151,7 +140,7 @@ export async function openProjectInWindow(path: string, newWindow: boolean, file
const s = useProject.getState();
const inNew = newWindow || s.project !== null || s.lightEdit;
try {
const outcome = await openProjectWindow(path, inNew, files);
const outcome = await call(commands.windowOpenProject(path, inNew, [...files]));
if (outcome.kind === "current" && (await openHere(path))) await openInEditor(files);
} catch (e) {
openFailed(path, e);
@@ -546,7 +535,7 @@ export function windowActions(): Action[] {
const arg = c.arg as { path?: unknown; newWindow?: unknown } | null;
if (!arg || typeof arg.path !== "string" || typeof arg.newWindow !== "boolean") return;
try {
const outcome = await openProjectWindow(arg.path, arg.newWindow);
const outcome = await call(commands.windowOpenProject(arg.path, arg.newWindow, []));
if (outcome.kind === "current") await openHere(arg.path);
} catch (error) {
openFailed(arg.path, error);
+1 -4
Переглянути файл
@@ -5,7 +5,6 @@ import { call, commands, onIdeEvent, type TrustDecisions, type TrustStatus } fro
import { dirname, useProject } from "@/platform/project";
import { initializeRemoteTrustMigration, isRemoteRoot } from "@/platform/remote";
import { provideProjectTrustPrompt, type ProjectTrustScope } from "@/platform/projectTrust";
import { askOverSplash } from "@/platform/splash";
import { invokeLocal } from "@/platform/tauriCore";
import { registerOverlay, registerSettingsPage, registerWorkbenchBanner } from "@/workbench/contributions";
import { Button, Checkbox, Dialog, T } from "@/ui";
@@ -210,7 +209,7 @@ async function decide(trusted: boolean) {
function promptForTrust(status: TrustStatus, scope: ProjectTrustScope): Promise<boolean> {
usePrompt.getState().finish?.(false);
const answer = new Promise<boolean>((resolve) =>
return new Promise<boolean>((resolve) =>
usePrompt.setState({
path: status.root,
scope,
@@ -221,8 +220,6 @@ function promptForTrust(status: TrustStatus, scope: ProjectTrustScope): Promise<
},
}),
);
askOverSplash(answer);
return answer;
}
async function trustProject() {
-17
Переглянути файл
@@ -224,20 +224,3 @@ it.each([false, true])("recovers an attached member whose trust is lost (decided
await act(async () => {});
expect(decide).toHaveBeenCalledWith("/other", true, false);
});
it("asks over the splash of a window launched for an untrusted project, not over its Welcome screen", async () => {
const splash = document.createElement("div");
splash.id = "splash";
document.body.append(splash);
try {
render(<OverlayHost />);
vi.mocked(invokeLocal).mockResolvedValue({ root: "/launched", trusted: false, decided: false });
const opening = confirmProjectTrust("/launched", "local").catch(() => "cancelled");
await screen.findByRole("dialog");
expect(splash.classList.contains("splash-under-dialogs")).toBe(true);
fireEvent.click(screen.getByRole("button", { name: "Don't Open" }));
expect(await opening).toBe("cancelled");
} finally {
splash.remove();
}
});
-94
Переглянути файл
@@ -1,94 +0,0 @@
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { act, fireEvent, render, screen } from "@testing-library/react";
import type { Sdk, Settings } from "@/platform/ipc";
const open = vi.fn();
const JDK: Sdk = {
path: "/opt/jdks/acme-17/Contents/Home",
name: "Acme 17.0.9",
version: "17.0.9",
source: "system",
home: "/opt/jdks/acme-17/Contents/Home",
extra: null,
};
vi.mock("@/platform/dialog", () => ({ open: (...args: unknown[]) => open(...args) }));
vi.mock("@/platform/ipc", async (importOriginal) => {
const real = await importOriginal<typeof import("@/platform/ipc")>();
return {
...real,
isTauri: () => true,
commands: {
...real.commands,
sdkDetect: vi.fn(async () => ({ status: "ok", data: [] })),
sdkJdkAt: vi.fn(async (path: string) => ({
status: "ok",
data: path.startsWith("/opt/jdks/acme-17") ? JDK : null,
})),
settingsSet: vi.fn(async () => ({ status: "ok", data: {} })),
settingsGet: vi.fn(async () => ({})),
settingsGetGlobal: vi.fn(async () => ({})),
},
};
});
import { useProject } from "@/platform/project";
import { useContextMenuStore } from "@/ui/Menu";
import { DEFAULT_SETTINGS } from "../model/schema";
import { openProjectStructure, stagedValue, useSettingsDialog } from "../model/staging";
import { ProjectStructureDialog } from "../languages/ProjectStructurePage";
import { useSdks } from "../languages/api";
function addMenuItem(label: string) {
fireEvent.click(screen.getByRole("button", { name: "Add SDK" }));
const item = useContextMenuStore.getState().menu?.items.find((i) => "label" in i && i.label === label) as
| { run?: () => void }
| undefined;
expect(item?.run).toBeDefined();
item!.run!();
}
const added = () => stagedValue(useSettingsDialog.getState(), "global", "languages.java.addedJdks");
beforeEach(() => {
open.mockReset();
useSdks.setState({ byKind: {}, loading: {}, errors: {} });
useProject.setState({
settings: structuredClone(DEFAULT_SETTINGS) as Settings,
project: { name: "demo", root: "/project" } as never,
});
render(<ProjectStructureDialog />);
act(() => openProjectStructure("sdks"));
});
afterEach(() => {
act(() => useSettingsDialog.setState({ projectStructureOpen: false }));
useProject.setState({ project: null, settings: null });
});
describe("SDKs › Add JDK from Disk…", () => {
it("adds the picked JDK home to the list and the global settings, and removes it again", async () => {
open.mockResolvedValue("/opt/jdks/acme-17");
await act(async () => addMenuItem("Add JDK from Disk…"));
expect(open).toHaveBeenCalledWith(expect.objectContaining({ directory: true }));
expect(screen.getAllByText("Acme 17.0.9").length).toBeGreaterThan(0);
expect(added()).toEqual([JDK.path]);
fireEvent.click(screen.getByRole("button", { name: "Remove SDK" }));
expect(screen.queryByText("Acme 17.0.9")).not.toBeInTheDocument();
expect(added()).toEqual([]);
});
it("refuses a folder that is no JDK home", async () => {
open.mockResolvedValue("/tmp/not-a-jdk");
await act(async () => addMenuItem("Add JDK from Disk…"));
expect(screen.getByRole("alert")).toHaveTextContent("The selected directory is not a valid home for JDK");
expect(added() ?? []).toEqual([]);
});
it("keeps detected SDKs from being removed", async () => {
await act(async () => useSdks.setState({ byKind: { jdk: [JDK] } }));
fireEvent.click(screen.getByRole("option", { name: /Acme 17\.0\.9/ }));
expect(screen.getByRole("button", { name: "Remove SDK" })).toBeDisabled();
});
});
+1 -5
Переглянути файл
@@ -1,6 +1,6 @@
import { describe, expect, it } from "vitest";
import { normalizeBinding } from "@/platform/keymap";
import { fromSwingStroke, parseIdeaKeymap } from "./ideaKeymap";
import { fromSwingStroke, parseIdeaKeymap } from "../keymap/ideaKeymapImport";
describe("IntelliJ IDEA keymap import", () => {
it("converts Swing keystrokes", () => {
@@ -8,10 +8,6 @@ describe("IntelliJ IDEA keymap import", () => {
expect(fromSwingStroke("ctrl pressed OPEN_BRACKET")).toBe("Ctrl+[");
expect(fromSwingStroke("F12")).toBe("F12");
expect(fromSwingStroke("alt BACK_SPACE")).toBe("Alt+Backspace");
// As IDEA saves a user's keymap.
expect(fromSwingStroke("ctrl right")).toBe("Ctrl+Right");
expect(fromSwingStroke("shift ctrl alt s")).toBe("Shift+Ctrl+Alt+S");
expect(fromSwingStroke("meta back_slash")).toBe("Meta+\\");
expect(fromSwingStroke("meta NUMPAD5")).toBeNull();
expect(fromSwingStroke("hyper A")).toBeNull();
});
+1 -1
Переглянути файл
@@ -53,7 +53,7 @@ import {
} from "./model";
import { groupIcon, groupPath, groupRank } from "./groups";
import { KeymapNameDialog } from "./KeymapDialogs";
import { parseIdeaKeymap } from "@/platform/ideaKeymap";
import { parseIdeaKeymap } from "./ideaKeymapImport";
import { RecordShortcutDialog } from "./RecordShortcutDialog";
import { StrokeRecorder } from "./StrokeRecorder";
import styles from "./Keymap.module.css";
+4 -28
Переглянути файл
@@ -4,16 +4,8 @@
* parent; each listed action's shortcuts replace the parent's.
*/
import { IDEA_ACTIONS } from "@/platform/ideaActions";
import type { CustomKeymap } from "@/bindings";
import {
customKeymapId,
defaultPreset,
isValidBinding,
normalizeBinding,
PRESET_TITLES,
withBindings,
type Keymap,
} from "@/platform/keymap";
import { defaultPreset, isValidBinding, normalizeBinding, type Keymap } from "@/platform/keymap";
import { withBindings } from "./model";
export interface ImportedIdeaKeymap {
name: string;
@@ -75,16 +67,13 @@ const SWING_KEYS: Record<string, string> = {
const SWING_MODS: Record<string, string> = { shift: "Shift", ctrl: "Ctrl", control: "Ctrl", alt: "Alt", meta: "Meta" };
/**
* `"shift meta O"` / `"ctrl pressed OPEN_BRACKET"` → `"Meta+Shift+O"`, or null when not expressible.
* Bundled keymaps name keys in upper case; the keymaps IDEA saves for the user are all lower case (`"ctrl right"`).
*/
/** `"shift meta O"` / `"ctrl pressed OPEN_BRACKET"` → `"Meta+Shift+O"`, or null when not expressible. */
export function fromSwingStroke(stroke: string): string | null {
const words = stroke
.trim()
.split(/\s+/)
.filter((w) => !/^(pressed|released|typed)$/i.test(w));
const key = words.pop()?.toUpperCase();
const key = words.pop();
if (!key || words.some((w) => !SWING_MODS[w.toLowerCase()])) return null;
const name = /^([A-Z0-9]|F\d{1,2})$/.test(key) ? key : SWING_KEYS[key];
return name ? [...words.map((w) => SWING_MODS[w.toLowerCase()]), name].join("+") : null;
@@ -145,16 +134,3 @@ export function parseIdeaKeymap(xml: string): ImportedIdeaKeymap {
skippedShortcuts,
};
}
/**
* Adds a parsed keymap to the user keymaps under its own name, replacing an
* earlier import of the same name (a name a bundled keymap has gets a suffix).
*/
export function addIdeaKeymap(
customs: Record<string, CustomKeymap>,
parsed: ImportedIdeaKeymap,
): { id: string; customs: Record<string, CustomKeymap> } {
const name = Object.values(PRESET_TITLES).includes(parsed.name) ? `${parsed.name} (JetBrains)` : parsed.name;
const id = Object.keys(customs).find((k) => customs[k]?.name === name) ?? customKeymapId(name, customs);
return { id, customs: { ...customs, [id]: { name, parent: parsed.parent, overrides: parsed.overrides } } };
}
+39 -13
Переглянути файл
@@ -5,19 +5,23 @@
*/
import type { Action } from "@/platform/actions";
import { evaluateWhen, type ContextKeys } from "@/platform/context";
import {
customKeymapId,
defaultPreset,
normalizeBinding,
presetBindings,
PRESET_TITLES,
PRESETS,
withBindings,
type Keymap,
type KeymapDraft,
} from "@/platform/keymap";
import { defaultPreset, normalizeBinding, PRESET_TITLES, PRESETS, useKeymap, type Keymap } from "@/platform/keymap";
export { presetBindings, withBindings, type KeymapDraft };
export interface KeymapDraft {
preset: string;
overrides: Keymap;
}
/**
* The defaults of `id`: the preset's, or for an action the preset leaves out,
* the shortcut its plugin declares (`keymaps`). Removing or changing one is an
* override like any other.
*/
export function presetBindings(preset: string, id: string): string[] {
const own = PRESETS[preset];
const keys = own && id in own ? own[id] : useKeymap.getState().extensions?.[id];
return (keys ?? []).map(normalizeBinding);
}
export function resolveBindings(draft: KeymapDraft, id: string): string[] {
return draft.overrides[id]?.map(normalizeBinding) ?? presetBindings(draft.preset, id);
@@ -37,6 +41,17 @@ export function isModified(draft: KeymapDraft, id: string): boolean {
return id in draft.overrides;
}
const sameList = (a: readonly string[], b: readonly string[]) => a.length === b.length && a.every((x, i) => x === b[i]);
/** Sets the full binding list of `id`; drops the override when it equals the preset. */
export function withBindings(draft: KeymapDraft, id: string, bindings: readonly string[]): Keymap {
const list = [...new Set(bindings.map(normalizeBinding))];
const overrides = { ...draft.overrides };
if (sameList(list, presetBindings(draft.preset, id))) delete overrides[id];
else overrides[id] = list;
return overrides;
}
export function addBinding(draft: KeymapDraft, id: string, binding: string): Keymap {
return withBindings(draft, id, [...resolveBindings(draft, id), binding]);
}
@@ -220,13 +235,24 @@ export function validateKeymapName(name: string, customs: CustomKeymaps, ownId?:
return clash ? `Keymap '${n}' already exists` : null;
}
function newKeymapId(name: string, customs: CustomKeymaps): string {
const slug =
name
.toLowerCase()
.replace(/[^a-z0-9]+/g, "-")
.replace(/^-|-$/g, "") || "keymap";
let id = `custom.${slug}`;
for (let i = 2; customs[id] || PRESETS[id]; i++) id = `custom.${slug}-${i}`;
return id;
}
/** Copies the selected keymap (its effective overrides) under `name`; returns the new id. */
export function duplicateKeymap(
draft: KeymapDraft,
customs: CustomKeymaps,
name: string,
): { id: string; customs: CustomKeymaps } {
const id = customKeymapId(name, customs);
const id = newKeymapId(name, customs);
return {
id,
customs: { ...customs, [id]: { name: name.trim(), parent: draft.preset, overrides: { ...draft.overrides } } },
+8 -60
Переглянути файл
@@ -28,7 +28,7 @@ import { call, commands, isTauri, nextRequestId, type FileEntry } from "@/platfo
import { mergeLibraryGroups } from "@/platform/libraries";
import type { BuildModel, LibraryGroup, WebArtifact } from "@/bindings";
import { relativePath, useProject } from "@/platform/project";
import { PageContext, useSetting, useSettingsFormFor } from "../components/context";
import { PageContext, useSettingsFormFor } from "../components/context";
import {
applySettings,
closeProjectStructure,
@@ -61,7 +61,7 @@ import {
} from "@/platform/languageSettings";
import { initProjectRoots, useDetectedRoots } from "@/platform/projectRoots";
import { Row, Section } from "../components/Form";
import { detectSdks, forgetSdk, rememberSdk, useSdks, type SdkKind } from "./api";
import { detectSdks, useSdks, type SdkKind } from "./api";
import { choosePath } from "@/platform/choosePath";
import { DownloadJdkDialog } from "./DownloadJdkDialog";
import { SdkField, tildify, useDetected, useJdtlsJdk, useProjectSetting } from "./components";
@@ -1790,31 +1790,8 @@ function SdksSection() {
const [downloading, setDownloading] = useState(false);
const [selectedKey, setSelectedKey] = useState<string>("");
const [projectJdk, setProjectJdk] = useProjectSetting<string>("languages.java.jdk");
const [addedJdks, setAddedJdks] = useSetting<string[] | undefined>("languages.java.addedJdks", "global");
const [addError, setAddError] = useState<string | null>(null);
useDetected("jdk");
const addJdkFromDisk = async () => {
setAddError(null);
const picked = await choosePath({ directory: true, title: tx("Select Home Directory for JDK") });
if (!picked) return;
const sdk = await call(commands.sdkJdkAt(picked)).catch(() => null);
if (!sdk) {
setAddError(tx`The selected directory is not a valid home for JDK: ${tildify(picked)}`);
return;
}
const added = addedJdks ?? [];
if (!added.includes(sdk.path)) setAddedJdks([...added, sdk.path]);
rememberSdk("jdk", { ...sdk, source: "added" });
setSelectedKey(`jdk:${sdk.path}`);
};
const removeAddedJdk = (path: string) => {
setAddedJdks((addedJdks ?? []).filter((p) => p !== path));
forgetSdk("jdk", path);
setSelectedKey("");
};
useEffect(() => {
for (const { kind } of SDK_KINDS) {
void detectSdks(kind);
@@ -1828,15 +1805,8 @@ function SdksSection() {
};
const rows = useMemo(() => {
const out: Array<{
key: string;
kind: SdkKind;
kindLabel: string;
name: string;
version: string;
path: string;
added: boolean;
}> = [];
const out: Array<{ key: string; kind: SdkKind; kindLabel: string; name: string; version: string; path: string }> =
[];
for (const { kind, label } of SDK_KINDS) {
for (const sdk of byKind[kind] ?? []) {
out.push({
@@ -1846,12 +1816,11 @@ function SdksSection() {
name: sdk.name,
version: sdk.version ?? "",
path: sdk.path,
added: kind === "jdk" && (sdk.source === "added" || (addedJdks ?? []).includes(sdk.path)),
});
}
}
return out;
}, [byKind, addedJdks]);
}, [byKind]);
const activeSdk = rows.find((r) => r.key === selectedKey) ?? rows[0];
@@ -1860,33 +1829,12 @@ function SdksSection() {
<div className={styles.splitLayout}>
<div className={styles.sideList}>
<div className={styles.tableToolbar}>
<IconButton
icon="plus"
size="small"
title="Add SDK"
onClick={(e) => {
const r = e.currentTarget.getBoundingClientRect();
showContextMenu({ x: r.left, y: r.bottom + 2 }, [
{ label: tx("Download JDK…"), icon: "download", run: () => setDownloading(true) },
{ label: tx("Add JDK from Disk…"), icon: "folder-open", run: () => void addJdkFromDisk() },
]);
}}
/>
<IconButton
icon="minus"
size="small"
title="Remove SDK"
disabled={!activeSdk?.added}
onClick={() => activeSdk && removeAddedJdk(activeSdk.path)}
/>
<Button size="small" variant="ghost" icon="plus" onClick={() => setDownloading(true)}>
<T>Download JDK…</T>
</Button>
<span className={styles.spacer} />
<IconButton icon="refresh" size="small" title="Detect again" onClick={refreshAll} />
</div>
{addError && (
<div className={styles.error} role="alert">
{addError}
</div>
)}
<div className={styles.sideItems} role="listbox" aria-label={tx("SDKs")}>
{rows.length === 0 && (
<div className={styles.empty}>
-5
Переглянути файл
@@ -63,11 +63,6 @@ export function detectSdks(kind: SdkKind, force = false): Promise<Sdk[]> {
return p;
}
/** Drops an SDK (e.g. a JDK added by hand, then removed) from the cached list. */
export function forgetSdk(kind: SdkKind, path: string) {
useSdks.setState((s) => ({ byKind: { ...s.byKind, [kind]: (s.byKind[kind] ?? []).filter((x) => x.path !== path) } }));
}
/** Adds an SDK (e.g. a just-created virtualenv) to the cached list. */
export function rememberSdk(kind: SdkKind, sdk: Sdk) {
const remember = () =>
-1
Переглянути файл
@@ -128,7 +128,6 @@ function pendingTool(name: string, entry: ServerEntry, languages: string[]): Too
defaultArgs: [],
defaultInitializationOptions: null,
alternatives: [],
companion: false,
};
}
-17
Переглянути файл
@@ -225,7 +225,6 @@ describe("missing language server prompt", () => {
installMethod: "uv (virtualenv)",
languages: ["Python"],
alternatives: [],
companion: false,
});
await promptInstall("ruff", true, new Set(), true);
expect(notes.at(-1)).toMatchObject({
@@ -235,22 +234,6 @@ describe("missing language server prompt", () => {
});
});
it("doesn't offer a companion server (refactorings only) when it is missing", async () => {
const template = sampleTools()[0]!;
backend.tools.push({
...template,
name: "pylsp",
displayName: "pylsp-rope (Python refactorings)",
command: "pylsp",
status: "missing",
languages: ["Rope Only"],
alternatives: [],
companion: true,
});
expect(await promptInstall("pylsp")).toBe(false);
expect(notes).toEqual([]);
});
it("stays silent when an installed alternative serves the same languages", async () => {
const off = installMissingServerPrompts();
// typescript-language-server (on PATH) covers vtsls' languages.
-1
Переглянути файл
@@ -72,7 +72,6 @@ function tool(partial: Partial<ToolInfo> & Pick<ToolInfo, "name" | "languages">)
defaultArgs: [],
defaultInitializationOptions: null,
alternatives: [],
companion: false,
...partial,
};
}
+2 -2
Переглянути файл
@@ -15,7 +15,7 @@ export const missingKey = (name: string) => `lsp-missing-${name}`;
/**
* `offered`: servers already offered for install. A fallback of one of them (pyright
* after basedpyright) stays quiet: installing the first is enough, and the Language
* Servers… page offers the others. So does a companion server (pylsp-rope's refactorings).
* Servers… page offers the others.
*/
export async function promptInstall(
name: string,
@@ -25,7 +25,7 @@ export async function promptInstall(
): Promise<boolean> {
if (!useTools.getState().loaded) await refreshTools();
const tool = toolByName(name);
if (!tool || !tool.canInstall || tool.status !== "missing" || tool.companion) return false;
if (!tool || !tool.canInstall || tool.status !== "missing") return false;
const position = tool.alternatives.indexOf(name);
if (position > 0 && tool.alternatives.slice(0, position).some((n) => offered.has(n))) return false;
formatter ||= tool.kind === "formatter";
+30 -16
Переглянути файл
@@ -1,9 +1,8 @@
/**
* CodeMirror setup for the VCS viewers (diff, merge, local history): token
* based theme + syntax colours and lazy language loading through the editor's
* language pipeline, so colours match the editor.
* based theme + syntax colours and lazy language loading by file name.
*/
import { syntaxHighlighting, type LanguageSupport } from "@codemirror/language";
import { HighlightStyle, LanguageDescription, syntaxHighlighting, type LanguageSupport } from "@codemirror/language";
import {
Compartment,
EditorState,
@@ -33,9 +32,8 @@ import {
import { getChunks, mergeViewSiblings, type Chunk } from "@codemirror/merge";
import { defaultKeymap } from "@codemirror/commands";
import { search, searchKeymap } from "@codemirror/search";
import { tags as t } from "@lezer/highlight";
import { scrollbarMarks, type ScrollbarMark } from "@/editor/api";
import { openideaHighlightStyle } from "@/editor/core/cm/highlight";
import { findLanguageDescription, loadSupport, uiModeForPath } from "@/editor/core/cm/languages";
import { findExtension } from "@/editor/core/cm/find";
import { overviewLane, overviewLaneIn } from "@/editor/core/cm/lanes";
import { LINE_INSET } from "@/editor/core/cm/lineInset";
@@ -296,6 +294,26 @@ export const diffWords: Extension = [
EditorView.editorAttributes.of({ class: "cm-diffWords" }),
];
export const viewerHighlight = HighlightStyle.define([
{
tag: [t.keyword, t.modifier, t.controlKeyword, t.operatorKeyword, t.definitionKeyword],
color: "var(--syn-keyword)",
},
{ tag: [t.string, t.special(t.string), t.regexp, t.character], color: "var(--syn-string)" },
{ tag: [t.typeName, t.className, t.namespace, t.tagName], color: "var(--syn-type)" },
{ tag: [t.function(t.variableName), t.function(t.propertyName)], color: "var(--syn-function)" },
{ tag: [t.comment, t.lineComment, t.blockComment, t.docComment], color: "var(--syn-comment)", fontStyle: "italic" },
{ tag: [t.annotation, t.meta, t.attributeName], color: "var(--syn-annotation)" },
{ tag: [t.number, t.bool, t.null, t.atom], color: "var(--syn-number)" },
{ tag: [t.constant(t.variableName), t.standard(t.variableName)], color: "var(--syn-constant)" },
{ tag: [t.punctuation, t.bracket, t.operator], color: "var(--syn-punct)" },
{ tag: [t.propertyName], color: "var(--syn-property)" },
{ tag: [t.variableName], color: "var(--syn-variable)" },
{ tag: t.invalid, color: "var(--syn-invalid)" },
{ tag: t.heading, fontWeight: "var(--fw-code-bold, 700)", color: "var(--fg-strong)" },
{ tag: t.link, color: "var(--link)", textDecoration: "underline" },
]);
export const viewerTheme = EditorView.theme(
{
...overviewStyles,
@@ -512,7 +530,7 @@ export function viewerBase(opts: {
opts.findBar
? [findExtension(), keymap.of(defaultKeymap)]
: [search({ top: true }), keymap.of([...searchKeymap, ...defaultKeymap])],
syntaxHighlighting(openideaHighlightStyle),
syntaxHighlighting(viewerHighlight),
viewerTheme,
changedLines,
EditorState.readOnly.of(opts.readOnly),
@@ -522,22 +540,18 @@ export function viewerBase(opts: {
];
}
let languagesPromise: Promise<readonly LanguageDescription[]> | null = null;
const cache = new Map<string, Promise<LanguageSupport | null>>();
/**
* Loads the language for `fileName` through the editor's pipeline
* (`findLanguageDescription` + `loadSupport`): the same modes, tag patches and
* `data-language` attribute as the editor, so colours match. Unknown
* extensions resolve like the editor's (null once the backend languages are
* loaded, file-name match before that).
*/
/** Loads the language for `fileName` (by extension / name), or null. */
export function languageFor(fileName: string): Promise<LanguageSupport | null> {
const name = fileName.slice(fileName.lastIndexOf("/") + 1);
const hit = cache.get(name);
if (hit) return hit;
const p = Promise.resolve(uiModeForPath(fileName))
.then((uiMode) => findLanguageDescription(uiMode ?? null, fileName))
.then((desc) => (desc ? loadSupport(desc) : null))
languagesPromise ??= import("@codemirror/language-data").then((m) => m.languages);
const p = languagesPromise
.then((langs) => LanguageDescription.matchFilename(langs, name))
.then((desc) => (desc ? desc.load() : null))
.catch(() => null);
cache.set(name, p);
return p;
-1
Переглянути файл
@@ -12,7 +12,6 @@ export const DEFAULT_IGNORED_NAMES: readonly string[] = [
".git",
".hg",
".jj",
".ropeproject",
".svn",
"CVS",
"__pycache__",
-40
Переглянути файл
@@ -730,43 +730,3 @@ export function installKeyboardDispatcher(
target.removeEventListener("blur", onBlur);
};
}
/** A keymap being edited: a bundled preset and the overrides on top of it. */
export interface KeymapDraft {
preset: string;
overrides: Keymap;
}
/**
* The defaults of `id`: the preset's, or for an action the preset leaves out,
* the shortcut its plugin declares (`keymaps`). Removing or changing one is an
* override like any other.
*/
export function presetBindings(preset: string, id: string): string[] {
const own = PRESETS[preset];
const keys = own && id in own ? own[id] : useKeymap.getState().extensions?.[id];
return (keys ?? []).map(normalizeBinding);
}
const sameList = (a: readonly string[], b: readonly string[]) => a.length === b.length && a.every((x, i) => x === b[i]);
/** Sets the full binding list of `id`; drops the override when it equals the preset. */
export function withBindings(draft: KeymapDraft, id: string, bindings: readonly string[]): Keymap {
const list = [...new Set(bindings.map(normalizeBinding))];
const overrides = { ...draft.overrides };
if (sameList(list, presetBindings(draft.preset, id))) delete overrides[id];
else overrides[id] = list;
return overrides;
}
/** A free id for a user keymap called `name`. */
export function customKeymapId(name: string, customs: Record<string, unknown>): string {
const slug =
name
.toLowerCase()
.replace(/[^a-z0-9]+/g, "-")
.replace(/^-|-$/g, "") || "keymap";
let id = `custom.${slug}`;
for (let i = 2; customs[id] || PRESETS[id]; i++) id = `custom.${slug}-${i}`;
return id;
}
+1 -11
Переглянути файл
@@ -465,8 +465,6 @@
"These settings will be imported:": "These settings will be imported:",
"Not imported:": "Not imported:",
"Current color scheme": "Current color scheme",
"Current keymap": "Current keymap",
"Code Style options other than Tabs and Indents": "Code Style options other than Tabs and Indents",
"No settings OpenIDEA can import were found": "No settings OpenIDEA can import were found",
"Overwrite existing branch": "Overwrite existing branch",
"Unset upstream branch": "Unset upstream branch",
@@ -2004,13 +2002,5 @@
"Target": "Target",
"Foreign Keys": "Foreign Keys",
"Indexes": "Indexes",
"Columns": "Columns",
"Add JDK from Disk…": "Add JDK from Disk…",
"Select Home Directory for JDK": "Select Home Directory for JDK",
"The selected directory is not a valid home for JDK: {path}": "The selected directory is not a valid home for JDK: {path}",
"Add SDK": "Add SDK",
"Remove SDK": "Remove SDK",
"{rel} is added to your request": "{rel} is added to your request",
"IDE Context Enabled: the current file and selection are added to your request": "IDE Context Enabled: the current file and selection are added to your request",
"IDE Context Disabled: the current file and selection are not added to your request": "IDE Context Disabled: the current file and selection are not added to your request"
"Columns": "Columns"
}
+1 -11
Переглянути файл
@@ -3512,8 +3512,6 @@
"These settings will be imported:": "将导入以下设置:",
"Not imported:": "不导入:",
"Current color scheme": "当前配色方案",
"Current keymap": "当前按键映射",
"Code Style options other than Tabs and Indents": "制表符和缩进以外的代码样式选项",
"No settings OpenIDEA can import were found": "没有找到 OpenIDEA 可以导入的设置",
"Rename Project": "重命名项目",
"Rename Project…": "重命名项目…",
@@ -8392,13 +8390,5 @@
"Only in target": "仅在目标中",
"Different": "不同",
"Foreign Keys": "外键",
"Indexes": "索引",
"Add JDK from Disk…": "从磁盘添加 JDK…",
"Select Home Directory for JDK": "选择 JDK 主目录",
"The selected directory is not a valid home for JDK: {path}": "所选目录不是有效的 JDK 主目录:{path}",
"Add SDK": "添加 SDK",
"Remove SDK": "移除 SDK",
"{rel} is added to your request": "{rel} 会添加到你的请求中",
"IDE Context Enabled: the current file and selection are added to your request": "IDE 上下文已启用:当前文件和所选内容会添加到你的请求中",
"IDE Context Disabled: the current file and selection are not added to your request": "IDE 上下文已禁用:当前文件和所选内容不会添加到你的请求中"
"Indexes": "索引"
}
-39
Переглянути файл
@@ -1,39 +0,0 @@
import { afterEach, beforeEach, expect, it, vi } from "vitest";
beforeEach(() => {
vi.useFakeTimers({ toFake: ["setTimeout", "requestAnimationFrame"] });
vi.resetModules();
document.body.innerHTML = '<div id="splash" class="splash"></div>';
});
afterEach(() => vi.useRealTimers());
const splash = () => document.getElementById("splash");
it("gives up on a slow launch after its time limit", async () => {
const { holdSplash, hideSplash } = await import("./splash");
holdSplash(new Promise(() => {}));
hideSplash();
await vi.advanceTimersByTimeAsync(5000);
expect(splash()).toBeNull();
});
it("stays up, under dialogs, until a question asked while the window opens is answered", async () => {
const { askOverSplash, holdSplash, hideSplash } = await import("./splash");
let answer!: (open: boolean) => void;
const question = new Promise<boolean>((resolve) => (answer = resolve));
holdSplash(question);
hideSplash();
askOverSplash(question);
expect(splash()?.classList.contains("splash-under-dialogs")).toBe(true);
await vi.advanceTimersByTimeAsync(60_000);
expect(splash()).not.toBeNull();
answer(false);
await vi.advanceTimersByTimeAsync(1000);
expect(splash()).toBeNull();
});
it("leaves a page without a splash alone", async () => {
document.body.innerHTML = "";
const { askOverSplash } = await import("./splash");
expect(() => askOverSplash(Promise.resolve(true))).not.toThrow();
});
+3 -19
Переглянути файл
@@ -20,21 +20,6 @@ function completeBar(el: HTMLElement): boolean {
return true;
}
const questions = new Set<Promise<unknown>>();
/**
* Keeps the splash up, past its time limit, until the user answers `question` in a dialog
* shown over it: a window launched for an untrusted project (`openidea <path>`) asks
* before anything of the window shows, never over its Welcome screen.
*/
export function askOverSplash(question: Promise<unknown>): void {
const el = document.getElementById("splash");
if (!el || el.classList.contains("splash-out")) return;
el.classList.add("splash-under-dialogs");
const answered: Promise<unknown> = question.catch(() => {}).finally(() => questions.delete(answered));
questions.add(answered);
}
/** Keeps the splash up until `work` settles. Call before `hideSplash()`. */
export function holdSplash(work: Promise<unknown>): void {
holds.push(work.catch(() => {}));
@@ -45,8 +30,7 @@ export function hideSplash(): void {
const el = document.getElementById("splash");
if (!el) return;
const timeout = new Promise((resolve) => setTimeout(resolve, MAX_WAIT_MS));
void Promise.race([Promise.all(holds), timeout]).then(async () => {
while (questions.size) await Promise.all(questions);
void Promise.race([Promise.all(holds), timeout]).then(() =>
// Two frames: let React commit the state the holds produced before uncovering it.
requestAnimationFrame(() =>
requestAnimationFrame(() => {
@@ -63,6 +47,6 @@ export function hideSplash(): void {
completeBar(el) ? FILL_MS : 0,
);
}),
);
});
),
);
}